public void ExecuteCommand()
{
ValidateParameters();
ExtensionConfigurationBuilder configBuilder = ExtensionManager.GetBuilder(Deployment.ExtensionConfiguration);
bool removed = false;
if (UninstallConfiguration && configBuilder.ExistAny(ExtensionNameSpace, ExtensionType))
{
configBuilder.RemoveAny(ExtensionNameSpace, ExtensionType);
removed = true;
}
else if (configBuilder.Exist(Role, ExtensionNameSpace, ExtensionType))
{
configBuilder.Remove(Role, ExtensionNameSpace, ExtensionType);
removed = true;
}
if (removed)
{
ChangeDeployment(configBuilder.ToConfiguration());
}
else
{
WriteWarning(string.Format(Resources.ServiceExtensionNoExistingExtensionsEnabledOnRoles, ExtensionNameSpace, ExtensionType));
}
if (UninstallConfiguration)
{
ExtensionManager.Uninstall(ExtensionNameSpace, ExtensionType, Slot);
}
}
public void ExecuteCommand()
{
ValidateParameters();
ExtensionConfigurationBuilder configBuilder = ExtensionManager.GetBuilder(Deployment.ExtensionConfiguration);
if (UninstallConfiguration && configBuilder.ExistAny(ExtensionNameSpace, ExtensionType))
{
configBuilder.RemoveAny(ExtensionNameSpace, ExtensionType);
WriteVerbose(string.Format(Resources.ServiceExtensionRemovingFromAllRoles, ExtensionType, ServiceName));
ChangeDeployment(configBuilder.ToConfiguration());
}
else if (configBuilder.Exist(Role, ExtensionNameSpace, ExtensionType))
{
configBuilder.Remove(Role, ExtensionNameSpace, ExtensionType);
if (Role == null || !Role.Any())
{
WriteVerbose(string.Format(Resources.ServiceExtensionRemovingFromAllRoles, ExtensionType, ServiceName));
}
else
{
bool defaultExists = configBuilder.ExistDefault(ExtensionNameSpace, ExtensionType);
foreach (var r in Role)
{
WriteVerbose(string.Format(Resources.ServiceExtensionRemovingFromSpecificRoles, ExtensionType, r, ServiceName));
if (defaultExists)
{
WriteVerbose(string.Format(Resources.ServiceExtensionRemovingSpecificAndApplyingDefault, ExtensionType, r));
}
}
}
ChangeDeployment(configBuilder.ToConfiguration());
}
else
{
WriteVerbose(string.Format(Resources.ServiceExtensionNoExistingExtensionsEnabledOnRoles, ExtensionNameSpace, ExtensionType));
}
if (UninstallConfiguration)
{
var allConfig = ExtensionManager.GetBuilder();
var deploymentList = (from slot in (new string[] { DeploymentSlotType.Production, DeploymentSlotType.Staging })
let d = GetDeployment(slot)
where d != null
select d).ToList();
deploymentList.ForEach(d => allConfig.Add(d.ExtensionConfiguration));
ExtensionManager.Uninstall(ExtensionNameSpace, ExtensionType, allConfig.ToConfiguration());
}
}
public void Uninstall(string nameSpace, string type, string deploymentSlot)
{
var slotList = new string[] { DeploymentSlotType.Production, DeploymentSlotType.Staging };
List <Deployment> deploymentList = new List <Deployment>();
foreach (var slot in slotList)
{
Deployment currentDeployment = null;
using (new OperationContextScope(Channel.ToContextChannel()))
{
try
{
currentDeployment = Channel.GetDeploymentBySlot(SubscriptionId, ServiceName, slot);
}
catch (Exception)
{
// Do nothing
}
}
if (currentDeployment != null)
{
deploymentList.Add(currentDeployment);
}
}
var roleList = deploymentList.First(d => d.DeploymentSlot == deploymentSlot);
Channel.ListHostedServiceExtensions(SubscriptionId, ServiceName).ForEach(e =>
{
if (e.ProviderNameSpace == nameSpace && e.Type == type)
{
bool found = deploymentList.Any(d =>
{
ExtensionConfigurationBuilder builder = GetBuilder(d.ExtensionConfiguration);
return(builder.ExistAny(e.Id));
});
if (!found)
{
Channel.DeleteHostedServiceExtension(SubscriptionId, ServiceName, e.Id);
}
}
});
}
public ExtensionConfiguration InstallExtension(ExtensionConfigurationInput context, string slot, ExtensionConfiguration extConfig)
{
ExtensionConfigurationBuilder builder = GetBuilder(extConfig);
foreach (ExtensionRole r in context.Roles)
{
var extensionIds = (from index in Enumerable.Range(0, ExtensionIdLiveCycleCount)
select GetExtensionId(r.PrefixName, 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 HostedServiceExtensionInput
{
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());
}
