public ActionResult Run()
{
// Set the base path of the web application.
path = Server.MapPath("~/");
// Deserialize the installer.config xml file.
InstallerConfig config = Serializer <InstallerConfig> .Deserialize(path + @"installer.config");
config.Path.AppPath = path; // set this for internal processing.
JsonResponse json = new JsonResponse();
try
{
// Run the installer.
InstallWizard.Run(config);
json.Success = true;
json.Message = "The installer completed successfully!";
}
catch (Exception ex)
{
json.Success = false;
json.Message = ex.Message;
}
return(Json(json));
}
public string GetConnString(InstallerConfig config, string dbName)
{
string connString = string.Empty;
//if (config.Database.UseSqlCe40)
//{
// connString = SqlCeConnection(config);
//}
//else
//{
// // For standard connections.
// connString = NamedDbConnection(config, dbName);
//}
/* Update by King Wilder
* Date: November 22, 2011
* This uses the new ConnectionFactory to generate proper connection strings based
* on the incoming parameters in the InstallerConfig object.
*/
ConnectionFactory factory = new ConnectionFactory(config);
connString = factory.ConnectionString();
return(connString);
}
public void TestMethod1()
{
//System.Configuration.Configuration configSection = ConfigurationManager.OpenExeConfiguration(System.IO.Path.Combine(AppDomain.CurrentDomain.BaseDirectory, "MvcInstallerV3.UnitTests.dll.config"));
Configuration configSection = ConfigurationManager.OpenExeConfiguration(ConfigurationUserLevel.None);
//Configuration configSection = WebConfigurationManager.OpenWebConfiguration(null);
if (configSection == null)
{
throw new InvalidOperationException("Configuration file not available.");
}
InstallerConfig config = Serializer <InstallerConfig> .Deserialize(AppDomain.CurrentDomain.BaseDirectory + @"\installer.config");
IConnectionStringComponent component = new ConnectionStringComponent(config);
IConfigurationFactory factory = new ConfigurationFactory(component);
factory.Execute(config, configSection);
Console.WriteLine("Before save...");
var result = configSection.ConnectionStrings.ConnectionStrings[0].ConnectionString;
Console.WriteLine(result);
configSection.Save();
Console.WriteLine("After save...");
result = configSection.ConnectionStrings.ConnectionStrings[0].ConnectionString;
Console.WriteLine(result);
string connString = configSection.ConnectionStrings.ConnectionStrings[0].ConnectionString;
Console.WriteLine(connString);
}
/// <summary>
/// Run the process to install the database and users.
/// </summary>
/// <param name="config"></param>
public static void Run(InstallerConfig config)
{
if (config == null)
{
throw new NullReferenceException("config");
}
try
{
// Update the web.config/connectionStrings section.
UpdateWebConfig(config);
// Create membership roles and users.
CreateMembership(config);
// Now execute the sql scripts.
RunScripts(config);
// Now create the roles and add users.
AddUsers(config);
// Finally remove the AppInstalled key in the appsettings.
RemoveAppInstalledKey();
}
catch (Exception)
{
throw;
}
}
public void We_are_creating_the_membership_users_and_roles_since_create_is_true()
{
InstallerConfig config = Serializer <InstallerConfig> .Deserialize(AppDomain.CurrentDomain.BaseDirectory + @"\installer.config");
Membership membership = config.Membership;
Assert.IsTrue(membership.Create);
}
public void Get_the_membership_provider_name()
{
InstallerConfig config = Serializer <InstallerConfig> .Deserialize(AppDomain.CurrentDomain.BaseDirectory + @"\installer.config");
Membership membership = config.Membership;
Assert.AreEqual("MyAspNetMembershipProvider", membership.ProviderName);
}
public void Read_collection_of_roles()
{
InstallerConfig config = Serializer <InstallerConfig> .Deserialize(AppDomain.CurrentDomain.BaseDirectory + @"\installer.config");
List <Role> roles = config.RoleManager.Roles;
Assert.AreEqual(2, roles.Count);
}
private void InstallASPNETDBTables(InstallerConfig config)
{
string[] files = Directory.GetFiles(config.Path.AppPath + @"App_Data\scripts");
foreach (string file in files)
{
string[] statements = GetScriptStatements(File.ReadAllText(file, new System.Text.UTF8Encoding()), StringSplitOptions.None);
ExecuteStatements(statements, config);
}
}
//private static void DropASPNETDBTables(InstallerConfig config)
//{
// string[] files = Directory.GetFiles(config.Path.AppPath + @"MvcInstaller\Scripts");
// foreach (string file in files)
// {
// string[] statements = GetScriptStatements(File.ReadAllText(file, new System.Text.UTF8Encoding()), StringSplitOptions.None);
// ExecuteStatements(statements, config);
// }
//}
/// <summary>
/// Run the sql scripts in the location set in the installer.config file.
/// </summary>
/// <param name="config"></param>
private static void RunScripts(InstallerConfig config)
{
string[] files = Directory.GetFiles(config.Path.AppPath + config.Path.RelativeSqlPath);
foreach (string file in files)
{
string[] statements = GetScriptStatements(File.ReadAllText(file, new System.Text.UTF8Encoding()));
ExecuteStatements(statements, config);
}
}
public void Read_serialized_installer_config()
{
InstallerConfig config = Serializer <InstallerConfig> .Deserialize(AppDomain.CurrentDomain.BaseDirectory + @"\installer.config");
Assert.IsNotNull(config);
string result = config.RoleManager.Roles[1].Name;
Assert.AreEqual("Administrator", result);
}
public void Read_database_connection_string_values()
{
InstallerConfig config = Serializer <InstallerConfig> .Deserialize(AppDomain.CurrentDomain.BaseDirectory + @"\installer.config");
Database db = config.Database;
Assert.AreEqual("MyDbConnection", db.ConnectionStringName);
Assert.AreEqual("localhost\\myinstance", db.DataSource);
Assert.AreEqual("MyCoolDb", db.InitialCatalog);
Assert.AreEqual("myUserName", db.UserName);
Assert.AreEqual("myPassword", db.Password);
}
public override List <ResultsGroup> Run()
{
List <ResultsGroup> results = new List <ResultsGroup>();
foreach (SnapshotConfig snapshotConfig in _vmConfig.Snapshots)
{
ResultsGroup group = new ResultsGroup(
_vmConfig.Name, snapshotConfig.Name, snapshotConfig.Description);
results.Add(group);
DriverTaskInstance driverTaskInstance = new DriverTaskInstance(
_config,
_logpath,
_simulationOnly,
_vmConfig,
_installersConfig,
snapshotConfig);
foreach (InstallerConfigProxy installerConfigProxy in _installersConfig)
{
InstallerConfig installerConfig = installerConfigProxy.Instance;
InstallerConfig.OnRewrite = new EventHandler <ReflectionResolverEventArgs>(
delegate(object sender, ReflectionResolverEventArgs args)
{
object[] objs = { snapshotConfig, _vmConfig, _installersConfig };
ReflectionResolver resolver = new ReflectionResolver(objs);
string result = null;
if (resolver.TryResolve(args.VariableType + "Config", args.VariableName, out result))
{
args.Result = result;
}
});
DriverTaskInstance.DriverTaskInstanceOptions options = new DriverTaskInstance.DriverTaskInstanceOptions();
options.Install = _install & installerConfig.Install;
options.Uninstall = _uninstall & installerConfig.UnInstall;
options.PowerOff = snapshotConfig.PowerOff;
if ((options.Install && installerConfig.Install) || (options.Uninstall && installerConfig.UnInstall))
{
driverTaskInstance.InstallUninstall(installerConfig, options);
group.AddRange(driverTaskInstance.Results);
}
else
{
ConsoleOutput.WriteLine("Skipping {0} of '{1}' on '{2}:{3}'", ProcedureString, installerConfig.Name,
_vmConfig.Name, snapshotConfig.Name);
}
}
}
return(results);
}
public void when_usesqlce40_is_true_provider_name_is_sqlserverce_4_0()
{
// Arrange
InstallerConfig config = Serializer <InstallerConfig> .Deserialize(AppDomain.CurrentDomain.BaseDirectory + @"\installer.config");
IConnectionStringComponent component = new ConnectionStringComponent(config);
// Act
string actual = component.GetProviderName;
// Assert
Assert.AreEqual("System.Data.SqlServerCe.4.0", actual);
}
public FactoryTests()
{
// You need to remember to remove the ".config" in the filename for it to work correctly.
// The ConfigurationManager tacks on a trailing ".config" to the filename.
// C:\VSProjects\MvcInstaller\RuleValidationFactory.Tests\bin\Debug\RuleValidationFactory.Tests.dll.config.config
// So if the actual filename is "RuleValidationFactory.Tests.dll.config",
// then you have to enter, RuleValidationFactory.Tests.dll for it to work.
_configSection = ConfigurationManager.OpenExeConfiguration(AppDomain.CurrentDomain.BaseDirectory + @"\RuleValidationFactory.Tests.dll");
_config = Serializer <InstallerConfig> .Deserialize(AppDomain.CurrentDomain.BaseDirectory + @"\installer.config");
_factory = new RulesValidationFactory(_config, _configSection);
}
public void when_usesqlce40_is_true_connection_string_is_for_sqlce()
{
// Arrange
InstallerConfig config = Serializer <InstallerConfig> .Deserialize(AppDomain.CurrentDomain.BaseDirectory + @"\installer.config");
IConnectionStringComponent component = new ConnectionStringComponent(config);
// Act
string actual = component.GetConnString();
// Assert
Assert.AreEqual(@"Data Source=|DataDirectory|\Database1.sdf;", actual);
}
/// <summary>
/// Add users and roles inside a transaction in case there's an exception,
/// we can simply click the "Install" button again.
/// </summary>
/// <param name="config"></param>
private static void AddUsers(InstallerConfig config)
{
if (config.Membership.Create)
{
using (System.Transactions.TransactionScope scope = new System.Transactions.TransactionScope())
{
// Now create the roles
foreach (var role in config.RoleManager.Roles)
{
if (!Roles.RoleExists(role.Name))
{
Roles.CreateRole(role.Name);
}
//throw new Exception("Error adding user - by King.");
// Now create user and add to role.
foreach (var user in role.Users)
{
MembershipCreateStatus status = MembershipCreateStatus.UserRejected;
MembershipUser u = System.Web.Security.Membership.CreateUser(user.UserName.Trim(), user.Password.Trim(), user.Email.Trim(),
user.SecretQuestion.Trim(), user.SecretAnswer.Trim(), true, out status);
if (status == MembershipCreateStatus.Success)
{
// Add user to role
Roles.AddUserToRole(user.UserName, role.Name);
}
else if (status == MembershipCreateStatus.DuplicateUserName)
{
// Add a duplicate username to another role.
// This allows the same user to be added to any number of roles.
try
{
Roles.AddUserToRole(user.UserName, role.Name);
}
catch (Exception)
{
}
}
else if (status == MembershipCreateStatus.InvalidPassword)
{
throw new ApplicationException("Please update the install.config file. The passwords don't adhere to the rules in the web.config/membership section.");
}
}
}
scope.Complete();
}
}
}
public void Read_collection_of_users_for_role()
{
InstallerConfig config = Serializer <InstallerConfig> .Deserialize(AppDomain.CurrentDomain.BaseDirectory + @"\installer.config");
List <Role> roles = config.RoleManager.Roles;
foreach (var role in roles)
{
Console.WriteLine("Role: {0}", role.Name);
foreach (var user in role.Users)
{
Console.WriteLine(" User: {0}:{1}", user.UserName, user.Password);
}
}
}
public ActionResult Index()
{
// Now check if the application has already been installed.
if (InstallWizard.Installed)
{
return(RedirectToAction("Index", "Home"));
}
path = Server.MapPath("~/");
// Deserialize the installer.config xml file.
InstallerConfig config = Serializer <InstallerConfig> .Deserialize(path + @"installer.config");
return(View(config));
}
public void run_failing_sql_command_to_get_error_list()
{
// Arrange
InstallerConfig config = Serializer <InstallerConfig> .Deserialize(AppDomain.CurrentDomain.BaseDirectory + @"\installer.config");
config.Path.AppPath = @"C:\VSProjects\MvcInstaller\MvcInstallerV3.UnitTests\";
try
{
RunScripts(config);
}
catch (Exception)
{
throw;
}
}
public void Get_Config_Section()
{
System.Configuration.Configuration configSection = ConfigurationManager.OpenExeConfiguration(System.IO.Path.Combine(AppDomain.CurrentDomain.BaseDirectory, "MvcInstaller.UnitTests.dll.config"));
if (configSection == null)
{
throw new InvalidOperationException("Configuration file not available.");
}
InstallerConfig config = Serializer <InstallerConfig> .Deserialize(AppDomain.CurrentDomain.BaseDirectory + @"\installer.config");
IConnectionStringComponent component = new ConnectionStringComponent(config);
IConfigurationFactory factory = new ConfigurationFactory(component);
factory.Execute(config, configSection);
configSection.Save();
}
/// <summary>
/// Given a blob of data extracted from the MSI, parse out the pieces
/// </summary>
/// <param name="configBytes"></param>
/// <returns></returns>
private InstallerConfig ParseConfig(byte[] configBytes)
{
// TODO Should use public key decryption on this
InstallerConfig conf = new InstallerConfig();
//
// Unmarshal data
//
// Get UUID
byte[] groupUUID = new byte[16];
Array.Copy(configBytes, 0, groupUUID, 0, 16);
conf.groupUUID = ConvertUUIDBytesToString(groupUUID);
return(conf);
}
public Instance(
string logpath,
bool simulationOnly,
RemoteInstallConfig config,
VMWareMappedVirtualMachine vm,
VirtualMachineConfig vmConfig,
InstallerConfig installerConfig,
SnapshotConfig snapshotConfig)
{
_logpath = logpath;
_simulationOnly = simulationOnly;
_config = config;
_vm = vm;
_vmConfig = vmConfig;
_installerConfig = installerConfig;
_snapshotConfig = snapshotConfig;
}
public void standard_sql_connection_string_with_integrated_security()
{
// Arrange
InstallerConfig config = new InstallerConfig();
config.Database.DataSource = @"kingwilder-pc\sqlserver";
config.Database.InitialCatalog = "BloggerApp";
config.Database.UseTrustedConnection = true;
ISqlConnection provider = new SqlConnectionString(config);
// Act
var actual = provider.GetConnectionString();
var expected = @"Data Source=kingwilder-pc\sqlserver;Initial Catalog=BloggerApp;Integrated Security=True";
// Assert
Assert.AreEqual(expected, actual);
}
public void return_standard_connection_string_using_trustedconnection()
{
// Arrange
InstallerConfig config = new InstallerConfig();
config.Database.DataSource = @"kingwilder-pc\sqlserver";
config.Database.InitialCatalog = "BloggerApp";
config.Database.UseTrustedConnection = true;
ConnectionFactory factory = new ConnectionFactory(config);
// Act
var actual = factory.ConnectionString();
var expected = string.Format("Data Source={0};Initial Catalog={1};Integrated Security=True", config.Database.DataSource, config.Database.InitialCatalog);
// Assert
Assert.AreEqual(expected, actual);
}
public void TestMethod1()
{
Configuration configSection = ConfigurationManager.OpenExeConfiguration(ConfigurationUserLevel.None);
//Configuration configSection = WebConfigurationManager.OpenWebConfiguration(null);
if (configSection == null)
{
throw new InvalidOperationException("Configuration file not available.");
}
InstallerConfig config = Serializer <InstallerConfig> .Deserialize(AppDomain.CurrentDomain.BaseDirectory + @"\installer.config");
IConnectionStringComponent component = new ConnectionStringComponent(config);
IConfigurationFactory factory = new ConfigurationFactory(component);
factory.Execute(config, configSection);
configSection.Save();
}
/// <summary>
/// This will execute the sql statements.
/// </summary>
/// <param name="tableStatements"></param>
/// <param name="dbName"></param>
private static void ExecuteStatements(string[] tableStatements, InstallerConfig config)
{
if (tableStatements.Length > 0)
{
using (SqlConnection conn = new SqlConnection())
{
IConnectionStringComponent component = new ConnectionStringComponent(config);
conn.ConnectionString = component.GetConnString();
conn.Open();
using (SqlCommand command = new SqlCommand(string.Empty, conn))
{
foreach (string statement in tableStatements)
{
command.CommandText = statement;
command.ExecuteNonQuery();
}
}
}
}
}
public void standard_sql_connection_string_with_all_parameters_returns_credentials()
{
// Arrange
InstallerConfig config = new InstallerConfig();
config.Database.DataSource = @"kingwilder-pc\sqlserver";
config.Database.InitialCatalog = "CommerceApp";
config.Database.UseTrustedConnection = false;
config.Database.UserName = "******";
config.Database.Password = "******";
IConnectionProvider provider = new SqlConnectionString(config);
// Act
var actual = provider.GetConnectionString();
var expected = @"Data Source=kingwilder-pc\sqlserver;Initial Catalog=CommerceApp;User ID=samAdmin;Password=myPassword";
// Assert
Assert.AreEqual(expected, actual);
}
public void Update_configuration_and_save()
{
//string path = System.IO.Path.Combine(AppDomain.CurrentDomain.BaseDirectory, "MvcInstaller.Tests.dll.config");
string path = @"C:\VSProjects\MvcInstaller\MvcInstaller.Tests\web.config";
//System.Configuration.Configuration configSection = ConfigurationManager.OpenExeConfiguration(path);
System.Configuration.Configuration configSection = WebConfigurationManager.OpenWebConfiguration(path);
if (configSection == null)
{
throw new InvalidOperationException("Configuration file not available.");
}
InstallerConfig config = Serializer <InstallerConfig> .Deserialize(AppDomain.CurrentDomain.BaseDirectory + @"\installer.config");
IConnectionStringComponent component = new ConnectionStringComponent(config);
IConfigurationFactory factory = new ConfigurationFactory(component);
factory.Execute(config, configSection);
configSection.Save();
}
public void return_standard_connection_string_with_credentials()
{
// Arrange
InstallerConfig config = new InstallerConfig();
config.Database.DataSource = @"kingwilder-pc\sqlserver";
config.Database.InitialCatalog = "BloggerApp";
config.Database.UseTrustedConnection = false;
config.Database.UserName = "******";
config.Database.Password = "******";
ConnectionFactory factory = new ConnectionFactory(config);
// Act
var actual = factory.ConnectionString();
var expected = string.Format("Data Source={0};Initial Catalog={1};User ID={2};Password={3}", config.Database.DataSource, config.Database.InitialCatalog, config.Database.UserName, config.Database.Password);
// Assert
Assert.AreEqual(expected, actual);
}
public void standard_sql_connection_string_with_all_parameters_returns_integrated_security()
{
// Arrange
InstallerConfig config = new InstallerConfig();
config.Database.DataSource = @"kingwilder-pc\sqlserver";
config.Database.InitialCatalog = "CommerceApp";
config.Database.UseTrustedConnection = true;
config.Database.UserName = "******";
config.Database.Password = "******";
IConnectionProvider provider = new SqlConnectionString(config);
// Act
var actual = provider.GetConnectionString();
var expected = @"Data Source=kingwilder-pc\sqlserver;Initial Catalog=CommerceApp;Integrated Security=True";
// Assert
Assert.AreEqual(expected, actual);
}
public void return_entityframework_connection_using_trustedconnection()
{
// Arrange
InstallerConfig config = new InstallerConfig();
config.Database.DataSource = @"kingwilder-pc\sqlserver";
config.Database.InitialCatalog = "BloggerApp";
config.Database.UseTrustedConnection = true;
config.Database.EntityFrameworkEntitiesName = "EntityFramework.BloggerEntities";
ConnectionFactory factory = new ConnectionFactory(config);
// Act
var actual = factory.ConnectionString();
//var expected = @"metadata=res://*/Models.BloggerEntities.csdl|res://*/Models.BloggerEntities.ssdl|res://*/Models.BloggerEntities.msl;provider=System.Data.SqlClient;provider connection string=""Data Source=kingwilder-pc\sqlserver;Initial Catalog=BloggerApp;Integrated Security=True;MultipleActiveResultSets=True;Application Name=EntityFramework""";
var expected = @"metadata=res://*/EntityFramework.BloggerEntities.csdl|res://*/EntityFramework.BloggerEntities.ssdl|res://*/EntityFramework.BloggerEntities.msl;provider=System.Data.SqlClient;provider connection string=""Data Source=kingwilder-pc\sqlserver;Initial Catalog=BloggerApp;Integrated Security=True;MultipleActiveResultSets=True;Application Name=EntityFramework""";
// Assert
Assert.AreEqual(expected, actual);
}
public bool InstallUninstall(
InstallerConfig installerConfig,
DriverTaskInstanceOptions options)
{
try
{
_results.Clear();
_vmPowerDriver.PowerOnDependencies();
_vmPowerDriver.ThrowOnFailure();
_vmPowerDriver.ConnectToHost();
CopyMethod copyMethod = _vmConfig.CopyMethod;
if (copyMethod == CopyMethod.undefined) copyMethod = installerConfig.CopyMethod;
_vmPowerDriver.MapVirtualMachine(copyMethod);
if (!_snapshotRestored)
{
_vmPowerDriver.PrepareSnapshot();
_snapshotRestored = true;
}
_vmPowerDriver.LoginToGuest();
CopyInstaller(installerConfig);
Instance installInstance = new Instance(
_logpath, _simulationOnly, _config, _vmPowerDriver.Vm, _vmPowerDriver.VmConfig, installerConfig, _vmPowerDriver.SnapshotConfig);
Instance.InstanceOptions instanceOptions = new Instance.InstanceOptions();
instanceOptions.Install = options.Install;
instanceOptions.Uninstall = options.Uninstall;
Result remoteInstallResult = installInstance.InstallUninstall(instanceOptions);
foreach (VirtualMachinePowerResult powerResult in _vmPowerDriver.PowerResults)
{
remoteInstallResult.Add(powerResult);
}
_results.Add(remoteInstallResult);
if (remoteInstallResult.RebootRequired)
{
if (installerConfig.RebootIfRequired)
{
ConsoleOutput.WriteLine("Shutting down '{0}:{1}'", _vmPowerDriver.VmConfig.Name,
_vmPowerDriver.SnapshotConfig.Name);
_vmPowerDriver.ShutdownGuest();
ConsoleOutput.WriteLine("Powering on '{0}:{1}'", _vmPowerDriver.VmConfig.Name,
_vmPowerDriver.SnapshotConfig.Name);
_vmPowerDriver.PowerOn();
}
else if (options.PowerOff)
{
_vmPowerDriver.PowerOff();
}
else
{
ConsoleOutput.WriteLine("Skipping reboot of '{0}:{1}'", _vmPowerDriver.VmConfig.Name,
_vmPowerDriver.SnapshotConfig.Name);
}
}
else if (options.PowerOff)
{
_vmPowerDriver.PowerOff();
}
return remoteInstallResult.Success;
}
catch (Exception ex)
{
ConsoleOutput.WriteLine(ex);
Result result = new Result(installerConfig.Name, installerConfig.SvnRevision);
result.LastError = ex.Message;
result.SuccessfulInstall = result.SuccessfulUnInstall = InstallResult.False;
_results.Add(result);
return false;
}
finally
{
_vmPowerDriver.CloseVirtualMachine();
_vmPowerDriver.DisconnectFromHost();
_vmPowerDriver.PowerOffDependencies();
}
}
public void CopyInstaller(InstallerConfig installerConfig)
{
if (!string.IsNullOrEmpty(installerConfig.File))
{
ConsoleOutput.WriteLine("Copying '{0}' to '{1}:{2}'",
installerConfig.Name,
_vmPowerDriver.VmConfig.Name,
_vmPowerDriver.SnapshotConfig.Name);
if (!_simulationOnly)
{
_vmPowerDriver.Vm.CopyFileFromHostToGuest(installerConfig.File, installerConfig.DestinationPath);
}
}
else
{
ConsoleOutput.WriteLine("Skipped copying installer to '{0}:{1}'",
_vmPowerDriver.VmConfig.Name,
_vmPowerDriver.SnapshotConfig.Name);
}
}
