/// <summary>
/// Internal task execution code.
/// </summary>
/// <param name="environment">The script execution environment.</param>
protected override void DoExecute(IScriptExecutionEnvironment environment)
{
// first check if the queue already exists
if (MessageQueue.Exists(messageQueuePath))
{
if (mode == CreateMessageQueueMode.DoNothingIfExists)
{
environment.LogMessage("Message queue '{0}' already exists, doing nothing.", messageQueuePath);
return;
}
if (mode == CreateMessageQueueMode.FailIfAlreadyExists)
{
throw new RunnerFailedException(
String.Format(
System.Globalization.CultureInfo.InvariantCulture,
"Message queue '{0}' already exists.",
messageQueuePath));
}
// otherwise delete the queue
environment.LogMessage("Message queue '{0}' already exists, it will be deleted.", messageQueuePath);
MessageQueue.Delete(messageQueuePath);
}
using (MessageQueue queue = MessageQueue.Create(messageQueuePath, isTransactional))
{
if (userName != null)
{
queue.SetPermissions(userName, accessRights);
}
}
}
protected override void DoExecute(IScriptExecutionEnvironment environment)
{
using (ServerManager serverManager = new ServerManager())
{
ApplicationPoolCollection applicationPoolCollection = serverManager.ApplicationPools;
ApplicationPool appPoolToWorkOn = null;
bool updatedExisting = false;
foreach (ApplicationPool applicationPool in applicationPoolCollection)
{
if (applicationPool.Name == applicationPoolName)
{
if (mode == CreateApplicationPoolMode.DoNothingIfExists)
{
environment.LogMessage(
String.Format(
System.Globalization.CultureInfo.InvariantCulture,
"Application pool '{0}' already exists, doing nothing.",
applicationPoolName));
}
else if (mode == CreateApplicationPoolMode.FailIfAlreadyExists)
{
throw new RunnerFailedException(
String.Format(
System.Globalization.CultureInfo.InvariantCulture,
"Application '{0}' already exists.",
applicationPoolName));
}
// otherwise we should update the existing application pool
appPoolToWorkOn = applicationPool;
updatedExisting = true;
break;
}
}
if (appPoolToWorkOn == null)
{
appPoolToWorkOn = serverManager.ApplicationPools.Add(applicationPoolName);
}
appPoolToWorkOn.AutoStart = false;
appPoolToWorkOn.Enable32BitAppOnWin64 = true;
appPoolToWorkOn.ManagedPipelineMode =
ClassicManagedPipelineMode ? ManagedPipelineMode.Classic : ManagedPipelineMode.Integrated;
//serverManager.ApplicationPools.Add(appPoolToWorkOn);
serverManager.CommitChanges();
environment.LogMessage(
String.Format(
System.Globalization.CultureInfo.InvariantCulture,
"Application pool '{0}' {1}.",
applicationPoolName,
updatedExisting ? "updated" : "created"));
}
}
protected override void DoExecute(IScriptExecutionEnvironment environment)
{
using (ServerManager serverManager = new ServerManager())
{
ApplicationPoolCollection applicationPoolCollection = serverManager.ApplicationPools;
foreach (ApplicationPool applicationPool in applicationPoolCollection)
{
if (applicationPool.Name == ApplicationPoolName)
{
switch (action)
{
case ControlApplicationPoolAction.Start:
RunWithRetries(x => applicationPool.Start(), 3);
break;
case ControlApplicationPoolAction.Stop:
RunWithRetries(x => applicationPool.Stop(), 3);
break;
case ControlApplicationPoolAction.Recycle:
RunWithRetries(x => applicationPool.Recycle(), 3);
break;
default:
throw new NotSupportedException();
}
serverManager.CommitChanges();
environment.LogMessage(
String.Format(
System.Globalization.CultureInfo.InvariantCulture,
"Application pool '{0}' has been deleted.",
ApplicationPoolName));
return;
}
}
string message = String.Format(
System.Globalization.CultureInfo.InvariantCulture,
"Application pool '{0}' does not exist.",
applicationPoolName);
if (failIfNotExist)
{
throw new RunnerFailedException(message);
}
environment.LogMessage(message);
}
}
protected override void DoExecute(IScriptExecutionEnvironment environment)
{
using (DirectoryEntry computerDirectoryEntry = new DirectoryEntry("WinNT://" + Environment.MachineName + ",computer"))
{
using (DirectoryEntry userEntry = computerDirectoryEntry.Children.Find(userName, "user"))
{
using (DirectoryEntry grp = computerDirectoryEntry.Children.Find(group, "group"))
{
try
{
grp.Invoke("Add", new object[] { userEntry.Path.ToString() });
}
catch (TargetInvocationException ex)
{
if (ex.InnerException is COMException)
{
if ((ex.InnerException as COMException).ErrorCode == -2147023518)
{
// user is already member of the group, nothing to do
environment.LogMessage(
"User '{0}' is already member of the group '{1}', nothing to do.",
userName,
group);
return;
}
}
throw;
}
}
}
}
}
public static string GetIisVersion(IScriptExecutionEnvironment environment, bool failIfNotExist)
{
string major;
if (environment.IsConfigSettingDefined(IisMajorVersion))
{
major = environment.GetConfigSetting(IisMajorVersion);
}
else
{
ExecuteTask(environment);
major = environment.GetConfigSetting(IisMajorVersion);
}
if (string.IsNullOrEmpty(major))
{
const string Msg = "IIS not installed or IIS access denied!";
if (failIfNotExist)
{
throw new RunnerFailedException(Msg);
}
environment.LogMessage(Msg);
return("0.0");
}
string minor = environment.GetConfigSetting(IisMinorVersion);
return(major + "." + minor);
}
protected override void DoExecute(IScriptExecutionEnvironment environment)
{
using (DirectoryEntry computerDirectoryEntry = new DirectoryEntry("WinNT://" + Environment.MachineName + ",computer"))
{
try
{
using (DirectoryEntry userEntry = computerDirectoryEntry.Children.Find(userName, "user"))
{
computerDirectoryEntry.Children.Remove(userEntry);
}
}
catch (COMException ex)
{
if (ex.ErrorCode == -2147022675)
{
// if the user does not exist
environment.LogMessage(
"User '{0}' does not exist, nothing to do.",
userName);
return;
}
else
{
throw;
}
}
}
}
private void CopyStructureRecursive(
IScriptExecutionEnvironment environment,
string sourcePathRecursive,
string destinationPathRecursive,
Regex inclusionRegex,
Regex exclusionRegex)
{
if (exclusionRegex != null && exclusionRegex.IsMatch(sourcePathRecursive))
{
return;
}
DirectoryInfo info = new DirectoryInfo(sourcePathRecursive);
foreach (FileSystemInfo fileSystemInfo in info.GetFileSystemInfos())
{
if (fileSystemInfo is FileInfo)
{
if (inclusionRegex != null && false == inclusionRegex.IsMatch(fileSystemInfo.FullName))
{
continue;
}
if (exclusionRegex != null && exclusionRegex.IsMatch(fileSystemInfo.FullName))
{
continue;
}
FileInfo fileInfo = fileSystemInfo as FileInfo;
string filePath = Path.Combine(destinationPathRecursive, fileInfo.Name);
if (false == Directory.Exists(destinationPathRecursive))
{
Directory.CreateDirectory(destinationPathRecursive);
}
fileInfo.CopyTo(filePath, overwriteExisting);
environment.LogMessage(
"Copied file '{0}' to '{1}'",
fileSystemInfo.FullName,
filePath);
copiedFilesList.Add(filePath);
}
else
{
DirectoryInfo dirInfo = fileSystemInfo as DirectoryInfo;
string subdirectoryPath = Path.Combine(
destinationPathRecursive,
dirInfo.Name);
CopyStructureRecursive(
environment,
dirInfo.FullName,
subdirectoryPath,
inclusionRegex,
exclusionRegex);
}
}
}
protected override void DoExecute(IScriptExecutionEnvironment environment)
{
Process[] processByName = Process.GetProcessesByName(processName);
foreach (Process process in processByName)
{
environment.LogMessage("Killing process '{0}'", process.ProcessName);
process.Kill();
}
}
protected override void DoExecute(IScriptExecutionEnvironment environment)
{
try
{
using (ServiceController serviceController = new ServiceController(serviceName))
{
// this should throw an exception if the service does not exist
System.Runtime.InteropServices.SafeHandle serviceHandle = serviceController.ServiceHandle;
environment.SetConfigSetting(configurationSetting, "true");
environment.LogMessage("Windows service '{0}' exists.", serviceName);
}
}
catch (InvalidOperationException)
{
environment.SetConfigSetting(configurationSetting, "false");
environment.LogMessage(
"Windows service '{0}' does not exist.",
serviceName);
}
}
protected override void DoExecute(IScriptExecutionEnvironment environment)
{
using (ServerManager serverManager = new ServerManager())
{
Site site = serverManager.Sites["Default Web Site"];
string vdirPath = "/" + ApplicationName;
Application ourApplication = null;
foreach (Application application in site.Applications)
{
if (application.Path == vdirPath)
{
if (mode == CreateWebApplicationMode.DoNothingIfExists)
{
environment.LogMessage(
"Web application '{0}' already exists, doing nothing.",
applicationName);
return;
}
if (mode == CreateWebApplicationMode.FailIfAlreadyExists)
{
throw new RunnerFailedException(
String.Format(
System.Globalization.CultureInfo.InvariantCulture,
"Web application '{0}' already exists.",
applicationName));
}
// otherwise we should update the existing virtual directory
ourApplication = application;
break;
}
}
if (ourApplication == null)
{
ourApplication = site.Applications.Add(vdirPath, LocalPath);
}
ourApplication.ApplicationPoolName = applicationPoolName;
throw new NotImplementedException();
//Microsoft.Web.Administration.Configuration configuration = ourApplication.GetWebConfiguration();
////ConfigurationSection webServerSection = configuration.GetSection("system.webServer");
////ConfigurationElement defaultDocEl = webServerSection.GetChildElement("defaultDocument");
//ConfigurationElement defaultDocEl = configuration.GetSection("system.webServer/defaultDocument");
//defaultDocEl["enabled"] = EnableDefaultDoc.ToString(CultureInfo.InvariantCulture);
//serverManager.CommitChanges();
}
}
protected override void DoExecute(IScriptExecutionEnvironment environment)
{
ServerManager serverManager = new ServerManager();
ApplicationPoolCollection applicationPoolCollection = serverManager.ApplicationPools;
foreach (ApplicationPool applicationPool in applicationPoolCollection)
{
if (applicationPool.Name == ApplicationPoolName)
{
applicationPoolCollection.Remove(applicationPool);
serverManager.CommitChanges();
environment.LogMessage(
String.Format(
System.Globalization.CultureInfo.InvariantCulture,
"Application pool '{0}' has been deleted.",
ApplicationPoolName));
return;
}
}
if (FailIfNotExist)
{
throw new RunnerFailedException(
String.Format(
CultureInfo.InvariantCulture,
"Application '{0}' does not exist.",
ApplicationPoolName));
}
environment.LogMessage(
String.Format(
CultureInfo.InvariantCulture,
"Application pool '{0}' does not exist, doing nothing.",
ApplicationPoolName));
}
protected override void DoExecute(IScriptExecutionEnvironment environment)
{
// ReSharper disable InconsistentNaming
const int GenericWrite = 0x40000000;
// ReSharper restore InconsistentNaming
IntPtr scHndl = IntPtr.Zero;
IntPtr svcHndl = IntPtr.Zero;
try
{
scHndl = OpenSCManager(null, null, GenericWrite);
if (scHndl == IntPtr.Zero)
{
throw new RunnerFailedException("Service manager could not be opened!");
}
// ReSharper disable InconsistentNaming
const int Delete = 0x10000;
// ReSharper restore InconsistentNaming
svcHndl = OpenService(scHndl, ServiceName, Delete);
if (svcHndl == IntPtr.Zero)
{
if (FailIfNotExist)
{
throw new RunnerFailedException("Service {0} does not exist.", ServiceName);
}
environment.LogMessage("Service '{0}' does not exist, doing nothing.", ServiceName);
return;
}
int result = DeleteService(svcHndl);
if (result != 0)
{
throw new RunnerFailedException("Uninstall windows service failed with error code:{0}", result);
}
}
finally
{
if (svcHndl != IntPtr.Zero)
{
CloseServiceHandle(svcHndl);
}
if (scHndl != IntPtr.Zero)
{
CloseServiceHandle(scHndl);
}
}
}
protected override void DoExecute(IScriptExecutionEnvironment environment)
{
SearchOption searchOption = SearchOption.TopDirectoryOnly;
if (recursive)
{
searchOption = SearchOption.AllDirectories;
}
foreach (string file in Directory.GetFiles(directoryPath, filePattern, searchOption))
{
File.Delete(file);
environment.LogMessage("Deleted file '{0}'", file);
}
}
/// <summary>
/// Internal task execution code.
/// </summary>
/// <param name="environment">The script execution environment.</param>
protected override void DoExecute(IScriptExecutionEnvironment environment)
{
// log important environment information
environment.LogMessage("Machine name: {0}", Environment.MachineName);
environment.LogMessage("OS Version: {0}", Environment.OSVersion);
environment.LogMessage("User name: {0}", Environment.UserName);
environment.LogMessage("User domain name: {0}", Environment.UserDomainName);
environment.LogMessage("CLR version: {0}", Environment.Version);
environment.LogMessage("Current directory: {0}", Environment.CurrentDirectory);
}
protected override void DoExecute(IScriptExecutionEnvironment environment)
{
const string AppPoolsRootName = @"IIS://localhost/W3SVC/AppPools";
using (DirectoryEntry parent = new DirectoryEntry(AppPoolsRootName))
{
DirectoryEntry applicationPoolEntry = null;
try
{
try
{
applicationPoolEntry = parent.Children.Find(ApplicationPoolName, "IIsApplicationPool");
applicationPoolEntry.DeleteTree();
applicationPoolEntry.CommitChanges();
}
catch (DirectoryNotFoundException)
{
// application pool already exists
if (FailIfNotExist)
{
throw new RunnerFailedException(
String.Format(
CultureInfo.InvariantCulture,
"Application '{0}' does not exist.",
ApplicationPoolName));
}
environment.LogMessage(
String.Format(
CultureInfo.InvariantCulture,
"Application pool '{0}' does not exist, doing nothing.",
ApplicationPoolName));
return;
}
}
finally
{
if (applicationPoolEntry != null)
{
applicationPoolEntry.Dispose();
}
}
parent.CommitChanges();
}
}
protected override void DoExecute(IScriptExecutionEnvironment environment)
{
const string AppPoolsRootName = @"IIS://localhost/W3SVC/AppPools";
using (DirectoryEntry parent = new DirectoryEntry(AppPoolsRootName))
{
DirectoryEntry applicationPoolEntry = null;
try
{
// first check if the user already exists
try
{
applicationPoolEntry = parent.Children.Find(applicationPoolName, "IIsApplicationPool");
applicationPoolEntry.Invoke(action.ToString());
}
catch (DirectoryNotFoundException)
{
string message = String.Format(
System.Globalization.CultureInfo.InvariantCulture,
"Application pool '{0}' does not exist.",
applicationPoolName);
if (failIfNotExist)
{
throw new RunnerFailedException(message);
}
else
{
environment.LogMessage(message);
}
}
}
finally
{
if (applicationPoolEntry != null)
{
applicationPoolEntry.Dispose();
}
}
}
}
/// <summary>
/// Internal task execution code.
/// </summary>
/// <param name="environment">The script execution environment.</param>
protected override void DoExecute(IScriptExecutionEnvironment environment)
{
XmlDocument xmlDoc = new XmlDocument();
if (configurationString != null)
{
xmlDoc.LoadXml(configurationString);
}
else if (configurationFileName != null)
{
xmlDoc.Load(configurationFileName);
}
else
{
throw new RunnerFailedException("Either the configuration string or the configuration fileName has to be set.");
}
XmlNode configurationRootNode = xmlDoc.SelectSingleNode("Configuration");
XmlNodeList nodes = xmlDoc.SelectNodes("Configuration//*");
foreach (XmlNode node in nodes)
{
if (node.InnerText == node.InnerXml)
{
StringBuilder settingName = new StringBuilder();
string terminator = null;
for (XmlNode parentNode = node; parentNode != null && parentNode != configurationRootNode; parentNode = parentNode.ParentNode)
{
settingName.Insert(0, terminator);
settingName.Insert(0, parentNode.Name);
terminator = "/";
}
environment.LogMessage(
"Configuration setting '{0}' has value '{1}'",
settingName,
node.InnerText);
environment.SetConfigSetting(settingName.ToString(), node.InnerText);
}
}
}
//internal static int GetMinorVersion(string version)
//{
// if (string.IsNullOrEmpty(version))
// return 0;
// string[] split = version.Split('.');
// return split.Length != 2 ? 0 : Convert.ToInt32(split[1], CultureInfo.InvariantCulture);
//}
protected override void DoExecute(IScriptExecutionEnvironment environment)
{
GetRegistryValueTask innerTask = new GetRegistryValueTask(
Microsoft.Win32.Registry.LocalMachine,
@"SOFTWARE\Microsoft\InetStp",
"MajorVersion",
IisMajorVersion);
innerTask.Execute(environment);
innerTask = new GetRegistryValueTask(
Microsoft.Win32.Registry.LocalMachine,
@"SOFTWARE\Microsoft\InetStp",
"MinorVersion",
IisMinorVersion);
innerTask.Execute(environment);
environment.LogMessage(
"Local IIS has version {0}.{1}",
environment.GetConfigSetting("IIS/MajorVersion"),
environment.GetConfigSetting("IIS/MinorVersion"));
}
protected override void DoExecute(IScriptExecutionEnvironment environment)
{
using (FileStream zipFileStream = new FileStream(
zipFileName,
FileMode.Create,
FileAccess.ReadWrite,
FileShare.None))
{
using (ZipOutputStream zipStream = new ZipOutputStream(zipFileStream))
{
if (compressionLevel.HasValue)
{
zipStream.SetLevel(compressionLevel.Value);
}
buffer = new byte[1024 * 1024];
foreach (string fileName in filesToZip)
{
int skipChar = 0;
if (false == String.IsNullOrEmpty(baseDir) &&
(baseDir[baseDir.Length - 1] == '\\' ||
baseDir[baseDir.Length - 1] == '/'))
{
skipChar++;
}
// cut off the leading part of the path (up to the root directory of the package)
string basedFileName = fileName.Substring(baseDir.Length + skipChar);
basedFileName = ZipEntry.CleanName(basedFileName);
environment.LogMessage("Zipping file '{0}'", basedFileName);
AddFileToZip(fileName, basedFileName, zipStream);
}
}
}
}
/// <summary>
/// Internal task execution code.
/// </summary>
/// <param name="environment">The script execution environment.</param>
protected override void DoExecute(IScriptExecutionEnvironment environment)
{
// first check if the queue already exists
if (false == MessageQueue.Exists(MessageQueuePath))
{
if (FailIfNotExist)
{
throw new RunnerFailedException(
String.Format(
CultureInfo.InvariantCulture,
"Message queue does not '{0}' exist.",
MessageQueuePath));
}
environment.LogMessage(
String.Format(
CultureInfo.InvariantCulture,
"Message queue does not '{0}' exist, doing nothing.",
MessageQueuePath));
return;
}
MessageQueue.Delete(MessageQueuePath);
}
protected override void DoExecute(IScriptExecutionEnvironment environment)
{
environment.LogMessage(message);
}
protected override void DoExecute(IScriptExecutionEnvironment environment)
{
string version = GetLocalIisVersionTask.GetIisVersion(environment, false);
int major = GetLocalIisVersionTask.GetMajorVersion(version);
if (major < 6 || major == 0)
{
environment.LogMessage("IIS does not support application pools.");
return;
}
const string AppPoolsRootName = @"IIS://localhost/W3SVC/AppPools";
using (DirectoryEntry parent = new DirectoryEntry(AppPoolsRootName))
{
DirectoryEntry applicationPoolEntry = null;
try
{
// first check if the user already exists
try
{
applicationPoolEntry = parent.Children.Find(applicationPoolName, "IIsApplicationPool");
// application pool already exists
if (mode == CreateApplicationPoolMode.DoNothingIfExists)
{
environment.LogMessage(
String.Format(
System.Globalization.CultureInfo.InvariantCulture,
"Application pool '{0}' already exists, doing nothing.",
applicationPoolName));
return;
}
else if (mode == CreateApplicationPoolMode.FailIfAlreadyExists)
{
throw new RunnerFailedException(
String.Format(
System.Globalization.CultureInfo.InvariantCulture,
"Application '{0}' already exists.",
applicationPoolName));
}
// otherwise we should update the existing application pool
}
catch (DirectoryNotFoundException)
{
// application pool does not exist, go on and add it
applicationPoolEntry = parent.Children.Add(applicationPoolName, "IIsApplicationPool");
}
if (major > 6)
{
applicationPoolEntry.InvokeSet(
"ManagedPipelineMode",
new object[] { classicManagedPipelineMode ? 1 : 0 });
}
applicationPoolEntry.CommitChanges();
}
finally
{
if (applicationPoolEntry != null)
{
applicationPoolEntry.Dispose();
}
}
parent.CommitChanges();
}
}
protected override void DoExecute(IScriptExecutionEnvironment environment)
{
string configSettingName = String.Format(
System.Globalization.CultureInfo.InvariantCulture,
"ServicesExist/{0}",
serviceName);
CheckIfServiceExistsTask.Execute(environment, serviceName, configSettingName);
if (bool.Parse(environment.GetConfigSetting(configSettingName)) == false)
{
if (FailIfNotExist)
{
throw new RunnerFailedException("Service {0} does not exist.", serviceName);
}
environment.LogMessage("Service '{0}' does not exist, doing nothing.", serviceName);
return;
}
using (ServiceController serviceController = new ServiceController(serviceName, MachineName))
{
ServiceControllerStatus status = ServiceControllerStatus.Running;
switch (mode)
{
case ControlWindowsServiceMode.Start:
status = ServiceControllerStatus.Running;
break;
case ControlWindowsServiceMode.Stop:
status = ServiceControllerStatus.Stopped;
break;
}
switch (status)
{
case ServiceControllerStatus.Running:
if (serviceController.Status != ServiceControllerStatus.Running)
{
serviceController.Start();
}
break;
case ServiceControllerStatus.Stopped:
if (serviceController.Status != ServiceControllerStatus.Stopped)
{
serviceController.Stop();
}
break;
}
int timeSoFar = 0;
for (serviceController.Refresh(); serviceController.Status != status; serviceController.Refresh())
{
System.Threading.Thread.Sleep(500);
timeSoFar += 500;
if (timeSoFar >= timeout.TotalMilliseconds)
{
throw new RunnerFailedException(
String.Format(
System.Globalization.CultureInfo.InvariantCulture,
"Timeout waiting for '{0}' service to reach status {1}.",
serviceName,
status));
}
}
}
}
/// <summary>
/// Internal task execution code.
/// </summary>
/// <param name="environment">The script execution environment.</param>
protected override void DoExecute(IScriptExecutionEnvironment environment)
{
string configSettingName = String.Format(
System.Globalization.CultureInfo.InvariantCulture,
"ServicesExist/{0}",
serviceName);
CheckIfServiceExistsTask checkIfServiceExistsTask = new CheckIfServiceExistsTask(serviceName, configSettingName);
checkIfServiceExistsTask.Execute(environment);
if (bool.Parse(environment.GetConfigSetting(configSettingName)) == true)
{
switch (mode)
{
case InstallWindowsServiceMode.DoNothingIfExists:
return;
case InstallWindowsServiceMode.FailIfAlreadyInstalled:
throw new RunnerFailedException(
String.Format(
System.Globalization.CultureInfo.InvariantCulture,
"The Windows service '{0}' already exists.",
serviceName));
case InstallWindowsServiceMode.ReinstallIfExists:
UninstallWindowsServiceTask uninstallWindowsServiceTask = new UninstallWindowsServiceTask(executablePath);
uninstallWindowsServiceTask.Execute(environment);
// wait for a while to ensure the service is really deleted
SleepTask.Execute(environment, serviceUninstallationWaitTime);
break;
default:
throw new NotSupportedException();
}
}
IDictionary savedState = new Hashtable();
string[] commandLine = new string[0];
using (System.Configuration.Install.AssemblyInstaller assemblyInstaller
= new System.Configuration.Install.AssemblyInstaller(executablePath, commandLine))
{
try
{
assemblyInstaller.UseNewContext = true;
assemblyInstaller.Install(savedState);
assemblyInstaller.Commit(savedState);
}
catch (System.ComponentModel.Win32Exception ex)
{
// 1073
environment.LogMessage(
"ex.ErrorCode = {0}",
ex.NativeErrorCode);
throw;
}
}
}
protected override void DoExecute(IScriptExecutionEnvironment environment)
{
using (DirectoryEntry rootDirectoryEntry = new DirectoryEntry("WinNT://" + Environment.MachineName + ",computer"))
{
DirectoryEntry userEntry = null;
try
{
// first check if the user already exists
try
{
userEntry = rootDirectoryEntry.Children.Find(userName, "user");
// user already exists
if (mode == CreateUserAccountMode.DoNothingIfExists)
{
environment.LogMessage(
"User '{0}' already exists, doing nothing.",
userName);
return;
}
else if (mode == CreateUserAccountMode.FailIfAlreadyExists)
{
throw new RunnerFailedException(
String.Format(
System.Globalization.CultureInfo.InvariantCulture,
"User '{0}' already exists.",
userName));
}
// otherwise we should update the existing user
}
catch (COMException ex)
{
if (ex.ErrorCode == -2147022675)
{
// user does not exist, go on and add it
userEntry = rootDirectoryEntry.Children.Add(userName, "user");
}
else
{
throw;
}
}
const int ADS_UF_DONT_EXPIRE_PASSWD = 0x00010000;
const int ADS_UF_PASSWD_CANT_CHANGE = 0x00000040;
userEntry.Invoke("SetPassword", new object[] { password });
userEntry.Invoke("Put", new object[] { "Description", userDescription });
userEntry.Invoke("Put", new object[] { "userFlags", ADS_UF_DONT_EXPIRE_PASSWD | ADS_UF_PASSWD_CANT_CHANGE });
userEntry.CommitChanges();
}
finally
{
if (userEntry != null)
{
userEntry.Dispose();
}
}
}
}
protected override void DoExecute(IScriptExecutionEnvironment environment)
{
string parentName = parentVirtualDirectoryName;
using (DirectoryEntry parent = new DirectoryEntry(parentName))
{
DirectoryEntry virtualDirEntry = null;
try
{
// first check if the virtual directory already exists
try
{
virtualDirEntry = parent.Children.Find(applicationName, "IIsWebVirtualDir");
// virtual directory already exists
if (mode == CreateWebApplicationMode.DoNothingIfExists)
{
environment.LogMessage(
"Web application '{0}' already exists, doing nothing.",
applicationName);
return;
}
else if (mode == CreateWebApplicationMode.FailIfAlreadyExists)
{
throw new RunnerFailedException(
String.Format(
System.Globalization.CultureInfo.InvariantCulture,
"Web application '{0}' already exists.",
applicationName));
}
// otherwise we should update the existing virtual directory
}
catch (DirectoryNotFoundException)
{
// virtual directory does not exist, go on and add it
virtualDirEntry = parent.Children.Add(applicationName, "IIsWebVirtualDir");
}
virtualDirEntry.Properties["Path"][0] = localPath;
virtualDirEntry.CommitChanges();
if (!string.IsNullOrEmpty(applicationPoolName))
{
virtualDirEntry.Invoke("AppCreate3", new object[] { 2, applicationPoolName, false });
}
virtualDirEntry.Properties["AppFriendlyName"][0] = appFriendlyName ?? applicationName;
int authFlags = 0;
if (allowAnonymous)
{
authFlags |= 1;
}
if (allowAuthNtlm)
{
authFlags |= 4;
}
virtualDirEntry.Properties["AuthFlags"][0] = authFlags;
if (anonymousUserName != null)
{
virtualDirEntry.Properties["AnonymousUserName"][0] = anonymousUserName;
}
if (anonymousUserPass != null)
{
virtualDirEntry.Properties["AnonymousUserPass"][0] = anonymousUserPass;
}
if (defaultDoc != null)
{
virtualDirEntry.Properties["DefaultDoc"][0] = defaultDoc;
}
virtualDirEntry.Properties["EnableDefaultDoc"][0] = enableDefaultDoc;
virtualDirEntry.Properties["AccessScript"][0] = true;
virtualDirEntry.Properties["AccessExecute"][0] = true;
virtualDirEntry.Properties["AspEnableParentPaths"][0] = aspEnableParentPaths;
virtualDirEntry.CommitChanges();
}
finally
{
if (virtualDirEntry != null)
{
virtualDirEntry.Dispose();
}
}
parent.CommitChanges();
}
}
/// <summary>
/// Method defining the actual work for a task.
/// </summary>
/// <param name="environment">The script execution environment.</param>
protected override void DoExecute(IScriptExecutionEnvironment environment)
{
XmlDocument xmldoc = new XmlDocument();
xmldoc.PreserveWhitespace = true;
xmldoc.Load(fileName);
// perform all deletes
foreach (string xpath in xpathDeletes)
{
foreach (XmlNode node in xmldoc.SelectNodes(xpath))
{
string fullNodePath = ConstructXmlNodeFullName(node);
environment.LogMessage("Node '{0}' will be removed.", fullNodePath);
if (node.NodeType == XmlNodeType.Element)
{
node.ParentNode.RemoveChild(node);
}
else if (node.NodeType == XmlNodeType.Attribute)
{
XmlAttribute attribute = (XmlAttribute)node;
attribute.OwnerElement.RemoveAttributeNode(attribute);
}
else
{
throw new ArgumentException(
String.Format(
System.Globalization.CultureInfo.InvariantCulture,
"Node '{0}' is of incorrect type '{1}', it should be an element or attribute.",
fullNodePath,
node.NodeType));
}
}
}
// perform all updates
foreach (string xpath in xpathUpdates.Keys)
{
foreach (XmlNode node in xmldoc.SelectNodes(xpath))
{
string fullNodePath = ConstructXmlNodeFullName(node);
environment.LogMessage(
"Node '{0}' will have value '{1}'",
fullNodePath,
xpathUpdates[xpath]);
if (node.NodeType == XmlNodeType.Attribute)
{
node.Value = xpathUpdates[xpath];
}
else if (node.NodeType == XmlNodeType.Element)
{
node.InnerText = xpathUpdates[xpath];
}
else
{
throw new ArgumentException(
String.Format(
System.Globalization.CultureInfo.InvariantCulture,
"Node '{0}' is of incorrect type '{1}', it should be an element or attribute.",
fullNodePath,
node.NodeType));
}
}
}
// perform all additions
foreach (UpdateXmlFileTaskAddition addition in xpathAdditions)
{
XmlNode rootNode = xmldoc.SelectSingleNode(addition.RootXPath);
if (rootNode == null)
{
throw new ArgumentException(
String.Format(
System.Globalization.CultureInfo.InvariantCulture,
"Path '{0}' does not exist.",
addition.RootXPath));
}
if (rootNode.NodeType != XmlNodeType.Element)
{
throw new ArgumentException(
String.Format(
System.Globalization.CultureInfo.InvariantCulture,
"Node '{0}' is of incorrect type '{1}', it should be an element.",
addition.RootXPath,
rootNode.NodeType));
}
XmlNode childNode = null;
if (addition.ChildNodeName.StartsWith("@", StringComparison.OrdinalIgnoreCase))
{
childNode = xmldoc.CreateAttribute(addition.ChildNodeName.Substring(1));
childNode.Value = addition.Value;
rootNode.Attributes.Append((XmlAttribute)childNode);
}
else
{
childNode = xmldoc.CreateElement(addition.ChildNodeName);
if (addition.Value != null)
{
childNode.InnerText = addition.Value;
}
if (addition.Attributes != null)
{
XmlElement element = (XmlElement)childNode;
foreach (string attribute in addition.Attributes.Keys)
{
element.SetAttribute(attribute, addition.Attributes[attribute]);
}
}
rootNode.AppendChild(childNode);
}
string fullNodePath = ConstructXmlNodeFullName(rootNode);
environment.LogMessage(
"Node '{0}' will have a new child '{1}' with value '{2}'",
fullNodePath,
childNode.Name,
addition.Value);
}
xmldoc.Save(fileName);
}