Compartir a través de


Programmatic management of IIS

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);
 }
 }