1396 lines
45 KiB
C#
1396 lines
45 KiB
C#
// Copyright (c) 2011, Outercurve Foundation.
|
|
// All rights reserved.
|
|
//
|
|
// Redistribution and use in source and binary forms, with or without modification,
|
|
// are permitted provided that the following conditions are met:
|
|
//
|
|
// - Redistributions of source code must retain the above copyright notice, this
|
|
// list of conditions and the following disclaimer.
|
|
//
|
|
// - Redistributions in binary form must reproduce the above copyright notice,
|
|
// this list of conditions and the following disclaimer in the documentation
|
|
// and/or other materials provided with the distribution.
|
|
//
|
|
// - Neither the name of the Outercurve Foundation nor the names of its
|
|
// contributors may be used to endorse or promote products derived from this
|
|
// software without specific prior written permission.
|
|
//
|
|
// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
|
|
// ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
|
|
// WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
|
|
// DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR
|
|
// ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
|
|
// (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
|
|
// LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON
|
|
// ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
|
|
// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
|
|
// SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
|
|
|
|
using System;
|
|
using System.Collections.Generic;
|
|
using System.Text;
|
|
using System.IO;
|
|
using WebsitePanel.Setup.Web;
|
|
using WebsitePanel.Setup.Windows;
|
|
using Microsoft.Web.Management;
|
|
using Microsoft.Web.Administration;
|
|
using Ionic.Zip;
|
|
using System.Xml;
|
|
using System.Management;
|
|
using Microsoft.Win32;
|
|
using System.Linq;
|
|
using System.Xml.Linq;
|
|
using System.Xml.XPath;
|
|
|
|
namespace WebsitePanel.Setup.Actions
|
|
{
|
|
public static class MyExtensions
|
|
{
|
|
public static XElement Element(this XElement parent, XName name, bool createIfNotFound)
|
|
{
|
|
var childNode = parent.Element(name);
|
|
{
|
|
if (childNode != null)
|
|
{
|
|
return childNode;
|
|
}
|
|
};
|
|
//
|
|
if (createIfNotFound.Equals(true))
|
|
{
|
|
childNode = new XElement(name);
|
|
parent.Add(childNode);
|
|
}
|
|
//
|
|
return childNode;
|
|
}
|
|
}
|
|
|
|
#region Actions
|
|
|
|
public class CheckOperatingSystemAction : Action, IPrerequisiteAction
|
|
{
|
|
bool IPrerequisiteAction.Run(SetupVariables vars)
|
|
{
|
|
throw new NotImplementedException();
|
|
}
|
|
|
|
event EventHandler<ActionProgressEventArgs<bool>> IPrerequisiteAction.Complete
|
|
{
|
|
add { throw new NotImplementedException(); }
|
|
remove { throw new NotImplementedException(); }
|
|
}
|
|
}
|
|
|
|
public class CreateWindowsAccountAction : Action, IInstallAction, IUninstallAction
|
|
{
|
|
public const string UserAccountExists = "Account already exists";
|
|
public const string UserAccountDescription = "{0} account for anonymous access to Internet Information Services";
|
|
public const string LogStartMessage = "Creating Windows user account...";
|
|
public const string LogInfoMessage = "Creating Windows user account \"{0}\"";
|
|
public const string LogEndMessage = "Created windows user account";
|
|
public const string InstallLogMessageLocal = "- Created a new Windows user account \"{0}\"";
|
|
public const string InstallLogMessageDomain = "- Created a new Windows user account \"{0}\" in \"{1}\" domain";
|
|
public const string LogStartRollbackMessage = "Removing Windows user account...";
|
|
public const string LogInfoRollbackMessage = "Deleting user account \"{0}\"";
|
|
public const string LogEndRollbackMessage = "User account has been removed";
|
|
public const string LogInfoRollbackMessageDomain = "Could not find user account '{0}' in domain '{1}', thus consider it removed";
|
|
public const string LogInfoRollbackMessageLocal = "Could not find user account '{0}', thus consider it removed";
|
|
public const string LogErrorRollbackMessage = "Could not remove Windows user account";
|
|
|
|
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));
|
|
}
|
|
|
|
public override bool Indeterminate
|
|
{
|
|
get { return true; }
|
|
}
|
|
|
|
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 IUninstallAction.Run(SetupVariables vars)
|
|
{
|
|
try
|
|
{
|
|
Log.WriteStart(LogStartRollbackMessage);
|
|
Log.WriteInfo(String.Format(LogInfoRollbackMessage, vars.UserAccount));
|
|
//
|
|
if (SecurityUtils.UserExists(vars.UserDomain, vars.UserAccount))
|
|
{
|
|
SecurityUtils.DeleteUser(vars.UserDomain, vars.UserAccount);
|
|
}
|
|
else
|
|
{
|
|
if (!String.IsNullOrEmpty(vars.UserDomain))
|
|
{
|
|
Log.WriteInfo(String.Format(LogInfoRollbackMessageDomain, vars.UserAccount, vars.UserDomain));
|
|
}
|
|
else
|
|
{
|
|
Log.WriteInfo(String.Format(LogInfoRollbackMessageLocal, vars.UserAccount));
|
|
}
|
|
}
|
|
//
|
|
Log.WriteEnd(LogEndRollbackMessage);
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
if (Utils.IsThreadAbortException(ex))
|
|
{
|
|
return;
|
|
}
|
|
//
|
|
Log.WriteError(LogErrorRollbackMessage, ex);
|
|
throw;
|
|
}
|
|
}
|
|
}
|
|
|
|
public class ConfigureAspNetTempFolderPermissionsAction : Action, IInstallAction
|
|
{
|
|
void IInstallAction.Run(SetupVariables vars)
|
|
{
|
|
try
|
|
{
|
|
string path;
|
|
if (vars.IISVersion.Major == 6)
|
|
{
|
|
// IIS_WPG -> C:\WINDOWS\Temp
|
|
path = Environment.GetEnvironmentVariable("TMP", EnvironmentVariableTarget.Machine);
|
|
SetFolderPermission(path, "IIS_WPG", NtfsPermission.Modify);
|
|
|
|
// IIS_WPG - > C:\WINDOWS\Microsoft.NET\Framework\v2.0.50727\Temporary ASP.NET Files
|
|
path = Path.Combine(System.Runtime.InteropServices.RuntimeEnvironment.GetRuntimeDirectory(),
|
|
"Temporary ASP.NET Files");
|
|
if (Utils.IsWin64() && Utils.IIS32Enabled())
|
|
path = path.Replace("Framework64", "Framework");
|
|
SetFolderPermission(path, "IIS_WPG", NtfsPermission.Modify);
|
|
}
|
|
// NETWORK_SERVICE -> C:\WINDOWS\Temp
|
|
path = Environment.GetEnvironmentVariable("TMP", EnvironmentVariableTarget.Machine);
|
|
//
|
|
SetFolderPermissionBySid(path, SystemSID.NETWORK_SERVICE, NtfsPermission.Modify);
|
|
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
if (Utils.IsThreadAbortException(ex))
|
|
return;
|
|
|
|
Log.WriteError("Security error", ex);
|
|
}
|
|
}
|
|
|
|
private void SetFolderPermission(string path, string account, NtfsPermission permission)
|
|
{
|
|
try
|
|
{
|
|
if (!FileUtils.DirectoryExists(path))
|
|
{
|
|
FileUtils.CreateDirectory(path);
|
|
Log.WriteInfo(string.Format("Created {0} folder", path));
|
|
}
|
|
|
|
Log.WriteStart(string.Format("Setting '{0}' permission for '{1}' folder for '{2}' account", permission, path, account));
|
|
SecurityUtils.GrantNtfsPermissions(path, null, account, permission, true, true);
|
|
Log.WriteEnd("Set security permissions");
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
if (Utils.IsThreadAbortException(ex))
|
|
return;
|
|
|
|
Log.WriteError("Security error", ex);
|
|
}
|
|
}
|
|
|
|
private void SetFolderPermissionBySid(string path, string account, NtfsPermission permission)
|
|
{
|
|
try
|
|
{
|
|
if (!FileUtils.DirectoryExists(path))
|
|
{
|
|
FileUtils.CreateDirectory(path);
|
|
Log.WriteInfo(string.Format("Created {0} folder", path));
|
|
}
|
|
|
|
Log.WriteStart(string.Format("Setting '{0}' permission for '{1}' folder for '{2}' account", permission, path, account));
|
|
SecurityUtils.GrantNtfsPermissionsBySid(path, account, permission, true, true);
|
|
Log.WriteEnd("Set security permissions");
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
if (Utils.IsThreadAbortException(ex))
|
|
return;
|
|
|
|
Log.WriteError("Security error", ex);
|
|
}
|
|
}
|
|
}
|
|
|
|
public class SetNtfsPermissionsAction : Action, IInstallAction
|
|
{
|
|
public const string LogStartInstallMessage = "Configuring folder permissions...";
|
|
public const string LogEndInstallMessage = "NTFS permissions has been applied to the application folder...";
|
|
public const string LogInstallErrorMessage = "Could not set content folder NTFS permissions";
|
|
public const string FqdnIdentity = "{0}\\{1}";
|
|
|
|
public override bool Indeterminate
|
|
{
|
|
get { return true; }
|
|
}
|
|
|
|
void IInstallAction.Run(SetupVariables vars)
|
|
{
|
|
string contentPath = vars.InstallationFolder;
|
|
|
|
//creating user account
|
|
string userName = vars.UserAccount;
|
|
string userDomain = vars.UserDomain;
|
|
string netbiosDomain = userDomain;
|
|
//
|
|
try
|
|
{
|
|
Begin(LogStartInstallMessage);
|
|
//
|
|
Log.WriteStart(LogStartInstallMessage);
|
|
//
|
|
if (!String.IsNullOrEmpty(userDomain))
|
|
{
|
|
netbiosDomain = SecurityUtils.GetNETBIOSDomainName(userDomain);
|
|
}
|
|
//
|
|
WebUtils.SetWebFolderPermissions(contentPath, netbiosDomain, userName);
|
|
//
|
|
Log.WriteEnd(LogEndInstallMessage);
|
|
//
|
|
Finish(LogStartInstallMessage);
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
if (Utils.IsThreadAbortException(ex))
|
|
return;
|
|
|
|
Log.WriteError(LogInstallErrorMessage, ex);
|
|
|
|
throw;
|
|
}
|
|
}
|
|
}
|
|
|
|
public class CreateWebApplicationPoolAction : Action, IInstallAction, IUninstallAction
|
|
{
|
|
public const string AppPoolNameFormatString = "{0} Pool";
|
|
public const string LogStartInstallMessage = "Creating application pool for the web site...";
|
|
public const string LogStartUninstallMessage = "Removing application pool...";
|
|
public const string LogUninstallAppPoolNotFoundMessage = "Application pool not found";
|
|
|
|
public static string GetWebIdentity(SetupVariables vars)
|
|
{
|
|
var userDomain = vars.UserDomain;
|
|
var netbiosDomain = userDomain;
|
|
var userName = vars.UserAccount;
|
|
var iisVersion = vars.IISVersion;
|
|
var iis7 = (iisVersion.Major == 7);
|
|
//
|
|
if (!String.IsNullOrEmpty(userDomain))
|
|
{
|
|
netbiosDomain = SecurityUtils.GetNETBIOSDomainName(userDomain);
|
|
//
|
|
if (iis7)
|
|
{
|
|
//for iis7 we use fqdn\user
|
|
return String.Format(SetNtfsPermissionsAction.FqdnIdentity, userDomain, userName);
|
|
}
|
|
else
|
|
{
|
|
//for iis6 we use netbiosdomain\user
|
|
return String.Format(SetNtfsPermissionsAction.FqdnIdentity, netbiosDomain, userName);
|
|
}
|
|
}
|
|
//
|
|
return userName;
|
|
}
|
|
|
|
public override bool Indeterminate
|
|
{
|
|
get { return true; }
|
|
}
|
|
|
|
void IInstallAction.Run(SetupVariables vars)
|
|
{
|
|
var appPoolName = String.Format(AppPoolNameFormatString, vars.ComponentFullName);
|
|
var userDomain = vars.UserDomain;
|
|
var netbiosDomain = userDomain;
|
|
var userName = vars.UserAccount;
|
|
var userPassword = vars.UserPassword;
|
|
var identity = GetWebIdentity(vars);
|
|
var componentId = vars.ComponentId;
|
|
var iisVersion = vars.IISVersion;
|
|
var iis7 = (iisVersion.Major == 7);
|
|
var poolExists = false;
|
|
|
|
//
|
|
vars.WebApplicationPoolName = appPoolName;
|
|
|
|
// Maintain backward compatibility
|
|
if (iis7)
|
|
{
|
|
poolExists = WebUtils.IIS7ApplicationPoolExists(appPoolName);
|
|
}
|
|
else
|
|
{
|
|
poolExists = WebUtils.ApplicationPoolExists(appPoolName);
|
|
}
|
|
|
|
// This flag is the opposite of poolExists flag
|
|
vars.NewWebApplicationPool = !poolExists;
|
|
|
|
if (poolExists)
|
|
{
|
|
//update app pool
|
|
Log.WriteStart("Updating application pool");
|
|
Log.WriteInfo(String.Format("Updating application pool \"{0}\"", appPoolName));
|
|
//
|
|
if (iis7)
|
|
{
|
|
WebUtils.UpdateIIS7ApplicationPool(appPoolName, userName, userPassword);
|
|
}
|
|
else
|
|
{
|
|
WebUtils.UpdateApplicationPool(appPoolName, userName, userPassword);
|
|
}
|
|
|
|
//
|
|
//update log
|
|
Log.WriteEnd("Updated application pool");
|
|
|
|
//update install log
|
|
InstallLog.AppendLine(String.Format("- Updated application pool named \"{0}\"", appPoolName));
|
|
}
|
|
else
|
|
{
|
|
// create app pool
|
|
Log.WriteStart("Creating application pool");
|
|
Log.WriteInfo(String.Format("Creating application pool \"{0}\"", appPoolName));
|
|
//
|
|
if (iis7)
|
|
{
|
|
WebUtils.CreateIIS7ApplicationPool(appPoolName, userName, userPassword);
|
|
}
|
|
else
|
|
{
|
|
WebUtils.CreateApplicationPool(appPoolName, userName, userPassword);
|
|
}
|
|
|
|
//update log
|
|
Log.WriteEnd("Created application pool");
|
|
|
|
//update install log
|
|
InstallLog.AppendLine(String.Format("- Created a new application pool named \"{0}\"", appPoolName));
|
|
}
|
|
}
|
|
|
|
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);
|
|
}
|
|
}
|
|
}
|
|
|
|
public class CreateWebSiteAction : Action, IInstallAction, IUninstallAction
|
|
{
|
|
public const string LogStartMessage = "Creating web site...";
|
|
public const string LogEndMessage = "";
|
|
|
|
public override bool Indeterminate
|
|
{
|
|
get { return true; }
|
|
}
|
|
|
|
void IInstallAction.Run(SetupVariables vars)
|
|
{
|
|
var siteName = vars.ComponentFullName;
|
|
var ip = vars.WebSiteIP;
|
|
var port = vars.WebSitePort;
|
|
var domain = vars.WebSiteDomain;
|
|
var contentPath = vars.InstallationFolder;
|
|
var iisVersion = vars.IISVersion;
|
|
var iis7 = (iisVersion.Major == 7);
|
|
var userName = CreateWebApplicationPoolAction.GetWebIdentity(vars);
|
|
var userPassword = vars.UserPassword;
|
|
var appPool = vars.WebApplicationPoolName;
|
|
var componentId = vars.ComponentId;
|
|
var newSiteId = String.Empty;
|
|
//
|
|
Begin(LogStartMessage);
|
|
//
|
|
Log.WriteStart(LogStartMessage);
|
|
//
|
|
Log.WriteInfo(String.Format("Creating web site \"{0}\" ( IP: {1}, Port: {2}, Domain: {3} )", siteName, ip, port, domain));
|
|
|
|
//check for existing site
|
|
var oldSiteId = iis7 ? WebUtils.GetIIS7SiteIdByBinding(ip, port, domain) : WebUtils.GetSiteIdByBinding(ip, port, domain);
|
|
//
|
|
if (oldSiteId != null)
|
|
{
|
|
// get site name
|
|
string oldSiteName = iis7 ? oldSiteId : WebUtils.GetSite(oldSiteId).Name;
|
|
throw new Exception(
|
|
String.Format("'{0}' web site already has server binding ( IP: {1}, Port: {2}, Domain: {3} )",
|
|
oldSiteName, ip, port, domain));
|
|
}
|
|
|
|
// create site
|
|
var site = new WebSiteItem
|
|
{
|
|
Name = siteName,
|
|
SiteIPAddress = ip,
|
|
ContentPath = contentPath,
|
|
AllowExecuteAccess = false,
|
|
AllowScriptAccess = true,
|
|
AllowSourceAccess = false,
|
|
AllowReadAccess = true,
|
|
AllowWriteAccess = false,
|
|
AnonymousUsername = userName,
|
|
AnonymousUserPassword = userPassword,
|
|
AllowDirectoryBrowsingAccess = false,
|
|
AuthAnonymous = true,
|
|
AuthWindows = true,
|
|
DefaultDocs = null,
|
|
HttpRedirect = "",
|
|
InstalledDotNetFramework = AspNetVersion.AspNet20,
|
|
ApplicationPool = appPool,
|
|
//
|
|
Bindings = new ServerBinding[] {
|
|
new ServerBinding(ip, port, domain)
|
|
},
|
|
};
|
|
|
|
// create site
|
|
if (iis7)
|
|
{
|
|
newSiteId = WebUtils.CreateIIS7Site(site);
|
|
}
|
|
else
|
|
{
|
|
newSiteId = WebUtils.CreateSite(site);
|
|
}
|
|
|
|
vars.VirtualDirectory = String.Empty;
|
|
vars.NewWebSite = true;
|
|
vars.NewVirtualDirectory = false;
|
|
|
|
// update setup variables
|
|
vars.WebSiteId = newSiteId;
|
|
|
|
//update log
|
|
Log.WriteEnd("Created web site");
|
|
//
|
|
Finish(LogStartMessage);
|
|
|
|
//update install log
|
|
InstallLog.AppendLine(string.Format("- Created a new web site named \"{0}\" ({1})", siteName, newSiteId));
|
|
InstallLog.AppendLine(" You can access the application by the following URLs:");
|
|
string[] urls = Utils.GetApplicationUrls(ip, domain, port, null);
|
|
foreach (string url in urls)
|
|
{
|
|
InstallLog.AppendLine(" http://" + url);
|
|
}
|
|
}
|
|
|
|
void IUninstallAction.Run(SetupVariables vars)
|
|
{
|
|
var iisVersion = vars.IISVersion;
|
|
var iis7 = (iisVersion.Major == 7);
|
|
var siteId = vars.WebSiteId;
|
|
//
|
|
try
|
|
{
|
|
Log.WriteStart("Deleting web site");
|
|
Log.WriteInfo(String.Format("Deleting web site \"{0}\"", siteId));
|
|
if (iis7)
|
|
{
|
|
if (WebUtils.IIS7SiteExists(siteId))
|
|
{
|
|
WebUtils.DeleteIIS7Site(siteId);
|
|
Log.WriteEnd("Deleted web site");
|
|
}
|
|
}
|
|
else
|
|
{
|
|
if (WebUtils.SiteIdExists(siteId))
|
|
{
|
|
WebUtils.DeleteSite(siteId);
|
|
Log.WriteEnd("Deleted web site");
|
|
}
|
|
}
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
if (Utils.IsThreadAbortException(ex))
|
|
return;
|
|
|
|
Log.WriteError("Web site delete error", ex);
|
|
throw;
|
|
}
|
|
}
|
|
}
|
|
|
|
public class CopyFilesAction : Action, IInstallAction, IUninstallAction
|
|
{
|
|
public const string LogStartInstallMessage = "Copying files...";
|
|
public const string LogStartUninstallMessage = "Deleting files copied...";
|
|
|
|
internal void DoFilesCopyProcess(string source, string destination)
|
|
{
|
|
var sourceFolder = new DirectoryInfo(source);
|
|
var destFolder = new DirectoryInfo(destination);
|
|
// unzip
|
|
long totalSize = FileUtils.CalculateFolderSize(sourceFolder.FullName);
|
|
long copied = 0;
|
|
|
|
int i = 0;
|
|
List<DirectoryInfo> folders = new List<DirectoryInfo>();
|
|
List<FileInfo> files = new List<FileInfo>();
|
|
|
|
DirectoryInfo di = null;
|
|
//FileInfo fi = null;
|
|
string path = null;
|
|
|
|
// Part 1: Indexing
|
|
folders.Add(sourceFolder);
|
|
while (i < folders.Count)
|
|
{
|
|
foreach (DirectoryInfo info in folders[i].GetDirectories())
|
|
{
|
|
if (!folders.Contains(info))
|
|
folders.Add(info);
|
|
}
|
|
foreach (FileInfo info in folders[i].GetFiles())
|
|
{
|
|
files.Add(info);
|
|
}
|
|
i++;
|
|
}
|
|
|
|
// Part 2: Destination Folders Creation
|
|
///////////////////////////////////////////////////////
|
|
for (i = 0; i < folders.Count; i++)
|
|
{
|
|
if (folders[i].Exists)
|
|
{
|
|
path = destFolder.FullName +
|
|
Path.DirectorySeparatorChar +
|
|
folders[i].FullName.Remove(0, sourceFolder.FullName.Length);
|
|
|
|
di = new DirectoryInfo(path);
|
|
|
|
// Prevent IOException
|
|
if (!di.Exists)
|
|
di.Create();
|
|
}
|
|
}
|
|
|
|
// Part 3: Source to Destination File Copy
|
|
///////////////////////////////////////////////////////
|
|
for (i = 0; i < files.Count; i++)
|
|
{
|
|
if (files[i].Exists)
|
|
{
|
|
path = destFolder.FullName +
|
|
Path.DirectorySeparatorChar +
|
|
files[i].FullName.Remove(0, sourceFolder.FullName.Length + 1);
|
|
FileUtils.CopyFile(files[i], path);
|
|
copied += files[i].Length;
|
|
if (totalSize != 0)
|
|
{
|
|
// Update progress
|
|
OnInstallProgressChanged(files[i].Name, Convert.ToInt32(copied * 100 / totalSize));
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
public override bool Indeterminate
|
|
{
|
|
get { return false; }
|
|
}
|
|
|
|
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 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;
|
|
}
|
|
}
|
|
}
|
|
|
|
public class SetServerPasswordAction : Action, IInstallAction
|
|
{
|
|
public const string LogStartInstallMessage = "Setting server password...";
|
|
|
|
public override bool Indeterminate
|
|
{
|
|
get { return true; }
|
|
}
|
|
|
|
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;
|
|
}
|
|
}
|
|
}
|
|
|
|
public class SetCommonDistributiveParamsAction : Action, IPrepareDefaultsAction
|
|
{
|
|
public override bool Indeterminate
|
|
{
|
|
get { return true; }
|
|
}
|
|
|
|
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";
|
|
}
|
|
}
|
|
|
|
public class EnsureServiceAccntSecured : Action, IPrepareDefaultsAction
|
|
{
|
|
public const string LogStartMessage = "Verifying setup parameters...";
|
|
|
|
public override bool Indeterminate
|
|
{
|
|
get { return true; }
|
|
}
|
|
|
|
void IPrepareDefaultsAction.Run(SetupVariables vars)
|
|
{
|
|
//Begin(LogStartMessage);
|
|
//
|
|
if (!String.IsNullOrEmpty(vars.UserPassword))
|
|
return;
|
|
//
|
|
vars.UserPassword = Guid.NewGuid().ToString();
|
|
//
|
|
//Finish(LogEndMessage);
|
|
}
|
|
}
|
|
|
|
public class SetServerDefaultInstallationSettingsAction : Action, IPrepareDefaultsAction
|
|
{
|
|
public override bool Indeterminate
|
|
{
|
|
get { return true; }
|
|
}
|
|
|
|
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;
|
|
}
|
|
}
|
|
|
|
public class SaveComponentConfigSettingsAction : Action, IInstallAction, IUninstallAction
|
|
{
|
|
#region Uninstall
|
|
public const string LogStartUninstallMessage = "Removing \"{0}\" component's configuration details";
|
|
public const string LogUninstallInfoMessage = "Deleting \"{0}\" component settings";
|
|
public const string LogErrorUninstallMessage = "Failed to remove the component configuration details";
|
|
public const string LogEndUninstallMessage = "Component's configuration has been removed";
|
|
#endregion
|
|
|
|
public const string LogStartInstallMessage = "Updating system configuration...";
|
|
|
|
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 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;
|
|
}
|
|
}
|
|
}
|
|
|
|
public class SwitchAppPoolAspNetVersion : Action, IInstallAction
|
|
{
|
|
public const string Iis6_AspNet_v4 = "v4.0.30319";
|
|
public const string Iis7_AspNet_v4 = "v4.0";
|
|
|
|
void IInstallAction.Run(SetupVariables vars)
|
|
{
|
|
if (vars.IISVersion.Major == 7)
|
|
{
|
|
ChangeAspNetVersionOnIis7(vars);
|
|
}
|
|
else
|
|
{
|
|
ChangeAspNetVersionOnIis6(vars);
|
|
}
|
|
}
|
|
|
|
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();
|
|
}
|
|
}
|
|
|
|
private void ChangeAspNetVersionOnIis6(SetupVariables vars)
|
|
{
|
|
//
|
|
Utils.ExecAspNetRegistrationToolCommand(vars, String.Format("-norestart -s {0}", vars.WebSiteId));
|
|
}
|
|
}
|
|
|
|
public class RegisterAspNet40Action : Action, IInstallAction
|
|
{
|
|
void IInstallAction.Run(SetupVariables vars)
|
|
{
|
|
if (CheckAspNet40Registered(vars) == false)
|
|
{
|
|
RegisterAspNet40(vars);
|
|
}
|
|
}
|
|
|
|
private void RegisterAspNet40(Setup.SetupVariables setupVariables)
|
|
{
|
|
// Run ASP.NET Registration Tool command
|
|
Utils.ExecAspNetRegistrationToolCommand(setupVariables, arguments: (setupVariables.IISVersion.Major == 6) ? "-ir -enable" : "-ir");
|
|
}
|
|
|
|
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;
|
|
}
|
|
}
|
|
|
|
public class EnableAspNetWebExtensionAction : Action, IInstallAction
|
|
{
|
|
void IInstallAction.Run(SetupVariables vars)
|
|
{
|
|
if (vars.IISVersion.Major > 6)
|
|
return;
|
|
// Enable ASP.NET 4.0 Web Server Extension if it is prohibited
|
|
if (Utils.GetAspNetWebExtensionStatus_Iis6(vars) == WebExtensionStatus.Prohibited)
|
|
{
|
|
Utils.EnableAspNetWebExtension_Iis6();
|
|
}
|
|
}
|
|
}
|
|
|
|
public class MigrateServerWebConfigAction : Action, IInstallAction
|
|
{
|
|
void IInstallAction.Run(SetupVariables vars)
|
|
{
|
|
//
|
|
DoMigration(vars);
|
|
}
|
|
|
|
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");
|
|
{
|
|
//
|
|
if (swnode.Element("compilation") != null)
|
|
swnode.Element("compilation").Remove();
|
|
};
|
|
// Find/add WCF endpoints configuration section (DDTK)
|
|
var serviceModelNode = xdoc.Root.Element("system.serviceModel", true);
|
|
{
|
|
// Find/add bindings node if does not exist
|
|
var bindingsNode = serviceModelNode.Element("bindings", true);
|
|
{
|
|
// Find/add wsHttpBinding node if does not exist
|
|
var wsHttpBindingNode = bindingsNode.Element("wsHttpBinding", true);
|
|
{
|
|
// Find SCVMM-DDTK endpoint binding configuration
|
|
var vmmBindingNode = wsHttpBindingNode.XPathSelectElement("binding[@name='WSHttpBinding_IVirtualMachineManagementService']");
|
|
// Add SCVMM-DDTK endpoint binding configuration
|
|
if (vmmBindingNode == null)
|
|
wsHttpBindingNode.Add(XElement.Parse("<binding name=\"WSHttpBinding_IVirtualMachineManagementService\" closeTimeout=\"00:01:00\" openTimeout=\"00:01:00\" receiveTimeout=\"00:10:00\" sendTimeout=\"00:01:00\" bypassProxyOnLocal=\"false\" transactionFlow=\"false\" hostNameComparisonMode=\"StrongWildcard\" maxBufferPoolSize=\"524288\" maxReceivedMessageSize=\"10485760\" messageEncoding=\"Text\" textEncoding=\"utf-8\" useDefaultWebProxy=\"true\" allowCookies=\"false\"><readerQuotas maxDepth=\"32\" maxStringContentLength=\"8192\" maxArrayLength=\"16384\" maxBytesPerRead=\"4096\" maxNameTableCharCount=\"16384\" /><reliableSession ordered=\"true\" inactivityTimeout=\"00:10:00\" enabled=\"false\" /><security mode=\"Message\"><transport clientCredentialType=\"Windows\" proxyCredentialType=\"None\" realm=\"\" /><message clientCredentialType=\"Windows\" negotiateServiceCredential=\"true\" algorithmSuite=\"Default\" /></security></binding>"));
|
|
// Find SCOM-DDTK endpoint binding configuration
|
|
var omBindingNode = wsHttpBindingNode.XPathSelectElement("binding[@name='WSHttpBinding_IMonitoringService']");
|
|
// Add SCOM-DDTK endpoint binding configuration
|
|
if (omBindingNode == null)
|
|
wsHttpBindingNode.Add(XElement.Parse("<binding name=\"WSHttpBinding_IMonitoringService\" closeTimeout=\"00:01:00\" openTimeout=\"00:01:00\" receiveTimeout=\"00:10:00\" sendTimeout=\"00:01:00\" bypassProxyOnLocal=\"false\" transactionFlow=\"false\" hostNameComparisonMode=\"StrongWildcard\" maxBufferPoolSize=\"524288\" maxReceivedMessageSize=\"10485760\" messageEncoding=\"Text\" textEncoding=\"utf-8\" useDefaultWebProxy=\"true\" allowCookies=\"false\"><readerQuotas maxDepth=\"32\" maxStringContentLength=\"8192\" maxArrayLength=\"16384\" maxBytesPerRead=\"4096\" maxNameTableCharCount=\"16384\" /><reliableSession ordered=\"true\" inactivityTimeout=\"00:10:00\" enabled=\"false\" /><security mode=\"Message\"><transport clientCredentialType=\"Windows\" proxyCredentialType=\"None\" realm=\"\" /><message clientCredentialType=\"Windows\" negotiateServiceCredential=\"true\" algorithmSuite=\"Default\" /></security></binding>"));
|
|
};
|
|
};
|
|
};
|
|
// Save all changes
|
|
xdoc.Save(fileName);
|
|
}
|
|
}
|
|
|
|
public class MigrateEntServerWebConfigAction : Action, IInstallAction
|
|
{
|
|
void IInstallAction.Run(SetupVariables vars)
|
|
{
|
|
//
|
|
DoMigration(vars);
|
|
}
|
|
|
|
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");
|
|
{
|
|
//
|
|
if (swnode.Element("compilation") != null)
|
|
swnode.Element("compilation").Remove();
|
|
};
|
|
// Save all changes
|
|
xdoc.Save(fileName);
|
|
}
|
|
}
|
|
|
|
public class AdjustHttpRuntimeRequestLengthAction : Action, IInstallAction
|
|
{
|
|
void IInstallAction.Run(SetupVariables vars)
|
|
{
|
|
//
|
|
DoMigration(vars);
|
|
}
|
|
|
|
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);
|
|
}
|
|
}
|
|
|
|
public class MigrateWebPortalWebConfigAction : Action, IInstallAction
|
|
{
|
|
void IInstallAction.Run(SetupVariables vars)
|
|
{
|
|
//
|
|
if (vars.IISVersion.Major == 6)
|
|
{
|
|
DoMigrationOnIis6(vars);
|
|
}
|
|
else
|
|
{
|
|
DoMigrationOnIis7(vars);
|
|
}
|
|
}
|
|
|
|
private void DoMigrationOnIis7(SetupVariables vars)
|
|
{
|
|
var fileName = Path.Combine(vars.InstallationFolder, "web.config");
|
|
//
|
|
var xdoc = XDocument.Load(fileName);
|
|
// Remove <configSections /> node
|
|
if (xdoc.Root.Element("configSections") != null)
|
|
xdoc.Root.Element("configSections").Remove();
|
|
// Remove <system.web.extensions /> node
|
|
if (xdoc.Root.Element("system.web.extensions") != null)
|
|
xdoc.Root.Element("system.web.extensions").Remove();
|
|
// Modify <appSettings /> node
|
|
var apsnode = xdoc.Root.Element("appSettings");
|
|
{
|
|
if (apsnode.XPathSelectElement("add[@key='ChartImageHandler']") == null)
|
|
apsnode.Add(XElement.Parse("<add key=\"ChartImageHandler\" value=\"storage=file;timeout=20;\" />"));
|
|
}
|
|
// Modify <system.web /> node child elements
|
|
var swnode = xdoc.Root.Element("system.web");
|
|
{
|
|
// Modify <pages /> node
|
|
var pnode = swnode.Element("pages");
|
|
{
|
|
// Set rendering compatibility
|
|
pnode.SetAttributeValue("controlRenderingCompatibilityVersion", "3.5");
|
|
// Select all legacy controls definitions
|
|
var nodes = from node in pnode.Element("controls").Elements()
|
|
where (String)node.Attribute("tagPrefix") == "asp"
|
|
select node;
|
|
// Remove all nodes found
|
|
nodes.Remove();
|
|
};
|
|
// Set compatible request validation mode
|
|
swnode.Element("httpRuntime").SetAttributeValue("requestValidationMode", "2.0");
|
|
// Modify <httpHandlers /> node
|
|
var hhnode = swnode.Element("httpHandlers");
|
|
{
|
|
// Remove <remove /> node
|
|
if (hhnode.XPathSelectElement("remove[@path='*.asmx']") != null)
|
|
hhnode.XPathSelectElement("remove[@path='*.asmx']").Remove();
|
|
//
|
|
if (hhnode.XPathSelectElement("add[@path='*_AppService.axd']") != null)
|
|
hhnode.XPathSelectElement("add[@path='*_AppService.axd']").Remove();
|
|
//
|
|
if (hhnode.XPathSelectElement("add[@path='*.asmx']") != null)
|
|
hhnode.XPathSelectElement("add[@path='*.asmx']").Remove();
|
|
//
|
|
if (hhnode.XPathSelectElement("add[@path='ScriptResource.axd']") != null)
|
|
hhnode.XPathSelectElement("add[@path='ScriptResource.axd']").Remove();
|
|
};
|
|
// Remove <httpModules /> node
|
|
if (swnode.Element("httpModules") != null)
|
|
swnode.Element("httpModules").Remove();
|
|
//
|
|
if (swnode.Element("compilation") != null)
|
|
swnode.Element("compilation").Remove();
|
|
};
|
|
// Remove <system.codedom /> node
|
|
if (xdoc.Root.Element("system.codedom") != null)
|
|
xdoc.Root.Element("system.codedom").Remove();
|
|
//
|
|
var swrnode = xdoc.Root.Element("system.webServer");
|
|
{
|
|
// Remove <modules /> node
|
|
if (swrnode.Element("modules") != null)
|
|
swrnode.Element("modules").Remove();
|
|
// Remove <handlers /> node
|
|
if (swrnode.Element("handlers") != null)
|
|
swrnode.Element("handlers").Remove();
|
|
// Add <handlers /> node
|
|
if (swrnode.Element("handlers") == null)
|
|
swrnode.Add(new XElement("handlers"));
|
|
// Modify <handlers /> node
|
|
var hsnode = swrnode.Element("handlers");
|
|
{
|
|
//
|
|
if (hsnode.XPathSelectElement("add[@path='Reserved.ReportViewerWebControl.axd']") == null)
|
|
hsnode.Add(XElement.Parse("<add name=\"ReportViewerWebControl\" verb=\"*\" path=\"Reserved.ReportViewerWebControl.axd\" type=\"Microsoft.Reporting.WebForms.HttpHandler, Microsoft.ReportViewer.WebForms, Version=8.0.0.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a\" />"));
|
|
//
|
|
if (hsnode.XPathSelectElement("add[@path='ChartImg.axd']") == null)
|
|
hsnode.Add(XElement.Parse("<add name=\"ChartImg\" path=\"ChartImg.axd\" verb=\"GET,HEAD,POST\" type=\"System.Web.UI.DataVisualization.Charting.ChartHttpHandler, System.Web.DataVisualization, Version=4.0.0.0, Culture=neutral, PublicKeyToken=31bf3856ad364e35\" />"));
|
|
}
|
|
};
|
|
// Remove <runtime /> node
|
|
if (xdoc.Root.Element("runtime") != null)
|
|
xdoc.Root.Element("runtime").Remove();
|
|
// Save all changes
|
|
xdoc.Save(fileName);
|
|
}
|
|
|
|
private void DoMigrationOnIis6(SetupVariables vars)
|
|
{
|
|
var fileName = Path.Combine(vars.InstallationFolder, "web.config");
|
|
//
|
|
var xdoc = XDocument.Load(fileName);
|
|
// Remove <configSections /> node
|
|
if (xdoc.Root.Element("configSections") != null)
|
|
xdoc.Root.Element("configSections").Remove();
|
|
// Remove <system.web.extensions /> node
|
|
if (xdoc.Root.Element("system.web.extensions") != null)
|
|
xdoc.Root.Element("system.web.extensions").Remove();
|
|
// Modify <appSettings /> node
|
|
var apsnode = xdoc.Root.Element("appSettings");
|
|
{
|
|
if (apsnode.XPathSelectElement("add[@key='ChartImageHandler']") == null)
|
|
apsnode.Add(XElement.Parse("<add key=\"ChartImageHandler\" value=\"storage=file;timeout=20;\" />"));
|
|
}
|
|
// Modify <system.web /> node child elements
|
|
var swnode = xdoc.Root.Element("system.web");
|
|
{
|
|
// Modify <pages /> node
|
|
var pnode = swnode.Element("pages");
|
|
{
|
|
// Set rendering compatibility
|
|
pnode.SetAttributeValue("controlRenderingCompatibilityVersion", "3.5");
|
|
// Select all legacy controls definitions
|
|
var nodes = from node in pnode.Element("controls").Elements()
|
|
where (String)node.Attribute("tagPrefix") == "asp"
|
|
select node;
|
|
// Remove all nodes found
|
|
nodes.Remove();
|
|
};
|
|
// Set compatible request validation mode
|
|
swnode.Element("httpRuntime").SetAttributeValue("requestValidationMode", "2.0");
|
|
// Modify <httpHandlers /> node
|
|
var hhnode = swnode.Element("httpHandlers");
|
|
{
|
|
// Remove <remove /> node
|
|
if (hhnode.XPathSelectElement("remove[@path='*.asmx']") != null)
|
|
hhnode.XPathSelectElement("remove[@path='*.asmx']").Remove();
|
|
//
|
|
if (hhnode.XPathSelectElement("add[@path='*_AppService.axd']") != null)
|
|
hhnode.XPathSelectElement("add[@path='*_AppService.axd']").Remove();
|
|
//
|
|
if (hhnode.XPathSelectElement("add[@path='*.asmx']") != null)
|
|
hhnode.XPathSelectElement("add[@path='*.asmx']").Remove();
|
|
//
|
|
if (hhnode.XPathSelectElement("add[@path='ScriptResource.axd']") != null)
|
|
hhnode.XPathSelectElement("add[@path='ScriptResource.axd']").Remove();
|
|
//
|
|
if (hhnode.XPathSelectElement("add[@path='ChartImg.axd']") == null)
|
|
hhnode.Add(XElement.Parse("<add path=\"ChartImg.axd\" verb=\"GET,HEAD,POST\" type=\"System.Web.UI.DataVisualization.Charting.ChartHttpHandler, System.Web.DataVisualization, Version=4.0.0.0, Culture=neutral, PublicKeyToken=31bf3856ad364e35\" validate=\"false\" />"));
|
|
};
|
|
// Remove <httpModules /> node
|
|
if (swnode.Element("httpModules") != null)
|
|
swnode.Element("httpModules").Remove();
|
|
// Remove <compilation /> node
|
|
if (swnode.Element("compilation") != null)
|
|
swnode.Element("compilation").Remove();
|
|
};
|
|
// Remove <system.codedom /> node
|
|
if (xdoc.Root.Element("system.codedom") != null)
|
|
xdoc.Root.Element("system.codedom").Remove();
|
|
// Remove <runtime /> node
|
|
if (xdoc.Root.Element("runtime") != null)
|
|
xdoc.Root.Element("runtime").Remove();
|
|
// Save all changes
|
|
xdoc.Save(fileName);
|
|
}
|
|
}
|
|
|
|
public class CleanupWebsitePanelModulesListAction : Action, IInstallAction
|
|
{
|
|
void IInstallAction.Run(SetupVariables vars)
|
|
{
|
|
var filePath = Path.Combine(vars.InstallationFolder, @"App_Data\WebsitePanel_Modules.config");
|
|
//
|
|
var xdoc = XDocument.Load(filePath);
|
|
//
|
|
if (xdoc.XPathSelectElement("//Control[@key='view_addon']") == null)
|
|
{
|
|
return;
|
|
}
|
|
//
|
|
xdoc.XPathSelectElement("//Control[@key='view_addon']").Remove();
|
|
//
|
|
xdoc.Save(filePath);
|
|
}
|
|
}
|
|
|
|
#endregion
|
|
|
|
public class RaiseExceptionAction : Action, IInstallAction
|
|
{
|
|
public override bool Indeterminate
|
|
{
|
|
get { return false; }
|
|
}
|
|
|
|
void IInstallAction.Run(SetupVariables vars)
|
|
{
|
|
throw new NotImplementedException();
|
|
}
|
|
}
|
|
|
|
public class ServerActionManager : BaseActionManager
|
|
{
|
|
public static readonly List<Action> InstallScenario = new List<Action>
|
|
{
|
|
new SetCommonDistributiveParamsAction(),
|
|
new SetServerDefaultInstallationSettingsAction(),
|
|
new EnsureServiceAccntSecured(),
|
|
new CopyFilesAction(),
|
|
new SetServerPasswordAction(),
|
|
new CreateWindowsAccountAction(),
|
|
new ConfigureAspNetTempFolderPermissionsAction(),
|
|
new SetNtfsPermissionsAction(),
|
|
new CreateWebApplicationPoolAction(),
|
|
new CreateWebSiteAction(),
|
|
new SwitchAppPoolAspNetVersion(),
|
|
new SaveComponentConfigSettingsAction()
|
|
};
|
|
|
|
public ServerActionManager(SetupVariables sessionVars)
|
|
: base(sessionVars)
|
|
{
|
|
Initialize += new EventHandler(ServerActionManager_Initialize);
|
|
}
|
|
|
|
void ServerActionManager_Initialize(object sender, EventArgs e)
|
|
{
|
|
//
|
|
switch (SessionVariables.SetupAction)
|
|
{
|
|
case SetupActions.Install: // Install
|
|
LoadInstallationScenario();
|
|
break;
|
|
default:
|
|
break;
|
|
}
|
|
}
|
|
|
|
protected virtual void LoadInstallationScenario()
|
|
{
|
|
CurrentScenario.AddRange(InstallScenario);
|
|
}
|
|
}
|
|
}
|