public ExtensionConfiguration UpdateExtensionState(ExtensionConfigurationInput input)
{
var extConfig = new ExtensionConfiguration();
if (input.Roles == null || input.Roles.Count == 1 && input.Roles[0].RoleType == ExtensionRoleType.AllRoles)
{
extConfig.AllRoles = new List <ExtensionConfiguration.Extension>();
extConfig.AllRoles.Add(new ExtensionConfiguration.Extension
{
Id = input.Id,
State = input.State
});
}
else
{
extConfig.NamedRoles = new List <ExtensionConfiguration.NamedRole>();
foreach (var role in input.Roles)
{
var ext = new List <ExtensionConfiguration.Extension>();
ext.Add(new ExtensionConfiguration.Extension
{
Id = input.Id,
State = input.State
});
extConfig.NamedRoles.Add(new ExtensionConfiguration.NamedRole
{
RoleName = role.RoleName,
Extensions = ext
});
}
}
return(extConfig);
}
public void ExecuteCommand()
{
InitializeAntimalwareSettings();
ValidateParameters();
RemoveAntimalwareExtension();
RemoveExistingAntimalwareMonitoringConfig();
ExtensionConfigurationInput[] extConfigInputs = null;
if (AntimalwareExtensionConfigurationInput != null && AntimalwareMonitoringExtensionConfigurationInput != null)
{
extConfigInputs = new ExtensionConfigurationInput[2];
extConfigInputs[0] = AntimalwareMonitoringExtensionConfigurationInput;
extConfigInputs[1] = AntimalwareExtensionConfigurationInput;
}
else if (AntimalwareExtensionConfigurationInput != null)
{
extConfigInputs = new ExtensionConfigurationInput[1];
extConfigInputs[0] = AntimalwareExtensionConfigurationInput;
}
else if (AntimalwareMonitoringExtensionConfigurationInput != null)
{
extConfigInputs = new ExtensionConfigurationInput[1];
extConfigInputs[0] = AntimalwareMonitoringExtensionConfigurationInput;
}
// process any pending deployment changes
if (extConfigInputs != null)
{
ExtensionConfiguration newExtConfig = ExtensionManager.Add(Deployment, extConfigInputs, Slot);
ChangeDeployment(newExtConfig);
}
}
public void ExecuteCommand()
{
ValidateParameters();
ExtensionConfigurationInput context = new ExtensionConfigurationInput
{
Version = Version,
ProviderNameSpace = ProviderNamespace,
Type = ExtensionName,
CertificateThumbprint = CertificateThumbprint,
ThumbprintAlgorithm = ThumbprintAlgorithm,
X509Certificate = X509Certificate,
PublicConfiguration = PublicConfiguration,
PrivateConfiguration = PrivateConfiguration,
Roles = new ExtensionRoleList(Role != null && Role.Any() ? Role.Select(r => new ExtensionRole(r)) : Enumerable.Repeat(new ExtensionRole(), 1))
};
var secondSlotDeployment = GetDeployment(this.Slot == DeploymentSlotType.Production ? DeploymentSlotType.Staging : DeploymentSlotType.Production);
Microsoft.WindowsAzure.Management.Compute.Models.ExtensionConfiguration secondSlotExtensionConfiguration =
secondSlotDeployment != null ? secondSlotDeployment.ExtensionConfiguration : null;
var extConfig = ExtensionManager.InstallExtension(context, Slot, Deployment.ExtensionConfiguration, secondSlotExtensionConfiguration);
ChangeDeployment(extConfig);
}
public NewAzureDeploymentCmdletInfo(string serviceName, string packagePath, string configName, string slot,
string label, string name, bool doNotStart, bool warning, ExtensionConfigurationInput config)
{
cmdletName = Utilities.NewAzureDeploymentCmdletName;
cmdletParams.Add(new CmdletParam("ServiceName", serviceName));
cmdletParams.Add(new CmdletParam("Package", packagePath));
cmdletParams.Add(new CmdletParam("Configuration", configName));
cmdletParams.Add(new CmdletParam("Slot", slot));
if (label != null)
{
cmdletParams.Add(new CmdletParam("Label", label));
}
if (name != null)
{
cmdletParams.Add(new CmdletParam("Name", name));
}
if (doNotStart)
{
cmdletParams.Add(new CmdletParam("DoNotStart"));
}
if (warning)
{
cmdletParams.Add(new CmdletParam("TreatWarningsAsError"));
}
if (config != null)
{
cmdletParams.Add(new CmdletParam("ExtensionConfiguration", config));
}
}
public void ExecuteCommand()
{
InitializeAntimalwareSettings();
ValidateParameters();
RemoveAntimalwareExtension();
RemoveExistingAntimalwareMonitoringConfig();
ExtensionConfigurationInput[] extConfigInputs = null;
if (AntimalwareExtensionConfigurationInput != null && AntimalwareMonitoringExtensionConfigurationInput != null)
{
extConfigInputs = new ExtensionConfigurationInput[2];
extConfigInputs[0] = AntimalwareMonitoringExtensionConfigurationInput;
extConfigInputs[1] = AntimalwareExtensionConfigurationInput;
}
else if (AntimalwareExtensionConfigurationInput != null)
{
extConfigInputs = new ExtensionConfigurationInput[1];
extConfigInputs[0] = AntimalwareExtensionConfigurationInput;
}
else if (AntimalwareMonitoringExtensionConfigurationInput != null)
{
extConfigInputs = new ExtensionConfigurationInput[1];
extConfigInputs[0] = AntimalwareMonitoringExtensionConfigurationInput;
}
// process any pending deployment changes
if (extConfigInputs != null)
{
ExtensionConfiguration newExtConfig = ExtensionManager.Add(Deployment, extConfigInputs, Slot);
ChangeDeployment(newExtConfig);
}
}
public ExtensionConfigurationBuilder Add(ExtensionConfigurationInput context, string extensionId)
{
if (context != null && context.Roles != null)
{
context.Roles.ForEach(r => Add(r, extensionId));
}
return(this);
}
private void MergeAntimalwareMonitoringIntoExistingConfig(string existingConfigXmlStr)
{
// prepare a new xml document to hold the merged config
XmlDocument mergedConfig = new XmlDocument();
mergedConfig.LoadXml(existingConfigXmlStr);
// check if old config already contains a WindowsEventLog section
string targetNode;
string mergeXmlStr;
if (existingConfigXmlStr.Contains(DiagnosticsConfigWindowsEventLogNodeName))
{
// inject into the existing windows event log section
targetNode = DiagnosticsConfigWindowsEventLogNodeName;
mergeXmlStr = DiagnosticsDefaultConfigMergeXmlWithExistingEventLogNode;
}
else
{
// inject a windows event log section with antimalware monitoring into the diagnostics config
targetNode = DiagnosticsConfigNodeName;
mergeXmlStr = DiagnosticsDefaultConfigMergeXmlWithoutExistingEventLogNode;
}
// locate the desired target using xpath
string diagXPathStr = String.Format("//*[local-name()='{0}' and namespace-uri()='{1}']", targetNode, DiagnosticsConfigXmlNamespace);
XmlNode diagNode = mergedConfig.DocumentElement.SelectSingleNode(diagXPathStr);
// create an import node and then append to the correct location
XmlDocument diagnosticsConfigXml = new XmlDocument();
diagnosticsConfigXml.LoadXml(mergeXmlStr);
XmlNode importNode = mergedConfig.ImportNode(diagnosticsConfigXml.DocumentElement, true);
diagNode.AppendChild(importNode);
// Note : Currently any pre-existing user of the diagnostics configuration will be expected
// to follow convention of specifying storage account name in the xml configuration so that
// it can be persisted across configuration changes being made by multiple users.
// remove any stray xmlns="" attribute from xml string prior to use
string mergedConfiguration = mergedConfig.OuterXml.Replace(@"xmlns=""""", "");
// set up for reinstall of the extension with the new configuration
InitializeDiagnosticsSettings();
AntimalwareMonitoringExtensionConfigurationInput = new ExtensionConfigurationInput
{
ProviderNameSpace = ProviderNamespace,
Type = ExtensionName,
CertificateThumbprint = CertificateThumbprint,
ThumbprintAlgorithm = ThumbprintAlgorithm,
X509Certificate = X509Certificate,
PublicConfiguration = mergedConfiguration,
PrivateConfiguration = PrivateConfiguration,
Roles = new ExtensionRoleList(Role != null && Role.Any() ? Role.Select(r => new ExtensionRole(r)) : Enumerable.Repeat(new ExtensionRole(), 1))
};
}
public ExtensionConfiguration InstallExtension(ExtensionConfigurationInput context, string slot,
DeploymentGetResponse deployment, DeploymentGetResponse peerDeployment)
{
Func <DeploymentGetResponse, ExtensionConfiguration> func = (d) => d == null ? null : d.ExtensionConfiguration;
ExtensionConfiguration extConfig = func(deployment);
ExtensionConfiguration secondSlotExtConfig = func(peerDeployment);
return(InstallExtension(context, slot, extConfig, secondSlotExtConfig));
}
public void ExecuteCommand()
{
ValidateParameters();
// prepare diagnostics extension
switch (monitoringAction)
{
case MonitoringActionType.Enable: EnableMonitoring(); break;
case MonitoringActionType.Disable: RemoveExistingAntimalwareMonitoringConfig(); break;
default: break;
}
// prepare antimalware extension
if (isAntimalwareEnabled)
{
InitializeAntimalwareSettings();
ExtensionConfigurationInput amExtConfigInput = new ExtensionConfigurationInput
{
ProviderNameSpace = ProviderNamespace,
Type = ExtensionName,
PublicConfiguration = PublicConfiguration,
PrivateConfiguration = PrivateConfiguration,
Roles = new ExtensionRoleList(Role != null && Role.Any() ? Role.Select(r => new ExtensionRole(r)) : Enumerable.Repeat(new ExtensionRole(), 1))
};
AntimalwareExtensionConfigurationInput = amExtConfigInput;
}
// update extensions as appropriate
ExtensionConfigurationInput[] extConfigInputs = null;
if (AntimalwareExtensionConfigurationInput != null && AntimalwareMonitoringExtensionConfigurationInput != null)
{
extConfigInputs = new ExtensionConfigurationInput[2];
extConfigInputs[0] = AntimalwareMonitoringExtensionConfigurationInput;
extConfigInputs[1] = AntimalwareExtensionConfigurationInput;
}
else if (AntimalwareExtensionConfigurationInput != null)
{
extConfigInputs = new ExtensionConfigurationInput[1];
extConfigInputs[0] = AntimalwareExtensionConfigurationInput;
}
else if (AntimalwareMonitoringExtensionConfigurationInput != null)
{
extConfigInputs = new ExtensionConfigurationInput[1];
extConfigInputs[0] = AntimalwareMonitoringExtensionConfigurationInput;
}
// process any pending deployment changes
if (extConfigInputs != null)
{
ExtensionConfiguration newExtConfig = ExtensionManager.Add(Deployment, PeerDeployment, extConfigInputs, Slot);
ChangeDeployment(newExtConfig);
}
}
public static SetAzureDeploymentCmdletInfo SetAzureDeploymentConfigCmdletInfo(string serviceName, string slot, string configPath, ExtensionConfigurationInput extConfig = null)
{
SetAzureDeploymentCmdletInfo result = new SetAzureDeploymentCmdletInfo(serviceName, slot);
result.cmdletParams.Add(new CmdletParam("Config"));
result.cmdletParams.Add(new CmdletParam("Configuration", configPath));
if (extConfig != null)
{
result.cmdletParams.Add(new CmdletParam("ExtensionConfiguration", extConfig));
}
return result;
}
public void ExecuteCommand()
{
ValidateParameters();
ExtensionConfigurationInput context = new ExtensionConfigurationInput
{
ProviderNameSpace = ProviderNamespace,
Type = ExtensionName,
CertificateThumbprint = CertificateThumbprint,
ThumbprintAlgorithm = ThumbprintAlgorithm,
X509Certificate = X509Certificate,
PublicConfiguration = PublicConfiguration,
PrivateConfiguration = PrivateConfiguration,
Roles = new ExtensionRoleList(Role != null && Role.Any() ? Role.Select(r => new ExtensionRole(r)) : Enumerable.Repeat(new ExtensionRole(), 1))
};
var extConfig = ExtensionManager.InstallExtension(context, Slot, Deployment.ExtensionConfiguration);
ChangeDeployment(extConfig);
}
private void AddNewAntimalwareMonitoringConfig()
{
// install diagnostics provider with a new antimalware event monitoring config
InitializeDiagnosticsSettings();
ExtensionConfigurationInput diagExtConfigInput = new ExtensionConfigurationInput
{
ProviderNameSpace = ProviderNamespace,
Type = ExtensionName,
CertificateThumbprint = CertificateThumbprint,
ThumbprintAlgorithm = ThumbprintAlgorithm,
X509Certificate = X509Certificate,
PublicConfiguration = PublicConfiguration,
PrivateConfiguration = PrivateConfiguration,
Roles = new ExtensionRoleList(Role != null && Role.Any() ? Role.Select(r => new ExtensionRole(r)) : Enumerable.Repeat(new ExtensionRole(), 1))
};
AntimalwareMonitoringExtensionConfigurationInput = diagExtConfigInput;
}
/// <summary>
/// The configuration must be defined in either allRoles or namedRoles.
/// Otherwise, it will fail for trying to apply the same extension.
/// We only apply the fix here but not in ExtensionManager, so other commands won't get affected.
/// </summary>
/// <param name="configInput">The configuration used for InstallExtension()</param>
/// <param name="extConfig">The extension config after InstallExtension()</param>
private Microsoft.WindowsAzure.Management.Compute.Models.ExtensionConfiguration PostProcessExtensionConfigAfterInstallExtension(
ExtensionConfigurationInput configInput,
Microsoft.WindowsAzure.Management.Compute.Models.ExtensionConfiguration extConfig)
{
ExtensionConfigurationBuilder builder = ExtensionManager.GetBuilder(extConfig);
if (configInput.Roles.All(r => r.Default))
{
// If the configuration applies to all roles, remove the ones defined in each named roles
foreach (var role in Deployment.Roles)
{
builder.Remove(role.RoleName, ProviderNamespace, ExtensionName);
}
}
else
{
// If the configuration applies to some specific roles and there is already extension defined in allRoles,
// we remove the setting from allRoles and move it to specific namedRoles.
if (builder.ExistDefault(ProviderNamespace, ExtensionName))
{
var diagnosticExtensionId = extConfig.AllRoles.FirstOrDefault(ext =>
{
var e = ExtensionManager.GetExtension(ext.Id);
return(e != null && e.ProviderNamespace == ProviderNamespace && e.Type == ExtensionName);
}).Id;
builder.RemoveDefault(diagnosticExtensionId);
foreach (var role in Deployment.Roles)
{
// The role is previously configured by allRoles, move it to the namedRole itself
if (!configInput.Roles.Exists(r => r.RoleName == role.RoleName))
{
builder.Add(role.RoleName, diagnosticExtensionId);
}
}
}
}
return(builder.ToConfiguration());
}
public ExtensionConfiguration Set(DeploymentGetResponse currentDeployment, DeploymentGetResponse peerDeployment, ExtensionConfigurationInput[] inputs, string slot)
{
string errorConfigInput = null;
if (!Validate(inputs, out errorConfigInput))
{
throw new Exception(string.Format(Resources.ServiceExtensionCannotApplyExtensionsInSameType, errorConfigInput));
}
ExtensionConfigurationBuilder configBuilder = this.GetBuilder();
foreach (ExtensionConfigurationInput context in inputs)
{
if (context != null)
{
ExtensionConfiguration currentConfig = this.InstallExtension(context, slot, currentDeployment, peerDeployment);
foreach (var r in currentConfig.AllRoles)
{
if (currentDeployment == null || !this.GetBuilder(currentDeployment.ExtensionConfiguration).ExistAny(r.Id))
{
configBuilder.AddDefault(r.Id);
}
}
foreach (var r in currentConfig.NamedRoles)
{
foreach (var e in r.Extensions)
{
if (currentDeployment == null || !this.GetBuilder(currentDeployment.ExtensionConfiguration).ExistAny(e.Id))
{
configBuilder.Add(r.RoleName, e.Id);
}
}
}
}
}
var extConfig = configBuilder.ToConfiguration();
return extConfig;
}
public ExtensionConfiguration InstallExtension(ExtensionConfigurationInput context, string slot,
DeploymentGetResponse deployment, DeploymentGetResponse peerDeployment)
{
Func<DeploymentGetResponse, ExtensionConfiguration> func = (d) => d == null ? null : d.ExtensionConfiguration;
ExtensionConfiguration extConfig = func(deployment);
ExtensionConfiguration secondSlotExtConfig = func(peerDeployment);
return InstallExtension(context, slot, extConfig, secondSlotExtConfig);
}
public ExtensionConfiguration InstallExtension(ExtensionConfigurationInput context, string slot,
ExtensionConfiguration extConfig, ExtensionConfiguration secondSlotExtConfig)
{
ExtensionConfigurationBuilder builder = GetBuilder(extConfig);
ExtensionConfigurationBuilder secondSlotConfigBuilder = null;
if (secondSlotExtConfig != null)
{
secondSlotConfigBuilder = GetBuilder(secondSlotExtConfig);
}
foreach (ExtensionRole r in context.Roles)
{
var extensionIds = (from index in Enumerable.Range(0, ExtensionIdLiveCycleCount)
select r.GetExtensionId(context.Type, slot, index)).ToList();
string availableId = context.Id
?? (from extensionId in extensionIds
where
!builder.ExistAny(extensionId) &&
(secondSlotConfigBuilder == null ||
!secondSlotConfigBuilder.ExistAny(extensionId))
select extensionId).FirstOrDefault();
var extensionList = (from id in extensionIds
let e = GetExtension(id)
where e != null
select e).ToList();
string thumbprint = context.CertificateThumbprint;
string thumbprintAlgorithm = context.ThumbprintAlgorithm;
if (context.X509Certificate != null)
{
thumbprint = context.X509Certificate.Thumbprint;
}
else
{
GetThumbprintAndAlgorithm(extensionList, availableId, ref thumbprint, ref thumbprintAlgorithm);
}
context.CertificateThumbprint = string.IsNullOrWhiteSpace(context.CertificateThumbprint) ? thumbprint : context.CertificateThumbprint;
context.ThumbprintAlgorithm = string.IsNullOrWhiteSpace(context.ThumbprintAlgorithm) ? thumbprintAlgorithm : context.ThumbprintAlgorithm;
if (!string.IsNullOrWhiteSpace(context.CertificateThumbprint) && string.IsNullOrWhiteSpace(context.ThumbprintAlgorithm))
{
context.ThumbprintAlgorithm = ThumbprintAlgorithmStr;
}
else if (string.IsNullOrWhiteSpace(context.CertificateThumbprint) && !string.IsNullOrWhiteSpace(context.ThumbprintAlgorithm))
{
context.ThumbprintAlgorithm = string.Empty;
}
var existingExtension = extensionList.Find(e => e.Id == availableId);
if (existingExtension != null)
{
DeleteExtension(availableId);
}
if (r.Default)
{
Cmdlet.WriteVerbose(string.Format(Resources.ServiceExtensionSettingForDefaultRole, context.Type));
}
else
{
Cmdlet.WriteVerbose(string.Format(Resources.ServiceExtensionSettingForSpecificRole, context.Type, r.RoleName));
}
AddExtension(new HostedServiceAddExtensionParameters
{
Id = availableId,
Thumbprint = context.CertificateThumbprint,
ThumbprintAlgorithm = context.ThumbprintAlgorithm,
ProviderNamespace = context.ProviderNameSpace,
Type = context.Type,
PublicConfiguration = context.PublicConfiguration,
PrivateConfiguration = context.PrivateConfiguration,
Version = string.IsNullOrEmpty(context.Version) ? ExtensionDefaultVersion : context.Version
});
if (r.Default)
{
builder.RemoveDefault(context.ProviderNameSpace, context.Type);
builder.AddDefault(availableId);
}
else
{
builder.Remove(r.RoleName, context.ProviderNameSpace, context.Type);
builder.Add(r.RoleName, availableId);
}
}
return builder.ToConfiguration();
}
private void AddNewAntimalwareMonitoringConfig()
{
// install diagnostics provider with a new antimalware event monitoring config
InitializeDiagnosticsSettings();
ExtensionConfigurationInput diagExtConfigInput = new ExtensionConfigurationInput
{
ProviderNameSpace = ProviderNamespace,
Type = ExtensionName,
CertificateThumbprint = CertificateThumbprint,
ThumbprintAlgorithm = ThumbprintAlgorithm,
X509Certificate = X509Certificate,
PublicConfiguration = PublicConfiguration,
PrivateConfiguration = PrivateConfiguration,
Roles = new ExtensionRoleList(Role != null && Role.Any() ? Role.Select(r => new ExtensionRole(r)) : Enumerable.Repeat(new ExtensionRole(), 1))
};
AntimalwareMonitoringExtensionConfigurationInput = diagExtConfigInput;
}
protected void EnableMonitoring()
{
// retrieve any pre-existing diagnostics extension
var ext = GetDiagnosticsExtension();
if ((ext == null) &&
((monitoringAction == MonitoringActionType.Disable) || (monitoringAction == MonitoringActionType.NoActionRequested)))
{
// if there was no pre-existing diagnostics extension there is
// nothing to do in either of these two cases so exit early
// note the user may not have provided a storage account either
// so this check is performed prior to storage account validation
return;
}
// establish the storage account name to be associated with monitoring
if (!IsValidStorageContext())
{
// no valid storage context exists, try to initialize storage context using config value
InitializeStorageContext(monitoringStorageAccountName);
}
if (!IsValidStorageContext())
{
// still unable to associate the storage account name with a valid storage context
ThrowTerminatingError(new ErrorRecord(
new Exception(Resources.ServiceExtensionCannotFindStorageAccountName),
string.Empty,
ErrorCategory.InvalidData,
null));
}
if (ext != null)
{
// save the current configuration of the diagnostics extension
// in the event we do not end up needing to modify it but need
// to persist the config in the final call to change deployment
InitializeDiagnosticsSettings();
AntimalwareMonitoringExtensionConfigurationInput = new ExtensionConfigurationInput
{
ProviderNameSpace = ProviderNamespace,
Type = ExtensionName,
CertificateThumbprint = CertificateThumbprint,
ThumbprintAlgorithm = ThumbprintAlgorithm,
X509Certificate = X509Certificate,
PublicConfiguration = ext.PublicConfiguration,
PrivateConfiguration = PrivateConfiguration,
Roles = new ExtensionRoleList(Role != null && Role.Any() ? Role.Select(r => new ExtensionRole(r)) : Enumerable.Repeat(new ExtensionRole(), 1))
};
}
switch (monitoringAction)
{
case (MonitoringActionType.Enable):
if (ext == null)
{
AddNewAntimalwareMonitoringConfig();
}
else
{
// extension already exists, check to see if it already contains antimalware data source
if (!ext.PublicConfiguration.Contains(DiagnosticsConfigAntimalwareProviderToken))
{
// antimalware data source is not already in the configuration, merge it
// with existing config (tracking perf counters, other event logs, etc.)
MergeAntimalwareMonitoringIntoExistingConfig(ext.PublicConfiguration);
}
else
{
// in this case we preserve monitoring configuration but
// apply any changes to storage context that may be needed
SaveMonitoringConfiguration(ext.PublicConfiguration);
InitializeDiagnosticsSettings();
AntimalwareMonitoringExtensionConfigurationInput = new ExtensionConfigurationInput
{
ProviderNameSpace = ProviderNamespace,
Type = ExtensionName,
CertificateThumbprint = CertificateThumbprint,
ThumbprintAlgorithm = ThumbprintAlgorithm,
X509Certificate = X509Certificate,
PublicConfiguration = PublicConfiguration,
PrivateConfiguration = PrivateConfiguration,
Roles = new ExtensionRoleList(Role != null && Role.Any() ? Role.Select(r => new ExtensionRole(r)) : Enumerable.Repeat(new ExtensionRole(), 1))
};
}
}
break;
case (MonitoringActionType.Disable):
if (ext != null)
{
RemoveExistingAntimalwareMonitoringConfig();
}
break;
case (MonitoringActionType.NoActionRequested):
break;
default:
break;
}
}
public ExtensionConfigurationBuilder Add(ExtensionConfigurationInput context, string extensionId)
{
if (context != null && context.Roles != null)
{
context.Roles.ForEach(r => Add(r, extensionId));
}
return this;
}
public ExtensionConfiguration InstallExtension(ExtensionConfigurationInput context, string slot,
DeploymentGetResponse deployment, DeploymentGetResponse peerDeployment)
{
Func <DeploymentGetResponse, ExtensionConfiguration> func = (d) => d == null ? null : d.ExtensionConfiguration;
ExtensionConfiguration extConfig = func(deployment);
ExtensionConfiguration secondSlotExtConfig = func(peerDeployment);
ExtensionConfigurationBuilder builder = GetBuilder(extConfig);
ExtensionConfigurationBuilder secondSlotConfigBuilder = null;
if (secondSlotExtConfig != null)
{
secondSlotConfigBuilder = GetBuilder(secondSlotExtConfig);
}
foreach (ExtensionRole r in context.Roles)
{
var extensionIds = (from index in Enumerable.Range(0, ExtensionIdLiveCycleCount)
select r.GetExtensionId(context.Type, slot, index)).ToList();
string availableId = context.Id
?? (from extensionId in extensionIds
where
!builder.ExistAny(extensionId) &&
(secondSlotConfigBuilder == null ||
!secondSlotConfigBuilder.ExistAny(extensionId))
select extensionId).FirstOrDefault();
var extensionList = (from id in extensionIds
let e = GetExtension(id)
where e != null
select e).ToList();
string thumbprint = context.CertificateThumbprint;
string thumbprintAlgorithm = context.ThumbprintAlgorithm;
if (context.X509Certificate != null)
{
thumbprint = context.X509Certificate.Thumbprint;
}
else
{
GetThumbprintAndAlgorithm(extensionList, availableId, ref thumbprint, ref thumbprintAlgorithm);
}
context.CertificateThumbprint = string.IsNullOrWhiteSpace(context.CertificateThumbprint) ? thumbprint : context.CertificateThumbprint;
context.ThumbprintAlgorithm = string.IsNullOrWhiteSpace(context.ThumbprintAlgorithm) ? thumbprintAlgorithm : context.ThumbprintAlgorithm;
if (!string.IsNullOrWhiteSpace(context.CertificateThumbprint) && string.IsNullOrWhiteSpace(context.ThumbprintAlgorithm))
{
context.ThumbprintAlgorithm = ThumbprintAlgorithmStr;
}
else if (string.IsNullOrWhiteSpace(context.CertificateThumbprint) && !string.IsNullOrWhiteSpace(context.ThumbprintAlgorithm))
{
context.ThumbprintAlgorithm = string.Empty;
}
var existingExtension = extensionList.Find(e => e.Id == availableId);
if (existingExtension != null)
{
DeleteExtension(availableId);
}
if (r.Default)
{
Cmdlet.WriteVerbose(string.Format(Resources.ServiceExtensionSettingForDefaultRole, context.Type));
}
else
{
Cmdlet.WriteVerbose(string.Format(Resources.ServiceExtensionSettingForSpecificRole, context.Type, r.RoleName));
}
AddExtension(new HostedServiceAddExtensionParameters
{
Id = availableId,
Thumbprint = context.CertificateThumbprint,
ThumbprintAlgorithm = context.ThumbprintAlgorithm,
ProviderNamespace = context.ProviderNameSpace,
Type = context.Type,
PublicConfiguration = context.PublicConfiguration,
PrivateConfiguration = context.PrivateConfiguration,
Version = string.IsNullOrEmpty(context.Version) ? ExtensionDefaultVersion : context.Version
});
if (r.Default)
{
builder.RemoveDefault(context.ProviderNameSpace, context.Type);
builder.AddDefault(availableId);
}
else
{
builder.Remove(r.RoleName, context.ProviderNameSpace, context.Type);
builder.Add(r.RoleName, availableId);
}
}
return(builder.ToConfiguration());
}
public ExtensionConfiguration UpdateExtensionState(ExtensionConfigurationInput input)
{
var extConfig = new ExtensionConfiguration();
if (input.Roles == null || input.Roles.Count == 1 && input.Roles[0].RoleType == ExtensionRoleType.AllRoles)
{
extConfig.AllRoles = new List<ExtensionConfiguration.Extension>();
extConfig.AllRoles.Add(new ExtensionConfiguration.Extension
{
Id = input.Id,
State = input.State
});
}
else
{
extConfig.NamedRoles = new List<ExtensionConfiguration.NamedRole>();
foreach (var role in input.Roles)
{
var ext = new List<ExtensionConfiguration.Extension>();
ext.Add(new ExtensionConfiguration.Extension
{
Id = input.Id,
State = input.State
});
extConfig.NamedRoles.Add(new ExtensionConfiguration.NamedRole
{
RoleName = role.RoleName,
Extensions = ext
});
}
}
return extConfig;
}
private bool VerifyExtensionConfigRDP(ExtensionConfigurationInput resultConfig, string user, string pass, List<string> roles, DateTime exp, string thumbprint = null, string algorithm = null, X509Certificate2 cert = null)
{
try
{
string resultUserName = GetInnerText(resultConfig.PublicConfiguration, "UserName");
string resultPassword = GetInnerText(resultConfig.PrivateConfiguration, "Password");
string resultExpDate = GetInnerText(resultConfig.PublicConfiguration, "Expiration");
Console.WriteLine("Type: {0}, UserName:{1}, Password: {2}, ExpirationDate: {3}, CertificateThumbprint: {4}, ThumbprintAlgorithm: {5}, X509Certificate: {6}",
resultConfig.Type, resultUserName, resultPassword, resultExpDate, resultConfig.CertificateThumbprint, resultConfig.ThumbprintAlgorithm, resultConfig.X509Certificate);
Assert.AreEqual(resultConfig.Type, "RDP", "Type is not equal!");
Assert.AreEqual(resultUserName, user);
Assert.AreEqual(resultPassword, pass);
Assert.IsTrue(Utilities.CompareDateTime(exp, resultExpDate));
if (string.IsNullOrWhiteSpace(thumbprint))
{
Assert.IsTrue(string.IsNullOrWhiteSpace(resultConfig.CertificateThumbprint));
}
else
{
Assert.AreEqual(resultConfig.CertificateThumbprint, thumbprint, "Certificate thumbprint is not equal!");
}
if (string.IsNullOrWhiteSpace(algorithm))
{
Assert.IsTrue(string.IsNullOrWhiteSpace(resultConfig.ThumbprintAlgorithm));
}
else
{
Assert.AreEqual(resultConfig.ThumbprintAlgorithm, algorithm, "Thumbprint algorithm is not equal!");
}
Assert.AreEqual(resultConfig.X509Certificate, cert, "X509Certificate is not equal!");
if (resultConfig.Roles.Count == 1 && string.IsNullOrEmpty(resultConfig.Roles[0].RoleName))
{
Assert.IsTrue(roles.Contains(resultConfig.Roles[0].RoleType.ToString()));
}
else
{
foreach (ExtensionRole role in resultConfig.Roles)
{
Assert.IsTrue(roles.Contains(role.RoleName));
}
}
return true;
}
catch
{
return false;
}
}
private void NewAzureDeployment(ExtensionConfigurationInput domainJoinExtensionConfig = null)
{
//Create a new Azure Iaas VM and set Domain Join extension, get domain join extension and then remove domain join extension
Console.WriteLine("Creating a new Azure Iaas VM");
vmPowershellCmdlets.NewAzureService(_serviceName, _serviceName, null, AffinityGroupName);
Console.WriteLine("Service, {0}, is created.", _serviceName);
vmPowershellCmdlets.AddAzureCertificate(_serviceName, _rdpCertPath.FullName, password);
if (domainJoinExtensionConfig == null)
{
vmPowershellCmdlets.NewAzureDeployment(_serviceName, _packagePath1.FullName, _configPath1.FullName, DeploymentSlotType.Production, _deploymentLabel, _deploymentName, false, false);
Console.WriteLine("New deployment created successfully.");
}
else
{
vmPowershellCmdlets.NewAzureDeployment(_serviceName, _packagePath1.FullName, _configPath1.FullName, DeploymentSlotType.Production, _deploymentLabel, _deploymentName, false, false, domainJoinExtensionConfig);
Console.WriteLine("{0}:New deployment {1} with domain join {2} created successfully.", DateTime.Now, _serviceName, domainJoinExtensionConfig.Type);
}
}
protected void RemoveExistingAntimalwareMonitoringConfig()
{
// this does not remove the diagnostics extension entirely, it only removes the portion of the
// diagnostics configuration that monitors antimalware events- everything else will remain
// in order to avoid doing harm to any other users who may be sharing the diagnostics extension
var ext = GetDiagnosticsExtension();
if (ext != null)
{
string tmpXmlString = ext.PublicConfiguration;
string AntimalwareDataSourceName = "System!*[System[Provider[@Name='Microsoft Antimalware']]]";
string DiagnosticsConfigXmlNamespace = @"http://schemas.microsoft.com/ServiceHosting/2010/10/DiagnosticsConfiguration";
// remove the data source element with the antimalware event provider
XmlDocument tmpXmlDoc = new XmlDocument();
tmpXmlDoc.LoadXml(tmpXmlString);
// retrieve storage account name from public configuration
string stgAcctNameXPath = string.Format(@"//*[local-name()='{0}' and namespace-uri()='{1}']", StorageAccountElemStr, DiagnosticsConfigXmlNamespace);
XmlNode stgAcctNameNode = tmpXmlDoc.DocumentElement.SelectSingleNode(stgAcctNameXPath);
if (stgAcctNameNode != null)
{
StorageAccountName = stgAcctNameNode.InnerText;
}
if (string.IsNullOrWhiteSpace(StorageAccountName))
{
// do not modify diagnostics config without including the storage account
// throw terminating exception since it is not possible to preserve the
// existing storage account with the configuration if it doesn't have a
// hint to what the last storage account was in the public configuration
ThrowTerminatingError(new ErrorRecord(
new Exception(Resources.ServiceExtensionCannotFindStorageAccountName),
string.Empty,
ErrorCategory.InvalidData,
null));
return;
}
else
{
// check the storage account and initialize for use
ValidateStorageAccount();
}
// locate the antimalware data source node in the document
string antimalwareDataSourceXPath = string.Format(@"//*[local-name()='{0}' and @name=""{1}"" and namespace-uri()='{2}']", "DataSource", AntimalwareDataSourceName, DiagnosticsConfigXmlNamespace);
XmlNode antimalwareDataSourceNode = tmpXmlDoc.DocumentElement.SelectSingleNode(antimalwareDataSourceXPath);
if (antimalwareDataSourceNode != null)
{
XmlNode windowsEventLogNode = antimalwareDataSourceNode.ParentNode;
if (windowsEventLogNode.RemoveChild(antimalwareDataSourceNode) != null)
{
// remove the windows event log if there are no other child data sources present
// as will be required for schema validation to succeed when sending the new config
// any other data sources outside of the windows event log are left untouched
if (!windowsEventLogNode.HasChildNodes)
{
windowsEventLogNode.ParentNode.RemoveChild(windowsEventLogNode);
}
}
// now reinstall the diagnostics extension with the updated configuration
InitializeDiagnosticsSettings();
ExtensionConfigurationInput diagExtConfigInput = new ExtensionConfigurationInput
{
ProviderNameSpace = ProviderNamespace,
Type = ExtensionName,
CertificateThumbprint = CertificateThumbprint,
ThumbprintAlgorithm = ThumbprintAlgorithm,
X509Certificate = X509Certificate,
PublicConfiguration = tmpXmlDoc.OuterXml,
PrivateConfiguration = PrivateConfiguration,
Roles = new ExtensionRoleList(Role != null && Role.Any() ? Role.Select(r => new ExtensionRole(r)) : Enumerable.Repeat(new ExtensionRole(), 1))
};
AntimalwareMonitoringExtensionConfigurationInput = diagExtConfigInput;
}
else
{
// no existing antimalware data source was found needing removal
return;
}
}
}
/// <summary>
/// The configuration must be defined in either allRoles or namedRoles.
/// Otherwise, it will fail for trying to apply the same extension.
/// We only apply the fix here but not in ExtensionManager, so other commands won't get affected.
/// </summary>
/// <param name="configInput">The configuration used for InstallExtension()</param>
/// <param name="extConfig">The extension config after InstallExtension()</param>
private Microsoft.WindowsAzure.Management.Compute.Models.ExtensionConfiguration PostProcessExtensionConfigAfterInstallExtension(
ExtensionConfigurationInput configInput,
Microsoft.WindowsAzure.Management.Compute.Models.ExtensionConfiguration extConfig)
{
ExtensionConfigurationBuilder builder = ExtensionManager.GetBuilder(extConfig);
if (configInput.Roles.All(r => r.Default))
{
// If the configuration applies to all roles, remove the ones defined in each named roles
foreach (var role in Deployment.Roles)
{
builder.Remove(role.RoleName, ProviderNamespace, ExtensionName);
}
}
else
{
// If the configuration applies to some specific roles and there is already extension defined in allRoles,
// we remove the setting from allRoles and move it to specific namedRoles.
if (builder.ExistDefault(ProviderNamespace, ExtensionName))
{
var diagnosticExtensionId = extConfig.AllRoles.FirstOrDefault(ext =>
{
var e = ExtensionManager.GetExtension(ext.Id);
return e != null && e.ProviderNamespace == ProviderNamespace && e.Type == ExtensionName;
}).Id;
builder.RemoveDefault(diagnosticExtensionId);
foreach (var role in Deployment.Roles)
{
// The role is previously configured by allRoles, move it to the namedRole itself
if (!configInput.Roles.Exists(r => r.RoleName == role.RoleName))
{
builder.Add(role.RoleName, diagnosticExtensionId);
}
}
}
}
return builder.ToConfiguration();
}
public ExtensionConfiguration InstallExtension(ExtensionConfigurationInput context, string slot, Microsoft.WindowsAzure.Management.Compute.Models.ExtensionConfiguration extConfig)
{
ExtensionConfigurationBuilder builder = GetBuilder(extConfig);
foreach (ExtensionRole r in context.Roles)
{
var extensionIds = (from index in Enumerable.Range(0, ExtensionIdLiveCycleCount)
select r.GetExtensionId(context.Type, slot, index)).ToList();
string availableId = (from extensionId in extensionIds
where !builder.ExistAny(extensionId)
select extensionId).FirstOrDefault();
var extensionList = (from id in extensionIds
let e = GetExtension(id)
where e != null
select e).ToList();
string thumbprint = context.CertificateThumbprint;
string thumbprintAlgorithm = context.ThumbprintAlgorithm;
if (context.X509Certificate != null)
{
thumbprint = context.X509Certificate.Thumbprint;
}
else
{
GetThumbprintAndAlgorithm(extensionList, availableId, ref thumbprint, ref thumbprintAlgorithm);
}
context.CertificateThumbprint = string.IsNullOrWhiteSpace(context.CertificateThumbprint) ? thumbprint : context.CertificateThumbprint;
context.ThumbprintAlgorithm = string.IsNullOrWhiteSpace(context.ThumbprintAlgorithm) ? thumbprintAlgorithm : context.ThumbprintAlgorithm;
if (!string.IsNullOrWhiteSpace(context.CertificateThumbprint) && string.IsNullOrWhiteSpace(context.ThumbprintAlgorithm))
{
context.ThumbprintAlgorithm = ThumbprintAlgorithmStr;
}
else if (string.IsNullOrWhiteSpace(context.CertificateThumbprint) && !string.IsNullOrWhiteSpace(context.ThumbprintAlgorithm))
{
context.ThumbprintAlgorithm = string.Empty;
}
var existingExtension = extensionList.Find(e => e.Id == availableId);
if (existingExtension != null)
{
DeleteExtension(availableId);
}
if (r.Default)
{
Cmdlet.WriteVerbose(string.Format(Resources.ServiceExtensionSettingForDefaultRole, context.Type));
}
else
{
Cmdlet.WriteVerbose(string.Format(Resources.ServiceExtensionSettingForSpecificRole, context.Type, r.RoleName));
}
AddExtension(new HostedServiceAddExtensionParameters
{
Id = availableId,
Thumbprint = context.CertificateThumbprint,
ThumbprintAlgorithm = context.ThumbprintAlgorithm,
ProviderNamespace = context.ProviderNameSpace,
Type = context.Type,
PublicConfiguration = context.PublicConfiguration,
PrivateConfiguration = context.PrivateConfiguration
});
if (r.Default)
{
builder.RemoveDefault(context.ProviderNameSpace, context.Type);
builder.AddDefault(availableId);
}
else
{
builder.Remove(r.RoleName, context.ProviderNameSpace, context.Type);
builder.Add(r.RoleName, availableId);
}
}
return(builder.ToConfiguration());
}
public static bool Validate(ExtensionConfigurationInput[] inputs, out string errorConfigInput)
{
var roleList = (from c in inputs
where c != null
from r in c.Roles
select r).GroupBy(r => r.ToString()).Select(g => g.First());
foreach (var role in roleList)
{
var result = from c in inputs
where c != null && c.Roles.Any(r => r.ToString() == role.ToString())
select string.Format("{0}.{1}", c.ProviderNameSpace, c.Type);
foreach (var s in result)
{
if (result.Count(t => t == s) > 1)
{
errorConfigInput = s;
return false;
}
}
}
errorConfigInput = null;
return true;
}
public void ExecuteCommand()
{
ValidateParameters();
ExtensionConfigurationInput context = new ExtensionConfigurationInput
{
Version = Version,
ProviderNameSpace = ProviderNamespace,
Type = ExtensionName,
CertificateThumbprint = CertificateThumbprint,
ThumbprintAlgorithm = ThumbprintAlgorithm,
X509Certificate = X509Certificate,
PublicConfiguration = PublicConfiguration,
PrivateConfiguration = PrivateConfiguration,
Roles = new ExtensionRoleList(Role != null && Role.Any() ? Role.Select(r => new ExtensionRole(r)) : Enumerable.Repeat(new ExtensionRole(), 1))
};
var secondSlotDeployment = GetDeployment(this.Slot == DeploymentSlotType.Production ? DeploymentSlotType.Staging : DeploymentSlotType.Production);
Microsoft.WindowsAzure.Management.Compute.Models.ExtensionConfiguration secondSlotExtensionConfiguration =
secondSlotDeployment != null ? secondSlotDeployment.ExtensionConfiguration : null;
var extConfig = ExtensionManager.InstallExtension(context, Slot, Deployment.ExtensionConfiguration, secondSlotExtensionConfiguration);
ChangeDeployment(extConfig);
}
private void MergeAntimalwareMonitoringIntoExistingConfig(string existingConfigXmlStr)
{
// prepare a new xml document to hold the merged config
XmlDocument mergedConfig = new XmlDocument();
mergedConfig.LoadXml(existingConfigXmlStr);
// check if old config already contains a WindowsEventLog section
string targetNode;
string mergeXmlStr;
if (existingConfigXmlStr.Contains(DiagnosticsConfigWindowsEventLogNodeName))
{
// inject into the existing windows event log section
targetNode = DiagnosticsConfigWindowsEventLogNodeName;
mergeXmlStr = DiagnosticsDefaultConfigMergeXmlWithExistingEventLogNode;
}
else
{
// inject a windows event log section with antimalware monitoring into the diagnostics config
targetNode = DiagnosticsConfigNodeName;
mergeXmlStr = DiagnosticsDefaultConfigMergeXmlWithoutExistingEventLogNode;
}
// locate the desired target using xpath
string diagXPathStr = String.Format("//*[local-name()='{0}' and namespace-uri()='{1}']", targetNode, DiagnosticsConfigXmlNamespace);
XmlNode diagNode = mergedConfig.DocumentElement.SelectSingleNode(diagXPathStr);
// create an import node and then append to the correct location
XmlDocument diagnosticsConfigXml = new XmlDocument();
diagnosticsConfigXml.LoadXml(mergeXmlStr);
XmlNode importNode = mergedConfig.ImportNode(diagnosticsConfigXml.DocumentElement, true);
diagNode.AppendChild(importNode);
// Note : Currently any pre-existing user of the diagnostics configuration will be expected
// to follow convention of specifying storage account name in the xml configuration so that
// it can be persisted across configuration changes being made by multiple users.
// remove any stray xmlns="" attribute from xml string prior to use
string mergedConfiguration = mergedConfig.OuterXml.Replace(@"xmlns=""""", "");
// now reinstall the extension with the new configuration
InitializeDiagnosticsSettings();
ExtensionConfigurationInput diagExtConfigInput = new ExtensionConfigurationInput
{
ProviderNameSpace = ProviderNamespace,
Type = ExtensionName,
CertificateThumbprint = CertificateThumbprint,
ThumbprintAlgorithm = ThumbprintAlgorithm,
X509Certificate = X509Certificate,
PublicConfiguration = mergedConfiguration,
PrivateConfiguration = PrivateConfiguration,
Roles = new ExtensionRoleList(Role != null && Role.Any() ? Role.Select(r => new ExtensionRole(r)) : Enumerable.Repeat(new ExtensionRole(), 1))
};
// set up for reinstall with new configuration
AntimalwareMonitoringExtensionConfigurationInput = diagExtConfigInput;
}
public Microsoft.WindowsAzure.Management.Compute.Models.ExtensionConfiguration Add(DeploymentGetResponse deployment, ExtensionConfigurationInput[] inputs, string slot)
{
string errorConfigInput = null;
if (!Validate(inputs, out errorConfigInput))
{
throw new Exception(string.Format(Resources.ServiceExtensionCannotApplyExtensionsInSameType, errorConfigInput));
}
var oldExtConfig = deployment.ExtensionConfiguration;
ExtensionConfigurationBuilder configBuilder = this.GetBuilder();
foreach (ExtensionConfigurationInput context in inputs)
{
if (context != null)
{
Microsoft.WindowsAzure.Management.Compute.Models.ExtensionConfiguration currentConfig = this.InstallExtension(context, slot, oldExtConfig);
foreach (var r in currentConfig.AllRoles)
{
if (!this.GetBuilder(oldExtConfig).ExistAny(r.Id))
{
configBuilder.AddDefault(r.Id);
}
}
foreach (var r in currentConfig.NamedRoles)
{
foreach (var e in r.Extensions)
{
if (!this.GetBuilder(oldExtConfig).ExistAny(e.Id))
{
configBuilder.Add(r.RoleName, e.Id);
}
}
}
}
}
var extConfig = configBuilder.ToConfiguration();
return extConfig;
}
protected void EnableMonitoring()
{
// retrieve any pre-existing diagnostics extension
var ext = GetDiagnosticsExtension();
if ( (ext == null) &&
((monitoringAction==MonitoringActionType.Disable) || (monitoringAction == MonitoringActionType.NoActionRequested)) )
{
// if there was no pre-existing diagnostics extension there is
// nothing to do in either of these two cases so exit early
// note the user may not have provided a storage account either
// so this check is performed prior to storage account validation
return;
}
// establish the storage account name to be associated with monitoring
if (string.IsNullOrWhiteSpace(StorageAccountName))
{
// not specified as a parameter, try to use any value found in config
StorageAccountName = monitoringStorageAccountName;
}
if (string.IsNullOrWhiteSpace(StorageAccountName))
{
// unable to find the storage account name as a parameter or as a config
ThrowTerminatingError(new ErrorRecord(
new Exception(Resources.ServiceExtensionCannotFindStorageAccountName),
string.Empty,
ErrorCategory.InvalidData,
null));
}
else
{
ValidateStorageAccount();
}
if (ext != null)
{
// save the current configuration of the diagnostics extension
// in the event we do not end up needing to modify it but need
// to persist the config in the final call to change deployment
InitializeDiagnosticsSettings();
AntimalwareMonitoringExtensionConfigurationInput = new ExtensionConfigurationInput
{
ProviderNameSpace = ProviderNamespace,
Type = ExtensionName,
CertificateThumbprint = CertificateThumbprint,
ThumbprintAlgorithm = ThumbprintAlgorithm,
X509Certificate = X509Certificate,
PublicConfiguration = ext.PublicConfiguration,
PrivateConfiguration = PrivateConfiguration,
Roles = new ExtensionRoleList(Role != null && Role.Any() ? Role.Select(r => new ExtensionRole(r)) : Enumerable.Repeat(new ExtensionRole(), 1))
};
}
switch (monitoringAction)
{
case (MonitoringActionType.Enable) :
if (ext == null)
{
AddNewAntimalwareMonitoringConfig();
}
else
{
// extension already exists, check to see if it already contains antimalware data source
if (!ext.PublicConfiguration.Contains(DiagnosticsConfigAntimalwareProviderToken))
{
// antimalware data source is not already in the configuration, merge it
// with existing config (tracking perf counters, other event logs, etc.)
MergeAntimalwareMonitoringIntoExistingConfig(ext.PublicConfiguration);
}
}
break;
case (MonitoringActionType.Disable) :
if (ext != null)
{
RemoveExistingAntimalwareMonitoringConfig();
}
break;
case (MonitoringActionType.NoActionRequested) :
break;
default:
break;
}
}
public void ExecuteCommand()
{
ValidateParameters();
ExtensionConfigurationInput context = new ExtensionConfigurationInput
{
Id = ExtensionId,
ProviderNameSpace = ProviderNamespace,
Type = ExtensionName,
CertificateThumbprint = CertificateThumbprint,
ThumbprintAlgorithm = ThumbprintAlgorithm,
X509Certificate = X509Certificate,
PublicConfiguration = PublicConfiguration,
PrivateConfiguration = PrivateConfiguration,
Version = Version,
Roles = new ExtensionRoleList(Role != null && Role.Any() ? Role.Select(r => new ExtensionRole(r)) : Enumerable.Repeat(new ExtensionRole(), 1))
};
var extConfig = ExtensionManager.InstallExtension(context, Slot, Deployment, PeerDeployment);
ChangeDeployment(extConfig);
}
public void ExecuteCommand()
{
ValidateParameters();
// set diagnostics extension
switch (monitoringAction)
{
case MonitoringActionType.Enable : EnableMonitoring(); break;
case MonitoringActionType.Disable : RemoveExistingAntimalwareMonitoringConfig(); break;
default: break;
}
// set antimalware extension
InitializeAntimalwareSettings();
ExtensionConfigurationInput amExtConfigInput = new ExtensionConfigurationInput
{
ProviderNameSpace = ProviderNamespace,
Type = ExtensionName,
PublicConfiguration = PublicConfiguration,
PrivateConfiguration = PrivateConfiguration,
Roles = new ExtensionRoleList(Role != null && Role.Any() ? Role.Select(r => new ExtensionRole(r)) : Enumerable.Repeat(new ExtensionRole(), 1))
};
AntimalwareExtensionConfigurationInput = amExtConfigInput;
ExtensionConfigurationInput[] extConfigInputs = null;
if (AntimalwareExtensionConfigurationInput != null && AntimalwareMonitoringExtensionConfigurationInput != null)
{
extConfigInputs = new ExtensionConfigurationInput[2];
extConfigInputs[0] = AntimalwareMonitoringExtensionConfigurationInput;
extConfigInputs[1] = AntimalwareExtensionConfigurationInput;
}
else if (AntimalwareExtensionConfigurationInput != null)
{
extConfigInputs = new ExtensionConfigurationInput[1];
extConfigInputs[0] = AntimalwareExtensionConfigurationInput;
}
else if (AntimalwareMonitoringExtensionConfigurationInput!=null)
{
extConfigInputs = new ExtensionConfigurationInput[1];
extConfigInputs[0] = AntimalwareMonitoringExtensionConfigurationInput;
}
// process any pending deployment changes
if (extConfigInputs != null)
{
ExtensionConfiguration newExtConfig = ExtensionManager.Add(Deployment, extConfigInputs, Slot);
ChangeDeployment(newExtConfig);
}
}
protected void RemoveExistingAntimalwareMonitoringConfig()
{
// this does not remove the diagnostics extension entirely, it only removes the portion of the
// diagnostics configuration that monitors antimalware events- everything else will remain
// in order to avoid doing harm to any other users who may be sharing the diagnostics extension
var ext = GetDiagnosticsExtension();
if (ext != null)
{
string tmpXmlString = ext.PublicConfiguration;
string AntimalwareDataSourceName = "System!*[System[Provider[@Name='Microsoft Antimalware']]]";
string DiagnosticsConfigXmlNamespace = @"http://schemas.microsoft.com/ServiceHosting/2010/10/DiagnosticsConfiguration";
string monitoringStorageAccountName = null; // for temporarily retrieving storage account name when specified in config file
// remove the data source element with the antimalware event provider
XmlDocument tmpXmlDoc = new XmlDocument();
tmpXmlDoc.LoadXml(tmpXmlString);
// retrieve storage account name from public configuration
string stgAcctNameXPath = string.Format(@"//*[local-name()='{0}' and namespace-uri()='{1}']", StorageAccountElemStr, DiagnosticsConfigXmlNamespace);
XmlNode stgAcctNameNode = tmpXmlDoc.DocumentElement.SelectSingleNode(stgAcctNameXPath);
if (stgAcctNameNode != null)
{
monitoringStorageAccountName = stgAcctNameNode.InnerText;
}
if (string.IsNullOrWhiteSpace(monitoringStorageAccountName))
{
// do not modify diagnostics config without including the storage account
// throw terminating exception since it is not possible to preserve the
// existing storage account with the configuration if it doesn't have a
// hint to what the last storage account was in the public configuration
ThrowTerminatingError(new ErrorRecord(
new Exception(Resources.ServiceExtensionCannotFindStorageAccountName),
string.Empty,
ErrorCategory.InvalidData,
null));
return;
}
else
{
// check the storage account and initialize for use
InitializeStorageContext(monitoringStorageAccountName);
}
// locate the antimalware data source node in the document
string antimalwareDataSourceXPath = string.Format(@"//*[local-name()='{0}' and @name=""{1}"" and namespace-uri()='{2}']", "DataSource", AntimalwareDataSourceName, DiagnosticsConfigXmlNamespace);
XmlNode antimalwareDataSourceNode = tmpXmlDoc.DocumentElement.SelectSingleNode(antimalwareDataSourceXPath);
if (antimalwareDataSourceNode != null)
{
XmlNode windowsEventLogNode = antimalwareDataSourceNode.ParentNode;
if (windowsEventLogNode.RemoveChild(antimalwareDataSourceNode) != null)
{
// remove the windows event log if there are no other child data sources present
// as will be required for schema validation to succeed when sending the new config
// any other data sources outside of the windows event log are left untouched
if (!windowsEventLogNode.HasChildNodes)
{
windowsEventLogNode.ParentNode.RemoveChild(windowsEventLogNode);
}
}
// now reinstall the diagnostics extension with the updated configuration
InitializeDiagnosticsSettings();
ExtensionConfigurationInput diagExtConfigInput = new ExtensionConfigurationInput
{
ProviderNameSpace = ProviderNamespace,
Type = ExtensionName,
CertificateThumbprint = CertificateThumbprint,
ThumbprintAlgorithm = ThumbprintAlgorithm,
X509Certificate = X509Certificate,
PublicConfiguration = tmpXmlDoc.OuterXml,
PrivateConfiguration = PrivateConfiguration,
Roles = new ExtensionRoleList(Role != null && Role.Any() ? Role.Select(r => new ExtensionRole(r)) : Enumerable.Repeat(new ExtensionRole(), 1))
};
AntimalwareMonitoringExtensionConfigurationInput = diagExtConfigInput;
}
else
{
// no existing antimalware data source was found needing removal
return;
}
}
}
private bool VerifyExtensionConfigDiag(ExtensionConfigurationInput resultConfig, string storage, List<string> roles, XmlDocument wadconfig = null, string thumbprint = null, string algorithm = null, X509Certificate2 cert = null)
{
try
{
string resultStorageAccount = GetInnerText(resultConfig.PublicConfiguration, "StorageAccount");
string resultWadCfg = Utilities.GetInnerXml(resultConfig.PublicConfiguration, "WadCfg");
if (string.IsNullOrWhiteSpace(resultWadCfg))
{
resultWadCfg = null;
}
string resultStorageKey = GetInnerValue(resultConfig.PrivateConfiguration, "StorageAccount", "key");
Console.WriteLine("Type: {0}, StorageAccountName:{1}, StorageKey: {2}, WadCfg: {3}, CertificateThumbprint: {4}, ThumbprintAlgorithm: {5}, X509Certificate: {6}",
resultConfig.Type, resultStorageAccount, resultStorageKey, resultWadCfg, resultConfig.CertificateThumbprint, resultConfig.ThumbprintAlgorithm, resultConfig.X509Certificate);
Assert.AreEqual("PaaSDiagnostics", resultConfig.Type, "Type is not equal!");
Assert.AreEqual(storage, resultStorageAccount);
Assert.IsTrue(Utilities.CompareWadCfg(resultWadCfg, wadconfig));
if (string.IsNullOrWhiteSpace(thumbprint))
{
Assert.IsTrue(string.IsNullOrWhiteSpace(resultConfig.CertificateThumbprint));
}
else
{
Assert.AreEqual(thumbprint, resultConfig.CertificateThumbprint, "Certificate thumbprint is not equal!");
}
if (string.IsNullOrWhiteSpace(algorithm))
{
Assert.IsTrue(string.IsNullOrWhiteSpace(resultConfig.ThumbprintAlgorithm));
}
else
{
Assert.AreEqual(algorithm, resultConfig.ThumbprintAlgorithm, "Thumbprint algorithm is not equal!");
}
Assert.AreEqual(cert, resultConfig.X509Certificate, "X509Certificate is not equal!");
if (resultConfig.Roles.Count == 1 && string.IsNullOrEmpty(resultConfig.Roles[0].RoleName))
{
Assert.IsTrue(roles.Contains(resultConfig.Roles[0].RoleType.ToString()));
}
else
{
foreach (ExtensionRole role in resultConfig.Roles)
{
Assert.IsTrue(roles.Contains(role.RoleName));
}
}
return true;
}
catch
{
return false;
}
}
