Note
Access to this page requires authorization. You can try signing in or changing directories.
Access to this page requires authorization. You can try changing directories.
Creation of Application Pool on IIS
Note: Add Microsoft.Web.Management.dll as reference(This can be found Windows/system32/inetsrv folder)
1) Create a class structure to take input parameters for Creation of Application Pool
/// <summary>
/// This class just provides parameters for application pool creation.
/// </summary>
public class ApplicationPoolParams
{
public ApplicationPoolParams(string appPoolName,string metabasePath, uint queueLength,string managedRuntimeVersion,ManagedPipelineMode managedPipeLineMode,
ProcessModelAppPool processModel, RecyclingAppPool recycleAppPool,CpuAppPool cpuAppPool)
{
Name = appPoolName;
MetabasePath = metabasePath;
QueueLength = queueLength;
ManagedRuntimeVersion = managedRuntimeVersion;
PipelineMode = managedPipeLineMode;
ProcessModelData = processModel;
RecycleAppPoolData = recycleAppPool;
CpuData = cpuAppPool;
}
public string Name { get; set; }
public string MetabasePath { get; set; }
public uint QueueLength { get; set; }
public string ManagedRuntimeVersion { get; set; }
public ManagedPipelineMode PipelineMode { get; set; }
public ProcessModelAppPool ProcessModelData { get; set;}
public RecyclingAppPool RecycleAppPoolData { get; set; }
public CpuAppPool CpuData { get; set; }
}
public class ProcessModelAppPool
{
public ProcessModelAppPool(TimeSpan idleTimeOut,uint maxProcesses)
{
IdleTimeout = idleTimeOut;
MaxProcesses = maxProcesses;
}
public TimeSpan IdleTimeout { get; set; }
public uint MaxProcesses { get; set; }
}
public class RecyclingAppPool
{
public RecyclingAppPool(bool isOverlappingRotation,bool isRotationOnConfigChange, PeriodicRestartAppPool periodic)
{
DisallowOverlappingRotation = isOverlappingRotation;
DisallowRotationOnConfigChange = isRotationOnConfigChange;
PeriodicRestartData = periodic;
}
public bool DisallowOverlappingRotation { get; set; }
public bool DisallowRotationOnConfigChange { get; set; }
public PeriodicRestartAppPool PeriodicRestartData { get; set; }
}
public class PeriodicRestartAppPool
{
public PeriodicRestartAppPool(int privatememory,int memory,int requests,TimeSpan timespan)
{
PrivateMemory = privatememory;
Memory = memory;
Requests = requests;
Time = timespan;
}
public int PrivateMemory { get; set; }
public int Memory { get; set; }
public int Requests { get; set; }
public TimeSpan Time { get; set; }
}
public class CpuAppPool
{
public CpuAppPool(int limit,CpuActions action)
{
Limit = limit;
Action = action;
}
public int Limit { get; set; }
public CpuActions Action { get; set; }
}
public enum CpuActions
{
NoAction,
KillW3wp
}
public static class VersionName
{
public static string Version2 = "v2.0";
public static string Version4 = "v4.0";
public static string UnManaged = "No Managed Code";
}
2) Create Application Programmatically using the parameters set in the above class
/// <summary>
/// Function to create Application Pool.
/// </summary>
/// <param name="appPoolData">Class Object with Input application pool data</param>
public static void CreateAppPool(ApplicationPoolParams appPoolData)
{
Console.WriteLine("\nCreating application pool named {0}/{1}:", appPoolData.MetabasePath, appPoolData.Name);
try
{
if (appPoolData.MetabasePath.EndsWith("/W3SVC/AppPools"))
{
DirectoryEntry newpool;
DirectoryEntry apppools = new DirectoryEntry(appPoolData.MetabasePath);
using (var manager = new ServerManager())
{
ApplicationPool appPoolIIS = manager.ApplicationPools.FirstOrDefault<ApplicationPool>(pool => pool.Attributes["name"].Value.ToString().ToLower() == appPoolData.Name.ToLower());
if (appPoolIIS == null)
{
newpool = apppools.Children.Add(appPoolData.Name, "IIsApplicationPool");
newpool.CommitChanges();
manager.CommitChanges();
appPoolIIS = manager.ApplicationPools.FirstOrDefault<ApplicationPool>(pool => pool.Attributes["name"].Value.ToString().ToLower() == appPoolData.Name.ToLower());
if(appPoolData.QueueLength > 0)
appPoolIIS.SetAttributeValue("queueLength", appPoolData.QueueLength);
if(!string.IsNullOrEmpty(appPoolData.ManagedRuntimeVersion))
appPoolIIS.SetAttributeValue("managedRuntimeVersion", appPoolData.ManagedRuntimeVersion);
if (!string.IsNullOrEmpty(appPoolData.PipelineMode.ToString()))
appPoolIIS.SetAttributeValue("managedPipelineMode", appPoolData.PipelineMode);
if (appPoolData.ProcessModelData != null)
{
appPoolIIS.ProcessModel.SetAttributeValue("idleTimeout", appPoolData.ProcessModelData.IdleTimeout);
appPoolIIS.ProcessModel.SetAttributeValue("maxProcesses", appPoolData.ProcessModelData.MaxProcesses);
}
if (appPoolData.RecycleAppPoolData != null)
{
appPoolIIS.Recycling.SetAttributeValue("disallowOverlappingRotation", appPoolData.RecycleAppPoolData.DisallowOverlappingRotation);
appPoolIIS.Recycling.SetAttributeValue("disallowRotationOnConfigChange", appPoolData.RecycleAppPoolData.DisallowRotationOnConfigChange);
if (appPoolData.RecycleAppPoolData.PeriodicRestartData != null)
{
appPoolIIS.Recycling.PeriodicRestart.SetAttributeValue("memory", appPoolData.RecycleAppPoolData.PeriodicRestartData.Memory);
appPoolIIS.Recycling.PeriodicRestart.SetAttributeValue("privateMemory", appPoolData.RecycleAppPoolData.PeriodicRestartData.PrivateMemory);
appPoolIIS.Recycling.PeriodicRestart.SetAttributeValue("requests", appPoolData.RecycleAppPoolData.PeriodicRestartData.Requests);
appPoolIIS.Recycling.PeriodicRestart.SetAttributeValue("time", appPoolData.RecycleAppPoolData.PeriodicRestartData.Time);
}
}
if (appPoolData.CpuData != null)
{
appPoolIIS.Cpu.SetAttributeValue("limit", appPoolData.CpuData.Limit);
appPoolIIS.Cpu.SetAttributeValue("action", appPoolData.CpuData.Action.ToString());
}
manager.CommitChanges();
}
}
Console.WriteLine(" Done.");
}
else
Console.WriteLine(" Failed in CreateAppPool; application pools can only be created in the */W3SVC/AppPools node.");
}
catch (Exception ex)
{
Console.WriteLine("Failed in CreateAppPool with the following exception: \n{0}", ex.Message);
}
}
Creation of Virtual Directory on IIS
1) This function will take Website Url under which virtual directory/web application have to be created, Name of the virtual directory and physical path to which it must point to.
/// <summary>
/// Function to create web application if does not exists.
/// </summary>
/// <param name="websiteUrl">Root website url</param>
/// <param name="vDirName">Name of the web application</param>
/// <param name="physicalPath">Physical path to which the web application will point to</param>
public static void CreateVDir(string websiteUrl, string vDirName, string physicalPath)
{
Console.WriteLine("\nCreating application {0}/{1}, mapping the Root application to {2}:",
websiteUrl, vDirName, physicalPath);
try
{
DirectoryEntry site = new DirectoryEntry(websiteUrl);
string className = site.SchemaClassName.ToString();
if ((className.EndsWith("Server")) || (className.EndsWith("VirtualDir")))
{
DirectoryEntries vdirs = site.Children;
DirectoryEntry newVDir = vdirs.Add(vDirName, (className.Replace("Service", "VirtualDir")));
newVDir.Properties["Path"][0] = physicalPath;
newVDir.Properties["AccessScript"][0] = true;
newVDir.Properties["AppFriendlyName"][0] = vDirName;
newVDir.Properties["AppIsolated"][0] = "1";
newVDir.Properties["AppRoot"][0] = "/LM" + websiteUrl.Substring(websiteUrl.IndexOf("/", ("IIS://".Length)));
newVDir.CommitChanges();
Console.WriteLine(" Done.");
}
else
Console.WriteLine(" Failed. A virtual directory can only be created in a site or virtual directory node.");
}
catch (Exception ex)
{
Console.WriteLine("Failed in CreateVDir with the following exception: \n{0}", ex.Message);
}
}
Assigning Application Pool to virtual directory
1) This function will take web application/virtual Directory name and application pool name
/// <summary>
/// Function to assign application pool to web application created.
/// </summary>
/// <param name="webApplicationUrl">Web Application Url</param>
/// <param name="appPoolName">Application pool name this web application to be assigned to</param>
public static void AssignVDirToAppPool(string webApplicationUrl, string appPoolName)
{
Console.WriteLine("\nAssigning application {0} to the application pool named {1}:", webApplicationUrl, appPoolName);
try
{
DirectoryEntry vDir = new DirectoryEntry(webApplicationUrl);
string className = vDir.SchemaClassName.ToString();
object[] param = { 0, appPoolName, true };
vDir.Invoke("AppCreate3", param);
vDir.Properties["AppIsolated"][0] = "2";
Console.WriteLine(" Done.");
}
catch (Exception ex)
{
Console.WriteLine("Failed in AssignVDirToAppPool with the following exception: \n{0}", ex.Message);
}
}