public void RemoveApplication(string siteName, int appIndex)
{
try
{
using (ServerManager serverManager = GetServerManager())
{
TestUtility.LogTrace(String.Format("#################### Deleting App {0} from Site {1} ####################", appIndex, siteName));
serverManager.Sites[siteName].Applications.RemoveAt(appIndex);
serverManager.CommitChanges();
}
}
catch (Exception ex)
{
TestUtility.LogInformation(String.Format("#################### Deleting App {0} from Site {1} failed. Reason: {2} ####################", appIndex, siteName, ex.Message));
}
}
public void ChangeApplicationPath(string siteName, int appIndex, string path)
{
try
{
using (ServerManager serverManager = GetServerManager())
{
TestUtility.LogTrace(String.Format("#################### Changing Path for App {0} of Site {1} to {2} ####################", appIndex, siteName, path));
serverManager.Sites[siteName].Applications[appIndex].SetAttributeValue("path", path);
serverManager.CommitChanges();
}
}
catch (Exception ex)
{
TestUtility.LogInformation(String.Format("#################### Changing Path for App {0} of Site {1} to {2} failed. Reason: {3} ####################", appIndex, siteName, path, ex.Message));
}
}
public void SetMaxProcessesForAppPool(string appPoolName, int maxProcesses)
{
TestUtility.LogTrace(String.Format("#################### Setting maxProcesses to {0} for AppPool {1} ####################", maxProcesses, appPoolName));
try
{
using (ServerManager serverManager = GetServerManager())
{
ApplicationPoolCollection appPools = serverManager.ApplicationPools;
appPools[appPoolName].ProcessModel.MaxProcesses = maxProcesses;
serverManager.CommitChanges();
}
}
catch (Exception ex)
{
TestUtility.LogInformation(String.Format("#################### Setting maxProcesses to {0} for AppPool {1} failed. Reason: {2} ####################", maxProcesses, appPoolName, ex.Message));
}
}
public void SetIdleTimeoutForAppPool(string appPoolName, int idleTimeoutMinutes)
{
TestUtility.LogTrace(String.Format("#################### Setting idleTimeout to {0} minutes for AppPool {1} ####################", idleTimeoutMinutes, appPoolName));
try
{
using (ServerManager serverManager = GetServerManager())
{
ApplicationPoolCollection appPools = serverManager.ApplicationPools;
appPools[appPoolName].ProcessModel.IdleTimeout = TimeSpan.FromMinutes(idleTimeoutMinutes);
serverManager.CommitChanges();
}
}
catch (Exception ex)
{
TestUtility.LogInformation(String.Format("#################### Setting idleTimeout to {0} minutes for AppPool {1} failed. Reason: {2} ####################", idleTimeoutMinutes, appPoolName, ex.Message));
}
}
private static void Main()
{
using (ServerManager serverManager = new ServerManager())
{
Configuration config = serverManager.GetApplicationHostConfiguration();
ConfigurationSection httpCompressionSection = config.GetSection("system.webServer/httpCompression");
ConfigurationElementCollection httpCompressionCollection = httpCompressionSection.GetCollection();
ConfigurationElement schemeElement = httpCompressionCollection.CreateElement("scheme");
schemeElement["name"] = @"deflate";
schemeElement["doStaticCompression"] = true;
schemeElement["doDynamicCompression"] = true;
schemeElement["dll"] = @"%Windir%\system32\inetsrv\gzip.dll";
httpCompressionCollection.Add(schemeElement);
serverManager.CommitChanges();
}
}
/// <summary>
/// Removes the HTTPS Binding from the specified IIS Site
/// </summary>
/// <param name="siteName"></param>
private static String RemoveHTTPSBindingFromIISSite(string siteName)
{
String existingOneInfo = null;
ServerManager serverMgr = new ServerManager();
Site site = serverMgr.Sites[siteName];
for (int i = 0; i < site.Bindings.Count; i++)
{
if (site.Bindings[i].Protocol.Equals("https"))
{
existingOneInfo = site.Bindings[i].BindingInformation;
site.Bindings.RemoveAt(i);
break;
}
}
serverMgr.CommitChanges();
return(existingOneInfo);
}
public bool CreateVirtualDirectoryV2
(string domainName, string appName, string path)
{
using (ServerManager mgr = new ServerManager())
{
try
{
mgr.Sites[domainName].Applications.Add("/" + appName, path);
mgr.Sites[domainName].Applications["/" + appName].ApplicationPoolName = appName;
mgr.CommitChanges();
return(true);
}
catch (Exception ex)
{
return(false);
}
}
}
/// <summary>
/// Removes the specified UI Module by name
/// </summary>
public static void RemoveUIModuleProvider(string name)
{
using (ServerManager mgr = new ServerManager())
{
Configuration adminConfig = mgr.GetAdministrationConfiguration();
// now remove the ModuleProvider
ConfigurationSection moduleProvidersSection = adminConfig.GetSection("moduleProviders");
ConfigurationElementCollection moduleProviders = moduleProvidersSection.GetCollection();
ConfigurationElement moduleProvider = FindByAttribute(moduleProviders, "name", name);
if (moduleProvider != null)
{
moduleProviders.Remove(moduleProvider);
}
mgr.CommitChanges();
}
}
public static void ActivateAppInitialisationModuleForAllSites()
{
// https://github.com/sandrinodimattia/WindowsAzure-IISApplicationInitializationModule
using (var serverManager = new ServerManager())
{
foreach (var application in serverManager.Sites.SelectMany(site => site.Applications))
{
application["preloadEnabled"] = true;
}
foreach (var appPool in serverManager.ApplicationPools)
{
appPool["startMode"] = "AlwaysRunning";
}
serverManager.CommitChanges();
}
}
/// <summary>
/// 给站点设置应用程序池
/// </summary>
/// <param name="siteName">站点名称</param>
/// <param name="applicationPoolName">应用名称</param>
public static void SetSiteApplicationPool(string siteName, string applicationPoolName, string adminUserName = "", string adminPassword = "")
{
using (ServerManager serverManager = new ServerManager())
{
var site = GetSite(serverManager, siteName);
if (site != null)
{
site.ApplicationDefaults.ApplicationPoolName = applicationPoolName;
if (!string.IsNullOrEmpty(adminUserName) && !string.IsNullOrEmpty(adminPassword))
{
var virtualDic = site.Applications[0].VirtualDirectories[0];
virtualDic.UserName = adminUserName;
virtualDic.Password = adminPassword;
}
}
serverManager.CommitChanges();
}
}
public static void DeleteWebFarm(string name)
{
using (var serverManager = new ServerManager())
{
Configuration config = serverManager.GetApplicationHostConfiguration();
ConfigurationSection section = config.GetSection("webFarms");
ConfigurationElementCollection farms = section.GetCollection();
ConfigurationElement farm = farms.FirstOrDefault(f => f.GetAttributeValue("name").ToString() == name);
if (farm != null)
{
farms.Remove(farm);
serverManager.CommitChanges();
}
}
}
private static void Main()
{
using (ServerManager serverManager = new ServerManager())
{
Configuration config = serverManager.GetApplicationHostConfiguration();
ConfigurationSection isapiFiltersSection = config.GetSection("system.webServer/isapiFilters");
ConfigurationElementCollection isapiFiltersCollection = isapiFiltersSection.GetCollection();
ConfigurationElement filterElement = isapiFiltersCollection.CreateElement("filter");
filterElement["name"] = @"SalesQueryIsapi";
filterElement["path"] = @"c:\Inetpub\www.contoso.com\filters\SalesQueryIsapi.dll";
filterElement["enabled"] = true;
filterElement["enableCache"] = true;
isapiFiltersCollection.Add(filterElement);
serverManager.CommitChanges();
}
}
internal static void UpdateIIS7SiteBindings(string siteId, ServerBinding[] bindings)
{
ServerManager serverManager = new ServerManager();
Site webSite = serverManager.Sites[siteId];
// cleanup all bindings
webSite.Bindings.Clear();
//
foreach (ServerBinding binding in bindings)
{
//
webSite.Bindings.Add(binding.IP + ":" + binding.Port + ":" + binding.Host,
Uri.UriSchemeHttp);
}
//
serverManager.CommitChanges();
}
public override string Execute(IHoconElement param)
{
string poolName = param.GetString();
using (ServerManager serverManager = new ServerManager())
{
var pools = serverManager.ApplicationPools;
var pool = pools[poolName];
if (pool == null)
{
return($"pool {poolName} not exist! can not delete");
}
pools.Remove(pool);
serverManager.CommitChanges();
}
return($"pool {poolName} delete success!");
}
/// <summary>
/// Updates application pool
/// </summary>
/// <param name="name"></param>
/// <param name="username"></param>
/// <param name="password"></param>
internal static void UpdateIIS7ApplicationPool(string name, string username, string password)
{
ServerManager serverManager = new ServerManager();
ApplicationPool pool = serverManager.ApplicationPools[name];
if (!String.IsNullOrEmpty(username))
{
pool.ProcessModel.IdentityType = ProcessModelIdentityType.SpecificUser;
pool.ProcessModel.UserName = username;
pool.ProcessModel.Password = password;
pool.ProcessModel.LoadUserProfile = true;
}
else
{
pool.ProcessModel.IdentityType = ProcessModelIdentityType.NetworkService;
}
serverManager.CommitChanges();
}
private static void Main()
{
using (ServerManager serverManager = new ServerManager()) {
Configuration config = serverManager.GetApplicationHostConfiguration();
ConfigurationSection applicationPoolsSection = config.GetSection("system.applicationHost/applicationPools");
ConfigurationElementCollection applicationPoolsCollection = applicationPoolsSection.GetCollection();
ConfigurationElement addElement = applicationPoolsCollection.CreateElement("add");
addElement["name"] = @"Contoso";
addElement["autoStart"] = true;
addElement["managedPipelineMode"] = @"Integrated";
applicationPoolsCollection.Add(addElement);
serverManager.CommitChanges();
}
}
private static void EnsureDefaultDocument(ServerManager iis)
{
IIS.Configuration applicationHostConfiguration = iis.GetApplicationHostConfiguration();
IIS.ConfigurationSection defaultDocumentSection = applicationHostConfiguration.GetSection("system.webServer/defaultDocument");
IIS.ConfigurationElementCollection filesCollection = defaultDocumentSection.GetCollection("files");
if (filesCollection.Any(ConfigurationElementContainsHostingStart))
{
return;
}
IIS.ConfigurationElement addElement = filesCollection.CreateElement("add");
addElement["value"] = HostingStartHtml;
filesCollection.Add(addElement);
iis.CommitChanges();
}
public override void Run()
{
using (var serverManager = new ServerManager())
{
var mainSite = serverManager.Sites[RoleEnvironment.CurrentRoleInstance.Id + "_Web"];
if (mainSite != null)
{
var mainApplication = mainSite.Applications["/"];
var mainApplicationPool = serverManager.ApplicationPools[mainApplication.ApplicationPoolName];
mainApplicationPool["autoStart"] = true;
mainApplicationPool["startMode"] = "AlwaysRunning";
serverManager.CommitChanges();
}
}
base.Run();
}
/// <summary>
/// 创建站点
/// </summary>
/// <param name="siteName">站点名称</param>
/// <param name="path">站点路径</param>
/// <param name="port">端口</param>
/// <param name="host">主机</param>
/// <param name="adminPassword"></param>
/// <param name="requestType">请求类型：http或者https</param>
/// <param name="adminUserName"></param>
public static void CreateSite(string siteName, string path, string port = "8000", string host = "*", string adminUserName = "", string adminPassword = "", string requestType = "http")
{
using (ServerManager serverManager = new ServerManager())
{
var sites = serverManager.Sites;
if (sites[siteName] == null)
{
var site = sites.Add(siteName, requestType, $"{host}:{port}:", path);
if (!string.IsNullOrEmpty(adminUserName) && !string.IsNullOrEmpty(adminPassword))
{
var virtualDic = site.Applications[0].VirtualDirectories[0];
virtualDic.UserName = adminUserName;
virtualDic.Password = adminPassword;
}
serverManager.CommitChanges();
}
}
}
public bool DeleteVirtualDirectoryV2
(string domainName, string appName)
{
try
{
using (ServerManager mgr = new ServerManager())
{
Application app = mgr.Sites[domainName].Applications["/" + appName];
mgr.Sites[domainName].Applications.Remove(app);
mgr.CommitChanges();
return(true);
}
}
catch (Exception ex)
{
return(false);
}
}
/// <summary>
/// Clean up the iis
/// </summary>
/// <param name="options">
/// </param>
public static void CleanupIIS(WebAppSetupOptions options)
{
using (ServerManager manager = new ServerManager())
{
Site site = manager.Sites[DefaultWebSiteName];
Application app = site.Applications.Where((x, i) => x.Path == "/" + options.VirtualDirectory).FirstOrDefault();
if (app != null)
{
site.Applications.Remove(app);
manager.CommitChanges();
}
// TODO: Currently disabled for debugging purposes
// RemoveDirectory(Path.Combine(options.IISRoot, options.vdirName));
}
}
public void InstallCertificateforBinding(Site site, X509Certificate2 certificate, string host, int sslPort = 443, bool useSNI = true)
{
var store = new X509Store(StoreName.My, StoreLocation.LocalMachine);
store.Open(OpenFlags.OpenExistingOnly | OpenFlags.ReadWrite);
using (var iisManager = new ServerManager())
{
var siteToUpdate = iisManager.Sites.FirstOrDefault(s => s.Id == site.Id);
if (siteToUpdate != null)
{
string internationalHost = _idnMapping.GetUnicode(host);
var existingBinding = (from b in siteToUpdate.Bindings where b.Host == internationalHost && b.Protocol == "https" select b).FirstOrDefault();
if (existingBinding != null)
{
// Update existing https Binding
existingBinding.CertificateHash = certificate.GetCertHash();
existingBinding.CertificateStoreName = store.Name;
}
else
{
//add new https binding at default port
var iisBinding = siteToUpdate.Bindings.Add(":" + sslPort + ":" + internationalHost, certificate.GetCertHash(), store.Name);
iisBinding.Protocol = "https";
if (useSNI)
{
try
{
iisBinding["sslFlags"] = 1; //enable sni
}
catch (Exception)
{
;;
System.Diagnostics.Debug.WriteLine("Cannot apply SNI SSL Flag");
}
}
}
}
iisManager.CommitChanges();
store.Close();
}
}
public string SetAppPool(string appPool, string app, string site)
{
ServerManager serverManager = new ServerManager();
ApplicationPool resultpool = null;
foreach (ApplicationPool pool in serverManager.ApplicationPools)
{
if (pool.Name.ToString() == appPool)
{
resultpool = pool;
}
}
foreach (Site insite in serverManager.Sites)
{
if (insite.Name.ToString() == site)
{
//insite.Stop();
foreach (var item in insite.Applications)
{
if (item.Path.Substring(1) == app)
{
item.ApplicationPoolName = resultpool.Name;
}
}
serverManager.CommitChanges();
//insite.Start();
resultpool.Recycle();
}
}
//foreach (Site mainsite in serverManager.Sites)
//{
// foreach (var item in mainsite.Applications)
// {
// if (item.Path.Substring(1) == app)
// {
// item.ApplicationPoolName = resultpool.Name;
// }
// }
//}
return("OK");
}
/// <summary>
/// Creates site.
/// </summary>
/// <param name="site">Site object.</param>
/// <returns>Site id.</returns>
internal static string CreateIIS7Site(WebSiteItem site)
{
ServerManager serverManager = new ServerManager();
Site webSite = serverManager.Sites[site.Name];
if (webSite == null)
{
webSite = serverManager.Sites.Add(site.Name, site.ContentPath, 80);
}
// cleanup all bindings
webSite.Bindings.Clear();
//
foreach (ServerBinding binding in site.Bindings)
{
//
webSite.Bindings.Add(binding.IP + ":" + binding.Port + ":" + binding.Host,
Uri.UriSchemeHttp);
}
//
webSite.Applications[0].ApplicationPoolName = site.ApplicationPool;
//
//webSite.LogFile.Directory = site.LogFileDirectory;
//
site.SiteId = webSite.Name;
//
webSite.ServerAutoStart = true;
//authentication
Configuration cnfg = serverManager.GetApplicationHostConfiguration();
ConfigurationSection section = cnfg.GetSection("system.webServer/security/authentication/anonymousAuthentication", site.Name);
section["enabled"] = site.AuthAnonymous;
section["userName"] = string.Empty;
section["password"] = string.Empty;
section = cnfg.GetSection("system.webServer/security/authentication/windowsAuthentication", site.Name);
section["enabled"] = site.AuthWindows;
//TODO: default documents
serverManager.CommitChanges();
return(site.SiteId);
}
private void Install_IIS()
{
string siteName = "TqDashboard";
string poolName = "TqDashboardPool";
string physicalPath = DashboardPath;
using (var iis = new ServerManager())
{
Site site = iis.Sites[siteName];
if (site == null)
{
site = iis.Sites.Add(siteName, physicalPath, 0);
site.Bindings.Clear();
}
else
{
return;
}
site.Name = siteName;
site.ApplicationDefaults.ApplicationPoolName = poolName;
ApplicationPool pool = iis.ApplicationPools[poolName];
if (pool == null)
{
pool = iis.ApplicationPools.Add(poolName);
}
pool.Name = poolName;
pool.Enable32BitAppOnWin64 = false;
pool.ManagedRuntimeVersion = "v4.0";
pool.ManagedPipelineMode = ManagedPipelineMode.Integrated;
pool.Failure.OrphanWorkerProcess = false;
pool.ProcessModel.MaxProcesses = 1;
pool.ProcessModel.LoadUserProfile = true;
pool.ProcessModel.IdentityType = ProcessModelIdentityType.LocalSystem;
// set binginds
site.Bindings.Clear();
site.Bindings.Add("*:80:local.ccnet", "http");
iis.CommitChanges();
}
}
/// <summary>
/// Configures the binding information for the specified site name.
/// </summary>
/// <param name="siteName">The name of the IIS site to configure.</param>
/// <param name="ipAddress">The IP address associated with this binding or null for all available.</param>
/// <param name="port">The port number, usually 443.</param>
/// <param name="hostname">The hostname associated with this binding or null for all available.</param>
/// <param name="certificateHash">The SHA-1 hash of the certificate.</param>
/// <param name="createBinding">True if a new binding should be created if it doesn't already exist.</param>
/// <returns>true if the binding was created/updated, false if not.</returns>
static public bool ConfigureBinding(BindingData bindingData, byte[] certificateHash, bool createBinding = true)
{
string bindingInformation = string.Format("{0}:{1}:{2}",
!string.IsNullOrWhiteSpace(bindingData.IPAddress) ? bindingData.IPAddress : "*",
bindingData.Port,
bindingData.Domain ?? string.Empty);
//
// This chunk of code will add a new HTTPS binding linked to the certificate.
//
var server = new ServerManager();
var site = server.Sites.Where(s => s.Name == bindingData.Site).FirstOrDefault();
if (site == null)
{
return(false);
}
var binding = site.Bindings.AsQueryable().Where(b => b.BindingInformation == bindingInformation).FirstOrDefault();
if (binding == null)
{
if (!createBinding)
{
return(false);
}
binding = site.Bindings.Add(bindingInformation, certificateHash, Enum.GetName(typeof(StoreName), StoreName.My));
}
else
{
binding.CertificateHash = certificateHash;
binding.CertificateStoreName = Enum.GetName(typeof(StoreName), StoreName.My);
}
if (!string.IsNullOrWhiteSpace(binding.Host) && GetIISVersion().Major >= 8)
{
binding.SetAttributeValue("sslFlags", 1);
}
server.CommitChanges();
return(true);
}
/// <summary>
/// 更改物理路径
/// </summary>
/// <returns></returns>
public static string ChangePhysicalPath(string name, string sitename, string path)
{
try
{
if (string.IsNullOrEmpty(sitename))
{
sitename = "/";
}
if (!sitename.StartsWith("/"))
{
sitename = "/" + sitename;
}
if (IsDefaultWebSite(name))
{
name = "Default Web Site";
}
ServerManager oMan = new ServerManager();
var siteList = oMan.Sites.ToList();
var site = siteList.Where(r => r.Name.ToLower().Equals(name.ToLower())).ToList();
if (site.Count == 0)
{
return("site can not found:" + name);
}
var target = site[0];
var applicationRoot = target.Applications.FirstOrDefault(r => r.Path.ToLower().Equals(sitename.ToLower()));
if (applicationRoot == null)
{
return($"can not found {sitename} in {name}");
}
applicationRoot.VirtualDirectories[0].PhysicalPath = path;
oMan.CommitChanges();
return(string.Empty);
}
catch (Exception e)
{
return(e.Message);
}
}
private static Site CreateSite(string siteName, string framework, string path, int port, ProcessModelIdentityType identityType)
{
var serverManager = new ServerManager();
if (serverManager.ApplicationPools.Any(ap => ap.Name == siteName))
{
Debug("Removing existing AppPool {0}", siteName);
serverManager.ApplicationPools.Remove(serverManager.ApplicationPools.Single(ap => ap.Name == siteName));
}
Debug("Creating new AppPool {0}, Framework={1}, IdentityType={2}", siteName, framework, identityType);
var applicationPool = serverManager.ApplicationPools.Add(siteName);
applicationPool.ManagedRuntimeVersion = framework;
applicationPool.Enable32BitAppOnWin64 = true;
applicationPool.ProcessModel.IdentityType = identityType;
applicationPool.ProcessModel.IdleTimeout = new TimeSpan(7, 0, 0);
/** Try to preserve the site so any external settings (such as log formats etc) are preserved */
Site site;
if (serverManager.Sites.Any(si => si.Name == siteName))
{
Debug("Found existing site {0}, updating port={1} and path={2}", siteName, port, path);
site = serverManager.Sites.Single(si => si.Name == siteName);
site.Bindings[0].BindingInformation = String.Format("*:{0}:*", port);
site.Applications[0].VirtualDirectories["/"].PhysicalPath = path;
}
else
{
Debug("Creating new Site {0}, Path={1}, Port={2}", siteName, path, port);
site = serverManager.Sites.Add(siteName, path, port);
}
site.ServerAutoStart = true;
site.Applications[0].ApplicationPoolName = siteName;
serverManager.CommitChanges();
System.Threading.Thread.Sleep(500);
Debug("Starting site");
site.Start();
return(site);
}
public bool CreateInstance()
{
//Modifies the ApplicationHost.Config for IIS
if (manager.Sites.Where(r => r.Name == App.ApplicationName).ToList().Count > 0)
{
Console.ForegroundColor = ConsoleColor.Red;
Console.WriteLine($"There already exists an application with the name {App.ApplicationName}...");
Console.ResetColor();
return(false);
}
try
{
//Adds the website to IIS
Site webSite = manager.Sites.Add(App.ApplicationName, App.Path, App.Port);
webSite.ServerAutoStart = true;
manager.ApplicationPools.Add(App.ApplicationPool);
manager.Sites[App.ApplicationName].Applications.First().ApplicationPoolName = App.ApplicationPool;
ApplicationPool pool = manager.ApplicationPools[App.ApplicationPool];
pool.ManagedRuntimeVersion = App.RuntimeVersion;
if (App.PipelineMode.ToLower() == "classic")
{
pool.ManagedPipelineMode = ManagedPipelineMode.Classic;
}
else
{
pool.ManagedPipelineMode = ManagedPipelineMode.Integrated;
}
if (App.VirtualDirectories.Count > 0)
{
AddVirtualDirectories();
}
AssignPrivileges();
manager.CommitChanges();
}
catch (Exception e)
{
ErrorHandler.WriteError(e);
return(false);
}
return(true);
}
public static bool AddHttpsBinding(X509Certificate2 cert, string port)
{
using (var mgr = new ServerManager())
{
var site = mgr.Sites[IISHelper.DefaultWebSiteName];
foreach (var each in site.Bindings)
{
if (each.BindingInformation == "*:" + port + ":")
{
return(true);
}
}
site.Bindings.Add("*:" + port + ":", cert.GetCertHash(), "MY");
mgr.CommitChanges();
}
return(false);
}
