Beispiel #1
0
 private void LoadSettingsFromClusterSettings(ClusterSettings clusterSettings)
 {
     foreach (var setting in clusterSettings.Settings)
     {
         if (setting.Name == FabricValidatorConstants.SectionNames.UnreliableTransport)
         {
             foreach (var parameter in setting.Parameter)
             {
                 UnreliableTransportSpecification specification = new UnreliableTransportSpecification();
                 if (!parameter.Name.Contains('=') && ParseSpecificationFromClusterSettings(parameter.Name, parameter.Value, ref specification) != Constants.ErrorCode_Failure)
                 {
                     Specification.Add(specification);
                 }
                 else
                 {
                     DeployerTrace.WriteWarning("Skipping malformed UnreliableTransport line in ClusterManifest File, value = [name = {0} value = {1}]", parameter.Name, parameter.Value);
                 }
             }
         }
     }
 }
        private void UpdateClusterSettings(ClusterSettings clusterSettingsNoUnreliableTransport)
        {
            var fabricHostSetting = clusterSettingsNoUnreliableTransport.Settings.FirstOrDefault(
                setting =>
                setting.Name.Equals(FabricValidatorConstants.SectionNames.FabricHost, StringComparison.OrdinalIgnoreCase));

            if (fabricHostSetting == null)
            {
                return;
            }

            var autoFabricUpdateParameterValue = fabricHostSetting.Parameter.FirstOrDefault(
                param =>
                param.Name.Equals(FabricValidatorConstants.ParameterNames.EnableServiceFabricAutomaticUpdates, StringComparison.OrdinalIgnoreCase) &&
                param.Value.Equals("true", StringComparison.OrdinalIgnoreCase));

            var autoFabricBaseUpgradeParameterValue = fabricHostSetting.Parameter.FirstOrDefault(
                param =>
                param.Name.Equals(FabricValidatorConstants.ParameterNames.EnableServiceFabricBaseUpgrade, StringComparison.OrdinalIgnoreCase) &&
                param.Value.Equals("true", StringComparison.OrdinalIgnoreCase));

            var restartManagementParameterValue = fabricHostSetting.Parameter.FirstOrDefault(
                param =>
                param.Name.Equals(FabricValidatorConstants.ParameterNames.EnableRestartManagement, StringComparison.OrdinalIgnoreCase) &&
                param.Value.Equals("true", StringComparison.OrdinalIgnoreCase));

            if (autoFabricUpdateParameterValue == null &&
                autoFabricBaseUpgradeParameterValue == null &&
                restartManagementParameterValue == null)
            {
                return;
            }

            string targetReplicaSetSize = this.infrastructure.InfrastructureNodes.Count() < 3 ? "1" : "3";
            string minReplicaSetSize    = this.infrastructure.InfrastructureNodes.Count() < 3 ? "1" : "2";
            var    targetSetSizeSetting = new SettingsTypeSectionParameter()
            {
                Name  = FabricValidatorConstants.ParameterNames.TargetReplicaSetSize,
                Value = targetReplicaSetSize
            };

            var minSetSizeSetting = new SettingsTypeSectionParameter()
            {
                Name  = FabricValidatorConstants.ParameterNames.MinReplicaSetSize,
                Value = minReplicaSetSize
            };

            if (autoFabricBaseUpgradeParameterValue != null || autoFabricUpdateParameterValue != null)
            {
                List <SettingsTypeSectionParameter> parameters = new List <SettingsTypeSectionParameter>
                {
                    targetSetSizeSetting,
                    minSetSizeSetting,
                    new SettingsTypeSectionParameter()
                    {
                        Name  = FabricValidatorConstants.ParameterNames.CoordinatorType,
                        Value = FabricValidatorConstants.WindowsUpdateServiceCoordinatorType
                    }
                };

                if (autoFabricBaseUpgradeParameterValue != null &&
                    autoFabricUpdateParameterValue == null)
                {
                    parameters.Add(
                        new SettingsTypeSectionParameter()
                    {
                        Name  = FabricValidatorConstants.ParameterNames.OnlyBaseUpgrade,
                        Value = "true"
                    });
                }

                clusterSettingsNoUnreliableTransport.Settings.Add(
                    new SettingsTypeSection()
                {
                    Name      = FabricValidatorConstants.SectionNames.UpgradeService,
                    Parameter = parameters.ToArray()
                });
            }

            if (restartManagementParameterValue != null)
            {
                clusterSettingsNoUnreliableTransport.Settings.Add(
                    new SettingsTypeSection()
                {
                    Name      = FabricValidatorConstants.SectionNames.RepairManager,
                    Parameter = new SettingsTypeSectionParameter[]
                    {
                        targetSetSizeSetting,
                        minSetSizeSetting,
                    }
                });

                clusterSettingsNoUnreliableTransport.Settings.Add(
                    new SettingsTypeSection()
                {
                    Name      = FabricValidatorConstants.SectionNames.InfrastructureService,
                    Parameter = new SettingsTypeSectionParameter[]
                    {
                        targetSetSizeSetting,
                        minSetSizeSetting,
                        new SettingsTypeSectionParameter()
                        {
                            Name  = FabricValidatorConstants.ParameterNames.CoordinatorType,
                            Value = FabricValidatorConstants.ServerRestartCoordinatorType
                        }
                    }
                });
            }
        }
        protected override void OnExecuteOperation(DeploymentParameters parameters, ClusterManifestType clusterManifest, Infrastructure infrastructure)
        {
            this.manifest        = clusterManifest;
            this.infrastructure  = infrastructure;
            this.parameters      = parameters;
            this.fabricValidator = new FabricValidatorWrapper(parameters, manifest, infrastructure);
            fabricValidator.ValidateAndEnsureDefaultImageStore();
            this.nodeSettings = GetNodeSettings();

            // creating a ClusterSettings without Unreliable Transport settings
            var clusterSettingsNoUnreliableTransport = new ClusterSettings(this.manifest.FabricSettings, GetVotes(), GetSeedNodes(), manifest.Certificates != null ? this.manifest.Certificates.SecretsCertificate : null);

            clusterSettingsNoUnreliableTransport.Settings.RemoveAll(x => x.Name == FabricValidatorConstants.SectionNames.UnreliableTransport);

            var clusterSettings = new ClusterSettings(this.manifest.FabricSettings, GetVotes(), GetSeedNodes(), manifest.Certificates != null ? this.manifest.Certificates.SecretsCertificate : null);

            this.UpdateClusterSettings(clusterSettingsNoUnreliableTransport);
            var fabricHostSettings  = InitializeFabricHostSettings(clusterSettingsNoUnreliableTransport, nodeSettings);
            var servicesToBeEnabled = GetServicesToBeEnabled();

            for (int i = 0; i < nodeSettings.Count; i++)
            {
                NodeSettings   nodeSetting          = nodeSettings[i];
                List <string>  servicesToBeDeployed = GetServicesToBeDeployed(i);
                DeploymentNode node = new DeploymentNode(nodeSetting, clusterSettings, infrastructure, servicesToBeDeployed.ToArray(), servicesToBeEnabled.ToArray(), this.manifest);
                if (string.IsNullOrEmpty(parameters.NodeName) || parameters.NodeName.Equals(nodeSetting.NodeName, StringComparison.OrdinalIgnoreCase))
                {
                    if (parameters.Operation == DeploymentOperations.Update || parameters.Operation == DeploymentOperations.UpdateInstanceId)
                    {
                        node.UpgradeDeployment();
                    }
                    else if (parameters.Operation == DeploymentOperations.Create)
                    {
                        node.CreateDeployment();  //update infrastructure manifest
                    }
                }

                //  Gateway service activation is managed by Fabric.exe, and so its settings shouldn't be written to FabricHostSettings.xml
                fabricHostSettings.AddRange(node.GetHostedServices().FindAll(
                                                delegate(SettingsTypeSection section)
                {
                    string hostedServiceName = string.Format(
                        CultureInfo.InvariantCulture,
                        Constants.SectionNames.HostSettingsSectionPattern,
                        nodeSetting.NodeName,
                        Constants.HttpGatewayService);

                    return(section.Name != hostedServiceName);
                }));
            }

            WriteFabricHostSettingsFile(parameters.DeploymentSpecification.GetDataRoot(), new SettingsType()
            {
                Section = fabricHostSettings.ToArray()
            }, parameters.MachineName);

            var currentType = this as CreateorUpdateOperation;

            if (currentType != null)
            {
                base.OnExecuteOperation(parameters, clusterManifest, infrastructure);
            }
        }
Beispiel #4
0
 public UnreliableTransportSettings(ClusterSettings clusterSettings)
 {
     Specification = new List <UnreliableTransportSpecification>();
     LoadSettingsFromClusterSettings(clusterSettings);
 }