public void Uninstall(string nameSpace, string type, Microsoft.WindowsAzure.Management.Compute.Models.ExtensionConfiguration extConfig)
        {
            var extBuilder = GetBuilder(extConfig);
            var extensions = Cmdlet.ComputeClient.HostedServices.ListExtensions(ServiceName).Extensions;

            if (extensions != null)
            {
                extensions.ForEach(
                    e =>
                {
                    if (CheckNameSpaceType(e, nameSpace, type) && !extBuilder.ExistAny(e.Id))
                    {
                        DeleteExtension(e.Id);
                    }
                });
            }
        }
 public ExtensionConfigurationBuilder GetBuilder(Microsoft.WindowsAzure.Management.Compute.Models.ExtensionConfiguration config)
 {
     return(new ExtensionConfigurationBuilder(this, config));
 }
        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();
        }
        protected void ChangeDeployment(ExtensionConfiguration extConfig)
        {
            DeploymentChangeConfigurationParameters changeConfigInput = new DeploymentChangeConfigurationParameters
            {
                Configuration = Deployment.Configuration,
                ExtensionConfiguration = Deployment.ExtensionConfiguration = extConfig,
                Mode = DeploymentChangeConfigurationMode.Auto,
                TreatWarningsAsError = false
            };

            ExecuteClientActionNewSM(
                null,
                CommandRuntime.ToString(),
                () => this.ComputeClient.Deployments.ChangeConfigurationBySlot(
                    ServiceName,
                    (DeploymentSlot)Enum.Parse(typeof(DeploymentSlot), Slot, true),
                    changeConfigInput));
        }
Esempio n. 5
0
        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 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);
        }
        public ExtensionConfiguration InstallExtension(ExtensionConfigurationInput context, string slot,
                                                       Microsoft.WindowsAzure.Management.Compute.Models.ExtensionConfiguration extConfig,
                                                       Microsoft.WindowsAzure.Management.Compute.Models.ExtensionConfiguration secondSlotExtConfig = null)
        {
            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 = (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 ExtensionConfigurationBuilder(ExtensionManager extensionManager, ExtensionConfiguration config)
     : this(extensionManager)
 {
     Add(config);
 }
        public ExtensionConfiguration ToConfiguration()
        {
            ExtensionConfiguration config = new ExtensionConfiguration();
            foreach (var id in allRoles)
            {
                config.AllRoles.Add(new ExtensionConfiguration.Extension
                {
                    Id = id
                });
            }

            foreach (var r in namedRoles)
            {
                if (r.Value.Any())
                {
                    var nr = new ExtensionConfiguration.NamedRole
                    {
                        RoleName = r.Key
                    };

                    foreach (var v in r.Value)
                    {
                        nr.Extensions.Add(new ExtensionConfiguration.Extension
                        {
                            Id = v
                        });
                    }

                    config.NamedRoles.Add(nr);
                }
            }

            return config;
        }
        public ExtensionConfigurationBuilder Add(ExtensionConfiguration config)
        {
            if (config != null)
            {
                if (config.AllRoles != null)
                {
                    foreach (var e in config.AllRoles)
                    {
                        AddDefault(e.Id);
                    }
                }

                if (config.NamedRoles != null)
                {
                    foreach (var r in config.NamedRoles)
                    {
                        foreach (var e in r.Extensions)
                        {
                            if (namedRoles.ContainsKey(r.RoleName))
                            {
                                namedRoles[r.RoleName].Add(e.Id);
                            }
                            else
                            {
                                namedRoles.Add(r.RoleName, new HashSet<string>(new string[] { e.Id }));
                            }
                        }
                    }
                }
            }
            return this;
        }