void IInstallAction.Run(SetupVariables vars)
{
try
{
Begin(LogStartInstallMessage);
//
var connectionString = vars.DbInstallConnectionString;
var database = vars.Database;
Log.WriteStart(LogStartInstallMessage);
Log.WriteInfo(String.Format("SQL Server Database Name: \"{0}\"", database));
//
if (SqlUtils.DatabaseExists(connectionString, database))
{
throw new Exception(String.Format("SQL Server database \"{0}\" already exists", database));
}
SqlUtils.CreateDatabase(connectionString, database);
//
Log.WriteEnd("Created SQL Server database");
//
InstallLog.AppendLine(String.Format("- Created a new SQL Server database \"{0}\"", database));
}
catch (Exception ex)
{
if (Utils.IsThreadAbortException(ex))
{
return;
}
//
Log.WriteError("Create database error", ex);
//
throw;
}
}
void IInstallAction.Run(SetupVariables vars)
{
Log.WriteStart("Updating web.config file (connection string)");
var file = Path.Combine(vars.InstallationFolder, vars.ConfigurationFile);
vars.ConnectionString = String.Format(vars.ConnectionString, vars.DatabaseServer, vars.Database, vars.Database, vars.DatabaseUserPassword);
var Xml = new XmlDocument();
Xml.Load(file);
var ConnNode = Xml.SelectSingleNode("configuration/connectionStrings/add[@name='EnterpriseServer']") as XmlElement;
if (ConnNode != null)
{
ConnNode.SetAttribute("connectionString", vars.ConnectionString);
}
Xml.Save(file);
Log.WriteEnd(String.Format("Updated {0} file", vars.ConfigurationFile));
// Schedular
var file1 = Path.Combine(vars.InstallationFolder, "Bin/SolidCP.SchedulerService.exe.config");
var Xml1 = new XmlDocument();
Xml1.Load(file);
var ConnNode1 = Xml1.SelectSingleNode("configuration/connectionStrings/add[@name='EnterpriseServer']") as XmlElement;
if (ConnNode1 != null)
{
ConnNode1.SetAttribute("connectionString", vars.ConnectionString);
}
Xml.Save(file1);
Log.WriteEnd(String.Format("Updated {0} file", vars.ConfigurationFile));
}
void IPrepareDefaultsAction.Run(SetupVariables vars)
{
//
if (String.IsNullOrEmpty(vars.WebSitePort))
{
vars.WebSitePort = Global.WebPortal.DefaultPort;
}
//
if (String.IsNullOrEmpty(vars.UserAccount))
{
vars.UserAccount = Global.WebPortal.ServiceAccount;
}
// By default we use public ip for the component
if (String.IsNullOrEmpty(vars.WebSiteIP))
{
var serverIPs = WebUtils.GetIPv4Addresses();
//
if (serverIPs != null && serverIPs.Length > 0)
{
vars.WebSiteIP = serverIPs[0];
}
else
{
vars.WebSiteIP = Global.LoopbackIPv4;
}
}
}
void IInstallAction.Run(SetupVariables vars)
{
try
{
var component = vars.ComponentFullName;
var componentId = vars.ComponentId;
var path = Path.Combine(vars.InstallationFolder, SqlFilePath);
if (!FileUtils.FileExists(path))
{
Log.WriteInfo(String.Format("File {0} not found", path));
return;
}
//
SqlProcess process = new SqlProcess(path, vars.DbInstallConnectionString, vars.Database);
//
process.ProgressChange += new EventHandler <ActionProgressEventArgs <int> >(process_ProgressChange);
//
process.Run();
//
InstallLog.AppendLine(string.Format("- Installed {0} database objects", component));
}
catch (Exception ex)
{
if (Utils.IsThreadAbortException(ex))
{
return;
}
//
Log.WriteError("Run sql error", ex);
//
throw;
}
}
void IUninstallAction.Run(SetupVariables vars)
{
try
{
Log.WriteStart("Deleting database user");
Log.WriteInfo(String.Format("Deleting database user \"{0}\"", vars.Database));
//
if (SqlUtils.UserExists(vars.DbInstallConnectionString, vars.Database))
{
SqlUtils.DeleteUser(vars.DbInstallConnectionString, vars.Database);
//
Log.WriteEnd("Deleted database user");
}
}
catch (Exception ex)
{
if (Utils.IsThreadAbortException(ex))
{
return;
}
Log.WriteError("Database user delete error", ex);
throw;
}
}
void IInstallAction.Run(SetupVariables vars)
{
try
{
//
Log.WriteStart(String.Format("Creating database user {0}", vars.Database));
//
vars.DatabaseUserPassword = Utils.GetRandomString(20);
//user name should be the same as database
vars.NewDatabaseUser = SqlUtils.CreateUser(vars.DbInstallConnectionString, vars.Database, vars.DatabaseUserPassword, vars.Database);
//
Log.WriteEnd("Created database user");
InstallLog.AppendLine("- Created database user \"{0}\"", vars.Database);
}
catch (Exception ex)
{
if (Utils.IsThreadAbortException(ex))
{
return;
}
Log.WriteError("Create db user error", ex);
throw;
}
}
private void UninstallService(SetupVariables vars)
{
if (ServiceController.GetServices().Any(s => s.ServiceName.Equals(Global.Parameters.SchedulerServiceName, StringComparison.CurrentCultureIgnoreCase)))
{
ManagedInstallerClass.InstallHelper(new[] { "/u /LogFile=\"\" ", Path.Combine(vars.InstallationFolder, "bin", Global.Parameters.SchedulerServiceFileName) });
}
}
public StandaloneServerActionManager(SetupVariables serverSetup, SetupVariables esServerSetup, SetupVariables portalSetup)
: base(SetupVariables.Empty)
{
this.serverSetup = serverSetup;
this.esServerSetup = esServerSetup;
this.portalSetup = portalSetup;
//
Initialize += new EventHandler(StandaloneServerActionManager_Initialize);
}
void IInstallAction.Run(SetupVariables vars)
{
// Exit with an error if Windows account with the same name already exists
if (SecurityUtils.UserExists(vars.UserDomain, vars.UserAccount))
{
throw new Exception(UserAccountExists);
}
//
CreateUserAccount(vars);
}
void IInstallAction.Run(SetupVariables vars)
{
//
try
{
Begin(LogStartInstallMessage);
//
Log.WriteStart(LogStartInstallMessage);
//
var urls = Utils.GetApplicationUrls(vars.WebSiteIP, vars.WebSiteDomain, vars.WebSitePort, null);
string url = null;
if (urls.Length == 0)
{
Log.WriteInfo(ApplicationUrlNotFoundMessage);
//
return;
}
// Retrieve top-most url from the list
url = "http://" + urls[0];
//
Log.WriteStart("Creating menu shortcut");
//
string programs = Environment.GetFolderPath(Environment.SpecialFolder.Programs);
string fileName = "Login to WebsitePanel.url";
string path = Path.Combine(programs, Path2);
//
if (!Directory.Exists(path))
{
Directory.CreateDirectory(path);
}
//
WriteShortcutData(Path.Combine(path, fileName), url);
//
Log.WriteEnd("Created menu shortcut");
//
Log.WriteStart("Creating desktop shortcut");
//
string desktop = Environment.GetFolderPath(Environment.SpecialFolder.DesktopDirectory);
WriteShortcutData(Path.Combine(desktop, fileName), url);
//
Log.WriteEnd("Created desktop shortcut");
//
InstallLog.AppendLine("- Created application shortcuts");
}
catch (Exception ex)
{
if (Utils.IsThreadAbortException(ex))
{
return;
}
//
Log.WriteError("Create shortcut error", ex);
}
}
protected BaseActionManager(SetupVariables sessionVariables)
{
if (sessionVariables == null)
{
throw new ArgumentNullException("sessionVariables");
}
//
currentScenario = new List <Action>();
//
this.sessionVariables = sessionVariables;
}
void IPrepareDefaultsAction.Run(SetupVariables vars)
{
//
if (String.IsNullOrEmpty(vars.WebSiteIP))
vars.WebSiteIP = "127.0.0.1";
//
if (String.IsNullOrEmpty(vars.WebSitePort))
vars.WebSitePort = "9002";
//
if (String.IsNullOrEmpty(vars.UserAccount))
vars.UserAccount = "WPEnterpriseServer";
}
void IPrepareDefaultsAction.Run(SetupVariables vars)
{
//Begin(LogStartMessage);
//
if (!String.IsNullOrEmpty(vars.UserPassword))
{
return;
}
//
vars.UserPassword = Guid.NewGuid().ToString();
//
//Finish(LogEndMessage);
}
void IInstallAction.Run(SetupVariables vars)
{
Log.WriteStart(string.Format("Updating {0}.config file (crypto key)", Global.Parameters.SchedulerServiceFileName));
try
{
UpdateCryptoKey(vars.InstallationFolder);
}
catch (Exception)
{
}
Log.WriteEnd(string.Format("Updated {0}.config file (connection string)", Global.Parameters.SchedulerServiceFileName));
}
private void CopySetupData(SetupVariables source, SetupVariables target)
{
var targetProperties = target.GetType().GetProperties();
//
foreach (var targetProperty in targetProperties)
{
if (targetProperty.CanWrite)
{
var sourceProperty = source.GetType().GetProperty(targetProperty.Name);
//
targetProperty.SetValue(target, sourceProperty.GetValue(source, null), null);
}
}
}
private void CreateUserAccount(SetupVariables vars)
{
//SetProgressText("Creating windows user account...");
var domain = vars.UserDomain;
var userName = vars.UserAccount;
//
var description = String.Format(UserAccountDescription, vars.ComponentName);
var memberOf = vars.UserMembership;
var password = vars.UserPassword;
Log.WriteStart(LogStartMessage);
Log.WriteInfo(String.Format(LogInfoMessage, userName));
// create account
SystemUserItem user = new SystemUserItem
{
Domain = domain,
Name = userName,
FullName = userName,
Description = description,
MemberOf = memberOf,
Password = password,
PasswordCantChange = true,
PasswordNeverExpires = true,
AccountDisabled = false,
System = true
};
//
SecurityUtils.CreateUser(user);
// add rollback action
//RollBack.RegisterUserAccountAction(domain, userName);
// update log
Log.WriteEnd(LogEndMessage);
// update install log
if (String.IsNullOrEmpty(domain))
{
InstallLog.AppendLine(String.Format(InstallLogMessageLocal, userName));
}
else
{
InstallLog.AppendLine(String.Format(InstallLogMessageDomain, userName, domain));
}
}
private void CopySetupData(SetupVariables source, SetupVariables target)
{
var targetProperties = target.GetType().GetProperties();
//
foreach (var targetProperty in targetProperties)
{
if (targetProperty.CanWrite)
{
var sourceProperty = source.GetType().GetProperty(targetProperty.Name);
//
targetProperty.SetValue(target, sourceProperty.GetValue(source, null), null);
}
}
}
public ActionResult Index(SetupVariables setupVariables)
{
if (_setupService.IsDatabaseSetup())
{
return(this.Forbidden("Forbidden", null));
}
Exception exc;
var user = _setupService.SetupDatabase(setupVariables, out exc);
if (exc != null)
{
return(View("Exception", exc));
}
_userService.Login(user, HttpContext);
return(View("Success"));
}
public async Task <ActionResult> Index(SetupVariables setupVariables)
{
if (_setupService.IsDatabaseSetup())
{
return(StatusCode(403));
}
var result = await _setupService.SetupDatabase(setupVariables);
if (result.Item2 != null)
{
return(View("Exception", result.Item2));
}
// can't login here because all of the normal app startup was skipped
//await AuthorizationController.PerformSignInAsync(true, user, HttpContext);
return(View("Success"));
}
public ActionResult Index(SetupVariables setupVariables)
{
if (_setupService.IsDatabaseSetup())
{
return(Forbid());
}
Exception exc;
var user = _setupService.SetupDatabase(setupVariables, out exc);
if (exc != null)
{
return(View("Exception", exc));
}
// can't login here because all of the normal app startup was skipped
//await AuthorizationController.PerformSignInAsync(true, user, HttpContext);
return(View("Success"));
}
void IInstallAction.Run(SetupVariables vars)
{
try
{
Begin(LogStartInstallMessage);
//
Log.WriteStart(LogStartInstallMessage);
//
var path = Path.Combine(vars.InstallationFolder, @"App_Data\SiteSettings.config");
//
if (!File.Exists(path))
{
Log.WriteInfo(String.Format("File {0} not found", path));
//
return;
}
//
var doc = new XmlDocument();
doc.Load(path);
//
var urlNode = doc.SelectSingleNode("SiteSettings/EnterpriseServer") as XmlElement;
if (urlNode == null)
{
Log.WriteInfo("EnterpriseServer setting not found");
return;
}
urlNode.InnerText = vars.EnterpriseServerURL;
doc.Save(path);
//
Log.WriteEnd("Updated site settings");
//
InstallLog.AppendLine("- Updated site settings");
}
catch (Exception ex)
{
if (Utils.IsThreadAbortException(ex))
{
return;
}
//
Log.WriteError("Site settigs error", ex);
//
throw;
}
}
void IUninstallAction.Run(SetupVariables vars)
{
try
{
var appPoolName = String.Format(AppPoolNameFormatString, vars.ComponentFullName);
var iisVersion = vars.IISVersion;
var iis7 = (iisVersion.Major == 7);
var poolExists = false;
//
Log.WriteStart(LogStartUninstallMessage);
//
vars.WebApplicationPoolName = appPoolName;
// Maintain backward compatibility
if (iis7)
{
poolExists = WebUtils.IIS7ApplicationPoolExists(appPoolName);
}
else
{
poolExists = WebUtils.ApplicationPoolExists(appPoolName);
}
if (!poolExists)
{
Log.WriteInfo(LogUninstallAppPoolNotFoundMessage);
return;
}
//
if (iis7)
{
WebUtils.DeleteIIS7ApplicationPool(appPoolName);
}
else
{
WebUtils.DeleteApplicationPool(appPoolName);
}
//update install log
InstallLog.AppendLine(String.Format("- Removed application pool named \"{0}\"", appPoolName));
}
finally
{
//update log
//Log.WriteEnd(LogEndUninstallMessage);
}
}
void IInstallAction.Run(SetupVariables vars)
{
AppConfig.EnsureComponentConfig(vars.ComponentId);
//
AppConfig.SetComponentSettingStringValue(vars.ComponentId, "Database", vars.Database);
AppConfig.SetComponentSettingBooleanValue(vars.ComponentId, "NewDatabase", true);
//
AppConfig.SetComponentSettingStringValue(vars.ComponentId, "DatabaseUser", vars.Database);
AppConfig.SetComponentSettingBooleanValue(vars.ComponentId, "NewDatabaseUser", vars.NewDatabaseUser);
//
AppConfig.SetComponentSettingStringValue(vars.ComponentId, Global.Parameters.ConnectionString, vars.ConnectionString);
AppConfig.SetComponentSettingStringValue(vars.ComponentId, Global.Parameters.DatabaseServer, vars.DatabaseServer);
AppConfig.SetComponentSettingStringValue(vars.ComponentId, Global.Parameters.InstallConnectionString, vars.DbInstallConnectionString);
AppConfig.SetComponentSettingStringValue(vars.ComponentId, Global.Parameters.CryptoKey, vars.CryptoKey);
//
AppConfig.SaveConfiguration();
}
private void CreateUserAccount(SetupVariables vars)
{
//SetProgressText("Creating windows user account...");
var domain = vars.UserDomain;
var userName = vars.UserAccount;
//
var description = String.Format(UserAccountDescription, vars.ComponentName);
var memberOf = vars.UserMembership;
var password = vars.UserPassword;
Log.WriteStart(LogStartMessage);
Log.WriteInfo(String.Format(LogInfoMessage, userName));
// create account
SystemUserItem user = new SystemUserItem
{
Domain = domain,
Name = userName,
FullName = userName,
Description = description,
MemberOf = memberOf,
Password = password,
PasswordCantChange = true,
PasswordNeverExpires = true,
AccountDisabled = false,
System = true
};
//
SecurityUtils.CreateUser(user);
// add rollback action
//RollBack.RegisterUserAccountAction(domain, userName);
// update log
Log.WriteEnd(LogEndMessage);
// update install log
if (String.IsNullOrEmpty(domain))
InstallLog.AppendLine(String.Format(InstallLogMessageLocal, userName));
else
InstallLog.AppendLine(String.Format(InstallLogMessageDomain, userName, domain));
}
void IInstallAction.Run(SetupVariables vars)
{
try
{
Begin(LogStartInstallMessage);
Log.WriteStart(LogStartInstallMessage);
string path = Path.Combine(vars.InstallationFolder, "web.config");
if (!File.Exists(path))
{
Log.WriteInfo(string.Format("File {0} not found", path));
return;
}
Log.WriteStart("Updating configuration file (session validation key)");
XmlDocument doc = new XmlDocument();
doc.Load(path);
XmlElement sessionKey = doc.SelectSingleNode("configuration/appSettings/add[@key='SessionValidationKey']") as XmlElement;
if (sessionKey == null)
{
Log.WriteInfo("SessionValidationKey setting not found");
return;
}
sessionKey.SetAttribute("value", StringUtils.GenerateRandomString(16));
doc.Save(path);
Log.WriteEnd("Generated session validation key");
InstallLog.AppendLine("- Generated session validation key");
}
catch (Exception ex)
{
if (Utils.IsThreadAbortException(ex))
{
return;
}
//
Log.WriteError("Site settigs error", ex);
//
throw;
}
}
void IPrepareDefaultsAction.Run(SetupVariables vars)
{
//
if (String.IsNullOrEmpty(vars.WebSiteIP))
{
vars.WebSiteIP = Global.Server.DefaultIP;
}
//
if (String.IsNullOrEmpty(vars.WebSitePort))
{
vars.WebSitePort = Global.Server.DefaultPort;
}
//
if (string.IsNullOrEmpty(vars.UserAccount))
{
vars.UserAccount = Global.Server.ServiceAccount;
}
}
void IPrepareDefaultsAction.Run(SetupVariables vars)
{
//
if (String.IsNullOrEmpty(vars.WebSiteIP))
{
vars.WebSiteIP = "127.0.0.1";
}
//
if (String.IsNullOrEmpty(vars.WebSitePort))
{
vars.WebSitePort = "9002";
}
//
if (String.IsNullOrEmpty(vars.UserAccount))
{
vars.UserAccount = "WPEnterpriseServer";
}
}
void IInstallAction.Run(SetupVariables vars)
{
try
{
Log.WriteStart("Copying web.config");
string configPath = Path.Combine(vars.InstallationFolder, "web.config");
string config6Path = Path.Combine(vars.InstallationFolder, "web6.config");
bool iis6 = (vars.IISVersion.Major == 6);
if (!File.Exists(config6Path))
{
Log.WriteInfo(string.Format("File {0} not found", config6Path));
return;
}
if (iis6)
{
if (!File.Exists(configPath))
{
Log.WriteInfo(string.Format("File {0} not found", configPath));
return;
}
FileUtils.DeleteFile(configPath);
File.Move(config6Path, configPath);
}
else
{
FileUtils.DeleteFile(config6Path);
}
Log.WriteEnd("Copied web.config");
}
catch (Exception ex)
{
if (Utils.IsThreadAbortException(ex))
{
return;
}
//
Log.WriteError("Copy web.config error", ex);
//
throw;
}
}
public async Task <Tuple <User, Exception> > SetupDatabase(SetupVariables setupVariables)
{
Exception exception = null;
try
{
_setupRepository.SetupDatabase();
}
catch (Exception exc)
{
exception = exc;
return(Tuple.Create <User, Exception>(null, exception));
}
var settings = _settingsManager.Current;
settings.ForumTitle = setupVariables.ForumTitle;
settings.SmtpServer = setupVariables.SmtpServer;
settings.SmtpPort = setupVariables.SmtpPort;
settings.MailerAddress = setupVariables.MailerAddress;
settings.UseSslSmtp = setupVariables.UseSslSmtp;
settings.UseEsmtp = setupVariables.UseEsmtp;
settings.SmtpUser = setupVariables.SmtpUser;
settings.SmtpPassword = setupVariables.SmtpPassword;
settings.ServerDaylightSaving = setupVariables.ServerDaylightSaving;
settings.ServerTimeZone = setupVariables.ServerTimeZone;
_settingsManager.SaveCurrent();
var user = await _userService.CreateUser(setupVariables.Name, setupVariables.Email, setupVariables.Password, true, "");
user.Roles = new List <string> {
PermanentRoles.Admin, PermanentRoles.Moderator
};
var profile = new Profile {
UserID = user.UserID, IsTos = true, IsSubscribed = true, TimeZone = setupVariables.ServerTimeZone, IsDaylightSaving = setupVariables.ServerDaylightSaving, ShowDetails = true
};
await _profileService.Create(profile);
var edit = new UserEdit(user, profile);
await _userService.EditUser(user, edit, false, false, null, null, "", user);
//PopForumsActivation.StartServicesIfRunningInstance();
return(Tuple.Create(user, exception));
}
void IInstallAction.Run(SetupVariables vars)
{
try
{
Begin(LogStartInstallMessage);
//
Log.WriteStart(LogStartInstallMessage);
//
var path = Path.Combine(vars.InstallationFolder, @"App_Data\SiteSettings.config");
//
if (!File.Exists(path))
{
Log.WriteInfo(String.Format("File {0} not found", path));
//
return;
}
//
var doc = new XmlDocument();
doc.Load(path);
//
var urlNode = doc.SelectSingleNode("SiteSettings/EnterpriseServer") as XmlElement;
if (urlNode == null)
{
Log.WriteInfo("EnterpriseServer setting not found");
return;
}
urlNode.InnerText = vars.EnterpriseServerURL;
doc.Save(path);
//
Log.WriteEnd("Updated site settings");
//
InstallLog.AppendLine("- Updated site settings");
}
catch (Exception ex)
{
if (Utils.IsThreadAbortException(ex))
return;
//
Log.WriteError("Site settigs error", ex);
//
throw;
}
}
public ActionResult Index()
{
if (!_setupService.IsConnectionPossible())
{
return(View("NoConnection"));
}
if (_setupService.IsDatabaseSetup())
{
return(StatusCode(403));
}
var setupVariables = new SetupVariables
{
SmtpPort = 25,
ServerDaylightSaving = true,
ServerTimeZone = -5
};
return(View(setupVariables));
}
void IUninstallAction.Run(SetupVariables vars)
{
try
{
Log.WriteStart(LogStartUninstallMessage);
UninstallService(vars);
Log.WriteEnd("Scheduler Service Uninstalled.");
}
catch (Exception ex)
{
if (Utils.IsThreadAbortException(ex))
{
return;
}
Log.WriteError("Uninstalling scheduler service error.", ex);
throw;
}
}
private void DoMigration(SetupVariables vars)
{
var fileName = Path.Combine(vars.InstallationFolder, "web.config");
//
var xdoc = XDocument.Load(fileName);
// Modify <system.web /> node child elements
var swnode = xdoc.Root.Element("system.web");
{
// Adjust httpRuntime maximum request length
if (swnode.Element("httpRuntime") != null)
{
var htnode = swnode.Element("httpRuntime");
//
htnode.SetAttributeValue("maxRequestLength", "16384");
}
};
// Save all changes
xdoc.Save(fileName);
}
private static SetupScript GetPrepareScript(Session Ctx)
{
var CtxVars = new SetupVariables();
WiXSetup.FillFromSession(Ctx.CustomActionData, CtxVars);
AppConfig.LoadConfiguration(new ExeConfigurationFileMap {
ExeConfigFilename = GetProperty(Ctx, "MainConfig")
});
CtxVars.IISVersion = Tool.GetWebServerVersion();
CtxVars.ComponentId = GetProperty(Ctx, "ComponentId");
CtxVars.Version = AppConfig.GetComponentSettingStringValue(CtxVars.ComponentId, Global.Parameters.Release);
CtxVars.SpecialBaseDirectory = Directory.GetParent(GetProperty(Ctx, "MainConfig")).FullName;
CtxVars.FileNameMap = new Dictionary <string, string>();
CtxVars.FileNameMap.Add(new FileInfo(GetProperty(Ctx, "MainConfig")).Name, BackupRestore.MainConfig);
SetupScript Result = new ExpressScript(CtxVars);
Result.Actions.Add(new InstallAction(ActionTypes.StopApplicationPool)
{
SetupVariables = CtxVars
});
Result.Actions.Add(new InstallAction(ActionTypes.Backup)
{
SetupVariables = CtxVars
});
var ServiceCtx = new SetupVariables()
{
ComponentId = CtxVars.ComponentId
};
AppConfig.LoadComponentSettings(ServiceCtx);
if (!string.IsNullOrWhiteSpace(ServiceCtx.ServiceName))
{
CtxVars.ServiceName = ServiceCtx.ServiceName;
CtxVars.ServiceFile = ServiceCtx.ServiceFile;
Result.Actions.Add(new InstallAction(ActionTypes.StopWindowsService));
}
Result.Actions.Add(new InstallAction(ActionTypes.DeleteDirectory)
{
SetupVariables = CtxVars, Path = CtxVars.InstallFolder
});
return(Result);
}
void IInstallAction.Run(SetupVariables vars)
{
try
{
OnInstallProgressChanged(LogStartInstallMessage, 0);
Log.WriteStart(LogStartInstallMessage);
var file = Path.Combine(vars.InstallationFolder, vars.ConfigurationFile);
vars.CryptoKey = Utils.GetRandomString(20);
// load file
string content = string.Empty;
using (StreamReader reader = new StreamReader(file))
{
content = reader.ReadToEnd();
}
// expand variables
content = Utils.ReplaceScriptVariable(content, "installer.cryptokey", vars.CryptoKey);
//
Log.WriteInfo(String.Format("The following cryptographic key has been generated: '{0}'", vars.CryptoKey));
// save file
using (StreamWriter writer = new StreamWriter(file))
{
writer.Write(content);
}
//update log
Log.WriteEnd(LogEndInstallMessage);
}
catch (Exception ex)
{
if (Utils.IsThreadAbortException(ex))
{
return;
}
//
Log.WriteError("Update web.config error", ex);
//
throw;
}
}
void IInstallAction.Run(SetupVariables vars)
{
try
{
OnInstallProgressChanged(LogStartInstallMessage, 0);
Log.WriteStart(LogStartInstallMessage);
var file = Path.Combine(vars.InstallationFolder, vars.ConfigurationFile);
vars.CryptoKey = Utils.GetRandomString(20);
// load file
string content = string.Empty;
using (StreamReader reader = new StreamReader(file))
{
content = reader.ReadToEnd();
}
// expand variables
content = Utils.ReplaceScriptVariable(content, "installer.cryptokey", vars.CryptoKey);
//
Log.WriteInfo(String.Format("The following cryptographic key has been generated: '{0}'", vars.CryptoKey));
// save file
using (StreamWriter writer = new StreamWriter(file))
{
writer.Write(content);
}
//update log
Log.WriteEnd(LogEndInstallMessage);
}
catch (Exception ex)
{
if (Utils.IsThreadAbortException(ex))
return;
//
Log.WriteError("Update web.config error", ex);
//
throw;
}
}
void IPrepareDefaultsAction.Run(SetupVariables vars)
{
//
if (String.IsNullOrEmpty(vars.WebSitePort))
vars.WebSitePort = Global.WebPortal.DefaultPort;
//
if (String.IsNullOrEmpty(vars.UserAccount))
vars.UserAccount = Global.WebPortal.ServiceAccount;
// By default we use public ip for the component
if (String.IsNullOrEmpty(vars.WebSiteIP))
{
var serverIPs = WebUtils.GetIPv4Addresses();
//
if (serverIPs != null && serverIPs.Length > 0)
{
vars.WebSiteIP = serverIPs[0];
}
else
{
vars.WebSiteIP = Global.LoopbackIPv4;
}
}
}
public static CheckStatuses CheckSql(SetupVariables setupVariables, out string Msg)
{
var Result = CheckStatuses.Error;
try
{
var MsgBuilder = new StringBuilder();
var MsgStr = string.Empty;
var ConnStr = setupVariables.InstallConnectionString;
if (CheckConnectionInfo(ConnStr, out MsgStr))
{
string V = SqlUtils.GetSqlServerVersion(ConnStr);
var Valid = new string[] { "9.", "10.", "11.", "12." }.Any(x => V.StartsWith(x));
if (Valid)
if (SqlUtils.GetSqlServerSecurityMode(ConnStr) == 0)
{
MsgBuilder.AppendLine("Good connection.");
Result = CheckStatuses.Success;
}
else
MsgBuilder.AppendLine("Please switch SQL Server authentication to mixed SQL Server and Windows Authentication mode.");
else
MsgBuilder.AppendLine("This program can be installed on SQL Server 2005/2008/2012/2014 only.");
}
else
{
MsgBuilder.AppendLine("SQL Server does not exist or access denied");
MsgBuilder.AppendLine(MsgStr);
}
Msg = MsgBuilder.ToString();
}
catch(Exception ex)
{
Msg = "Unable to configure the database server." + ex.Message;
}
return Result;
}
void IInstallAction.Run(SetupVariables vars)
{
try
{
OnInstallProgressChanged(LogStartInstallMessage, 0);
Log.WriteStart(LogStartInstallMessage);
var file = Path.Combine(vars.InstallationFolder, vars.ConfigurationFile);
vars.CryptoKey = Utils.GetRandomString(20);
var Xml = new XmlDocument();
Xml.Load(file);
var CryptoNode = Xml.SelectSingleNode("configuration/appSettings/add[@key='WebsitePanel.CryptoKey']") as XmlElement;
if (CryptoNode != null)
CryptoNode.SetAttribute("value", vars.CryptoKey);
Xml.Save(file);
Log.WriteEnd(LogEndInstallMessage);
}
catch (Exception ex)
{
if (Utils.IsThreadAbortException(ex))
return;
Log.WriteError("Update web.config error", ex);
throw;
}
}
void IPrepareDefaultsAction.Run(SetupVariables vars)
{
//
if (String.IsNullOrEmpty(vars.WebSiteIP))
vars.WebSiteIP = Global.Server.DefaultIP;
//
if (String.IsNullOrEmpty(vars.WebSitePort))
vars.WebSitePort = Global.Server.DefaultPort;
//
if (string.IsNullOrEmpty(vars.UserAccount))
vars.UserAccount = Global.Server.ServiceAccount;
}
void IInstallAction.Run(SetupVariables vars)
{
try
{
Begin(LogStartInstallMessage);
//
Log.WriteStart("Updating configuration file (server password)");
Log.WriteInfo(String.Format("Server password is: '{0}'", vars.ServerPassword));
Log.WriteInfo("Single quotes are added for clarity purposes");
//
string file = Path.Combine(vars.InstallationFolder, vars.ConfigurationFile);
string hash = Utils.ComputeSHA1(vars.ServerPassword);
// load file
string content = string.Empty;
using (StreamReader reader = new StreamReader(file))
{
content = reader.ReadToEnd();
}
// expand variables
content = Utils.ReplaceScriptVariable(content, "installer.server.password", hash);
// save file
using (StreamWriter writer = new StreamWriter(file))
{
writer.Write(content);
}
}
catch (Exception ex)
{
if (Utils.IsThreadAbortException(ex))
return;
Log.WriteError("Configuration file update error", ex);
throw;
}
}
void IInstallAction.Run(SetupVariables vars)
{
AppConfig.EnsureComponentConfig(vars.ComponentId);
//
AppConfig.SetComponentSettingStringValue(vars.ComponentId, "Database", vars.Database);
AppConfig.SetComponentSettingBooleanValue(vars.ComponentId, "NewDatabase", true);
//
AppConfig.SetComponentSettingStringValue(vars.ComponentId, "DatabaseUser", vars.Database);
AppConfig.SetComponentSettingBooleanValue(vars.ComponentId, "NewDatabaseUser", vars.NewDatabaseUser);
//
AppConfig.SetComponentSettingStringValue(vars.ComponentId, Global.Parameters.ConnectionString, vars.ConnectionString);
AppConfig.SetComponentSettingStringValue(vars.ComponentId, Global.Parameters.DatabaseServer, vars.DatabaseServer);
AppConfig.SetComponentSettingStringValue(vars.ComponentId, Global.Parameters.InstallConnectionString, vars.DbInstallConnectionString);
AppConfig.SetComponentSettingStringValue(vars.ComponentId, Global.Parameters.CryptoKey, vars.CryptoKey);
//
AppConfig.SaveConfiguration();
}
public EntServerActionManager(SetupVariables sessionVars) : base(sessionVars)
{
Initialize += new EventHandler(EntServerActionManager_PreInit);
}
void IInstallAction.Run(SetupVariables vars)
{
try
{
Log.WriteStart("Updating serveradmin password");
//
var path = Path.Combine(vars.InstallationFolder, vars.ConfigurationFile);
var password = vars.ServerAdminPassword;
if (!File.Exists(path))
{
Log.WriteInfo(String.Format("File {0} not found", path));
return;
}
//
bool encryptionEnabled = IsEncryptionEnabled(path);
// Encrypt password
if (encryptionEnabled)
{
password = Utils.Encrypt(vars.CryptoKey, password);
}
//
SqlUtils.ExecuteQuery(vars.DbInstallConnectionString, String.Format(SqlStatement, vars.Database, password));
//
Log.WriteEnd("Updated serveradmin password");
//
InstallLog.AppendLine("- Updated password for the serveradmin account");
//
}
catch (Exception ex)
{
if (Utils.IsThreadAbortException(ex))
return;
//
Log.WriteError("Update error", ex);
throw;
}
}
void IInstallAction.Run(SetupVariables vars)
{
Log.WriteStart("Updating web.config file (connection string)");
//
var file = Path.Combine(vars.InstallationFolder, vars.ConfigurationFile);
//
var content = String.Empty;
// load file
using (StreamReader reader = new StreamReader(file))
{
content = reader.ReadToEnd();
}
// Build connection string
vars.ConnectionString = String.Format(vars.ConnectionString, vars.DatabaseServer, vars.Database, vars.Database, vars.DatabaseUserPassword);
// Expand variables
content = Utils.ReplaceScriptVariable(content, "installer.connectionstring", vars.ConnectionString);
// Save file
using (StreamWriter writer = new StreamWriter(file))
{
writer.Write(content);
}
//
Log.WriteEnd(String.Format("Updated {0} file", vars.ConfigurationFile));
}
void IUninstallAction.Run(SetupVariables vars)
{
try
{
Log.WriteStart("Deleting database user");
Log.WriteInfo(String.Format("Deleting database user \"{0}\"", vars.Database));
//
if (SqlUtils.UserExists(vars.DbInstallConnectionString, vars.Database))
{
SqlUtils.DeleteUser(vars.DbInstallConnectionString, vars.Database);
//
Log.WriteEnd("Deleted database user");
}
}
catch (Exception ex)
{
if (Utils.IsThreadAbortException(ex))
return;
Log.WriteError("Database user delete error", ex);
throw;
}
}
private void ChangeAspNetVersionOnIis7(SetupVariables vars)
{
using (var srvman = new ServerManager())
{
var appPool = srvman.ApplicationPools[vars.WebApplicationPoolName];
//
if (appPool == null)
throw new ArgumentNullException("appPool");
//
appPool.ManagedRuntimeVersion = Iis7_AspNet_v4;
//
srvman.CommitChanges();
}
}
void IInstallAction.Run(SetupVariables vars)
{
try
{
Begin(LogStartInstallMessage);
//
var connectionString = vars.DbInstallConnectionString;
var database = vars.Database;
Log.WriteStart(LogStartInstallMessage);
Log.WriteInfo(String.Format("SQL Server Database Name: \"{0}\"", database));
//
if (SqlUtils.DatabaseExists(connectionString, database))
{
throw new Exception(String.Format("SQL Server database \"{0}\" already exists", database));
}
SqlUtils.CreateDatabase(connectionString, database);
//
Log.WriteEnd("Created SQL Server database");
//
InstallLog.AppendLine(String.Format("- Created a new SQL Server database \"{0}\"", database));
}
catch (Exception ex)
{
if (Utils.IsThreadAbortException(ex))
return;
//
Log.WriteError("Create database error", ex);
//
throw;
}
}
void IInstallAction.Run(SetupVariables vars)
{
try
{
//
Log.WriteStart(String.Format("Creating database user {0}", vars.Database));
//
vars.DatabaseUserPassword = Utils.GetRandomString(20);
//user name should be the same as database
vars.NewDatabaseUser = SqlUtils.CreateUser(vars.DbInstallConnectionString, vars.Database, vars.DatabaseUserPassword, vars.Database);
//
Log.WriteEnd("Created database user");
InstallLog.AppendLine("- Created database user \"{0}\"", vars.Database);
}
catch (Exception ex)
{
if (Utils.IsThreadAbortException(ex))
return;
Log.WriteError("Create db user error", ex);
throw;
}
}
private bool CheckAspNet40Registered(SetupVariables setupVariables)
{
//
var aspNet40Registered = false;
// Run ASP.NET Registration Tool command
var psOutput = Utils.ExecAspNetRegistrationToolCommand(setupVariables, "-lv");
// Split process output per lines
var strLines = psOutput.Split(new char[] { '\n' }, StringSplitOptions.RemoveEmptyEntries);
// Lookup for an evidence of ASP.NET 4.0
aspNet40Registered = strLines.Any((string s) => { return s.Contains("4.0.30319.0"); });
//
return aspNet40Registered;
}
void IInstallAction.Run(SetupVariables vars)
{
if (CheckAspNet40Registered(vars) == false)
{
RegisterAspNet40(vars);
}
}
private void ChangeAspNetVersionOnIis6(SetupVariables vars)
{
//
Utils.ExecAspNetRegistrationToolCommand(vars, String.Format("-norestart -s {0}", vars.WebSiteId));
}
void IUninstallAction.Run(SetupVariables vars)
{
try
{
var path = vars.InstallationFolder;
//
Log.WriteStart(LogStartUninstallMessage);
Log.WriteInfo(String.Format("Deleting directory \"{0}\"", path));
if (FileUtils.DirectoryExists(path))
{
FileUtils.DeleteDirectory(path);
}
}
catch (Exception ex)
{
if (Utils.IsThreadAbortException(ex))
return;
Log.WriteError("Directory delete error", ex);
throw;
}
}
void IInstallAction.Run(SetupVariables vars)
{
try
{
var component = vars.ComponentFullName;
var componentId = vars.ComponentId;
var path = Path.Combine(vars.InstallationFolder, SqlFilePath);
if (!FileUtils.FileExists(path))
{
Log.WriteInfo(String.Format("File {0} not found", path));
return;
}
//
SqlProcess process = new SqlProcess(path, vars.DbInstallConnectionString, vars.Database);
//
process.ProgressChange += new EventHandler<ActionProgressEventArgs<int>>(process_ProgressChange);
//
process.Run();
//
InstallLog.AppendLine(string.Format("- Installed {0} database objects", component));
}
catch (Exception ex)
{
if (Utils.IsThreadAbortException(ex))
return;
//
Log.WriteError("Run sql error", ex);
//
throw;
}
}
void IUninstallAction.Run(SetupVariables vars)
{
try
{
Log.WriteStart(LogStartUninstallMessage);
Log.WriteInfo(String.Format(LogUninstallInfoMessage, vars.ComponentFullName));
XmlUtils.RemoveXmlNode(AppConfig.GetComponentConfig(vars.ComponentId));
AppConfig.SaveConfiguration();
Log.WriteEnd(LogEndUninstallMessage);
InstallLog.AppendLine("- Updated system configuration");
}
catch (Exception ex)
{
if (Utils.IsThreadAbortException(ex))
{
return;
}
//
Log.WriteError(LogErrorUninstallMessage, ex);
throw;
}
}
void IInstallAction.Run(SetupVariables vars)
{
Begin(LogStartInstallMessage);
//
Log.WriteStart(LogStartInstallMessage);
//
AppConfig.EnsureComponentConfig(vars.ComponentId);
//
AppConfig.SetComponentSettingStringValue(vars.ComponentId, "ApplicationName", vars.ApplicationName);
AppConfig.SetComponentSettingStringValue(vars.ComponentId, "ComponentCode", vars.ComponentCode);
AppConfig.SetComponentSettingStringValue(vars.ComponentId, "ComponentName", vars.ComponentName);
AppConfig.SetComponentSettingStringValue(vars.ComponentId, "ComponentDescription", vars.ComponentDescription);
AppConfig.SetComponentSettingStringValue(vars.ComponentId, "Release", vars.Version);
AppConfig.SetComponentSettingStringValue(vars.ComponentId, "Instance", vars.Instance);
AppConfig.SetComponentSettingStringValue(vars.ComponentId, "InstallFolder", vars.InstallationFolder);
AppConfig.SetComponentSettingStringValue(vars.ComponentId, "Installer", vars.Installer);
AppConfig.SetComponentSettingStringValue(vars.ComponentId, "InstallerType", vars.InstallerType);
AppConfig.SetComponentSettingStringValue(vars.ComponentId, "InstallerPath", vars.InstallerPath);
// update config setings
AppConfig.SetComponentSettingBooleanValue(vars.ComponentId, "NewApplicationPool", vars.NewWebApplicationPool);
AppConfig.SetComponentSettingStringValue(vars.ComponentId, "ApplicationPool", vars.WebApplicationPoolName);
// update config setings
AppConfig.SetComponentSettingStringValue(vars.ComponentId, "WebSiteId", vars.WebSiteId);
AppConfig.SetComponentSettingStringValue(vars.ComponentId, "WebSiteIP", vars.WebSiteIP);
AppConfig.SetComponentSettingStringValue(vars.ComponentId, "WebSitePort", vars.WebSitePort);
AppConfig.SetComponentSettingStringValue(vars.ComponentId, "WebSiteDomain", vars.WebSiteDomain);
AppConfig.SetComponentSettingStringValue(vars.ComponentId, "VirtualDirectory", vars.VirtualDirectory);
AppConfig.SetComponentSettingBooleanValue(vars.ComponentId, "NewWebSite", vars.NewWebSite);
AppConfig.SetComponentSettingBooleanValue(vars.ComponentId, "NewVirtualDirectory", vars.NewVirtualDirectory);
//
AppConfig.SetComponentSettingBooleanValue(vars.ComponentId, "NewUserAccount", true);
AppConfig.SetComponentSettingStringValue(vars.ComponentId, "UserAccount", vars.UserAccount);
AppConfig.SetComponentSettingStringValue(vars.ComponentId, "Domain", vars.UserDomain);
//
AppConfig.SaveConfiguration();
}
void IPrepareDefaultsAction.Run(SetupVariables vars)
{
//
if (String.IsNullOrEmpty(vars.InstallationFolder))
vars.InstallationFolder = String.Format(@"C:\WebsitePanel\{0}", vars.ComponentName);
//
if (String.IsNullOrEmpty(vars.WebSiteDomain))
vars.WebSiteDomain = String.Empty;
// Force create new web site
vars.NewWebSite = true;
vars.NewVirtualDirectory = false;
//
if (String.IsNullOrEmpty(vars.ConfigurationFile))
vars.ConfigurationFile = "web.config";
}
void IInstallAction.Run(SetupVariables vars)
{
if (vars.IISVersion.Major == 7)
{
ChangeAspNetVersionOnIis7(vars);
}
else
{
ChangeAspNetVersionOnIis6(vars);
}
}
void IInstallAction.Run(SetupVariables vars)
{
try
{
Begin(LogStartInstallMessage);
//
var source = vars.InstallerFolder;
var destination = vars.InstallationFolder;
//
string component = vars.ComponentFullName;
//
Log.WriteStart(LogStartInstallMessage);
Log.WriteInfo(String.Format("Copying files from \"{0}\" to \"{1}\"", source, destination));
//showing copy process
DoFilesCopyProcess(source, destination);
//
InstallLog.AppendLine(String.Format("- Copied {0} files", component));
// rollback
//RollBack.RegisterDirectoryAction(destination);
}
catch (Exception ex)
{
if (Utils.IsThreadAbortException(ex))
return;
Log.WriteError("Copy error", ex);
throw;
}
}
void IPrepareDefaultsAction.Run(SetupVariables vars)
{
//Begin(LogStartMessage);
//
if (!String.IsNullOrEmpty(vars.UserPassword))
return;
//
vars.UserPassword = Guid.NewGuid().ToString();
//
//Finish(LogEndMessage);
}
