コード例 #1
0
        private void ValidateConfiguration(ApplicationTypeContext context)
        {
            Dictionary <string, IEnumerable <ConfigPackage> > configurationPackageDictionary = new Dictionary <string, IEnumerable <ConfigPackage> >();

            foreach (var serviceManifest in context.ServiceManifests)
            {
                configurationPackageDictionary.Add(serviceManifest.ServiceManifestType.Name, serviceManifest.ConfigPackages);
            }

            ApplicationManifestTypeServiceManifestImport[] serviceManifestImports = context.ApplicationManifest.ServiceManifestImport;
            bool hasEncryptedParameter = false;

            foreach (KeyValuePair <string, IEnumerable <ConfigPackage> > configKeyValuePair in configurationPackageDictionary)
            {
                if (configKeyValuePair.Value != null)
                {
                    ApplicationManifestTypeServiceManifestImport matchingServiceManifestImport = serviceManifestImports.FirstOrDefault <ApplicationManifestTypeServiceManifestImport>(
                        serviceManifestImport => ImageBuilderUtility.Equals(serviceManifestImport.ServiceManifestRef.ServiceManifestName, configKeyValuePair.Key));

                    ReleaseAssert.AssertIf(
                        matchingServiceManifestImport == null,
                        "Could not find matching ServiceManifest with Name {0}",
                        configKeyValuePair.Key);

                    foreach (ConfigPackage configurationPackage in configKeyValuePair.Value)
                    {
                        ImageBuilder.TraceSource.WriteInfo(
                            TraceType,
                            "Validating the configuration. ApplicationTypeName:{0}, ServiceManifestName:{1}, ConfigPackageName:{2}",
                            context.ApplicationManifest.ApplicationTypeName,
                            matchingServiceManifestImport.ServiceManifestRef.ServiceManifestName,
                            configurationPackage.ConfigPackageType.Name);

                        if (configurationPackage.SettingsType != null && configurationPackage.SettingsType.Section != null)
                        {
                            string configPackageDirectory = context.BuildLayoutSpecification.GetConfigPackageFolder(configKeyValuePair.Key, configurationPackage.ConfigPackageType.Name);
                            string configPackageArchive   = context.BuildLayoutSpecification.GetSubPackageArchiveFile(configPackageDirectory);

                            if (!FabricDirectory.Exists(configPackageDirectory) && !FabricFile.Exists(configPackageArchive))
                            {
                                continue;
                            }

                            ConfigOverrideType matchingConfigOverride = null;
                            if (matchingServiceManifestImport.ConfigOverrides != null)
                            {
                                matchingConfigOverride = matchingServiceManifestImport.ConfigOverrides.FirstOrDefault <ConfigOverrideType>(
                                    configOverride => ImageBuilderUtility.Equals(configOverride.Name, configurationPackage.ConfigPackageType.Name));
                            }

                            string settingsFileName = context.BuildLayoutSpecification.GetSettingsFile(configPackageDirectory);

                            DuplicateDetector sectionDuplicateDetector = new DuplicateDetector("Section", "Name", settingsFileName);
                            foreach (SettingsTypeSection section in configurationPackage.SettingsType.Section)
                            {
                                sectionDuplicateDetector.Add(section.Name);

                                SettingsOverridesTypeSection matchingConfigOverrideSection = null;
                                if (matchingConfigOverride != null && matchingConfigOverride.Settings != null)
                                {
                                    matchingConfigOverrideSection = matchingConfigOverride.Settings.FirstOrDefault <SettingsOverridesTypeSection>(
                                        configOverrideSection => ImageBuilderUtility.Equals(configOverrideSection.Name, section.Name));
                                }

                                if (section.Parameter != null)
                                {
                                    DuplicateDetector settingDuplicateDetector = new DuplicateDetector("Parameter", "Name", settingsFileName);
                                    foreach (SettingsTypeSectionParameter parameter in section.Parameter)
                                    {
                                        settingDuplicateDetector.Add(parameter.Name);

                                        if (!hasEncryptedParameter)
                                        {
                                            hasEncryptedParameter = parameter.IsEncrypted;
                                        }

                                        if (parameter.MustOverride)
                                        {
                                            SettingsOverridesTypeSectionParameter matchingOverrideParameter = null;
                                            if (matchingConfigOverrideSection != null && matchingConfigOverrideSection.Parameter != null)
                                            {
                                                matchingOverrideParameter = matchingConfigOverrideSection.Parameter.FirstOrDefault <SettingsOverridesTypeSectionParameter>(
                                                    configOverrideSetting => ImageBuilderUtility.Equals(configOverrideSetting.Name, parameter.Name));
                                            }

                                            if (matchingOverrideParameter == null)
                                            {
                                                ImageBuilderUtility.TraceAndThrowValidationErrorWithFileName(
                                                    TraceType,
                                                    settingsFileName,
                                                    StringResources.ImageBuilderError_ParameterNotOverriden,
                                                    parameter.Name);
                                            }
                                        }

                                        if (!String.IsNullOrEmpty(parameter.Type))
                                        {
                                            this.VerifySourceLocation(parameter.Name, "Settings.xml", parameter.Type);
                                        }
                                    }
                                }
                            }
                        }
                    }
                }
            }

            if (hasEncryptedParameter &&
                RequireCertACLingForUsers(context.ApplicationManifest.Principals) &&
                (context.ApplicationManifest.Certificates == null || context.ApplicationManifest.Certificates.SecretsCertificate == null))
            {
                ImageBuilderUtility.TraceAndThrowValidationErrorWithFileName(
                    TraceType,
                    context.GetApplicationManifestFileName(),
                    StringResources.ImageBuilderError_EncryptedSettingsNoCertInAppManifest);
            }
        }
コード例 #2
0
        private void ValidateServiceManifests(ApplicationTypeContext context)
        {
            IEnumerable <ServiceManifestType> serviceManifestTypes = context.GetServiceManifestTypes();

            // Validates the ServiceManifest
            var duplicateServiceTypeDetector = new DuplicateDetector("ServiceType", "ServiceTypeName");

            foreach (ServiceManifestType serviceManifestType in serviceManifestTypes)
            {
                ImageBuilder.TraceSource.WriteInfo(
                    TraceType,
                    "Validating ServiceManifest. ApplicationTypeName:{0}, ServiceManifestName:{1}, ServiceManifestVersion:{2}",
                    context.ApplicationManifest.ApplicationTypeName,
                    serviceManifestType.Name,
                    serviceManifestType.Version);

                string serviceManifestFileName = context.GetServiceManifestFileName(serviceManifestType.Name);

                if (!ManifestValidatorUtility.IsValidName(serviceManifestType.Name))
                {
                    ImageBuilderUtility.TraceAndThrowValidationErrorWithFileName(
                        TraceType,
                        serviceManifestFileName,
                        StringResources.ImageBuilderError_InvalidName_arg2,
                        "ServiceManifest",
                        serviceManifestType.Name,
                        Path.DirectorySeparatorChar,
                        StringConstants.DoubleDot);
                }

                if (!ManifestValidatorUtility.IsValidVersion(serviceManifestType.Version))
                {
                    ImageBuilderUtility.TraceAndThrowValidationErrorWithFileName(
                        TraceType,
                        serviceManifestFileName,
                        StringResources.ImageBuilderError_InvalidVersion_arg2,
                        "ServiceManifestVersion",
                        serviceManifestType.Version,
                        Path.DirectorySeparatorChar,
                        StringConstants.DoubleDot);
                }

                var implicitServiceTypeCount = 0;
                var normalServiceTypeCount   = 0;
                var hasServiceGroupTypes     = false;

                foreach (object manifestServiceTypeType in serviceManifestType.ServiceTypes)
                {
                    string serviceTypeName      = null;
                    string placementConstraints = null;
                    if (manifestServiceTypeType is ServiceTypeType serviceTypeType)
                    {
                        serviceTypeName      = serviceTypeType.ServiceTypeName;
                        placementConstraints = serviceTypeType.PlacementConstraints;

                        if (IsImplicitServiceType(serviceTypeType))
                        {
                            ++implicitServiceTypeCount;
                        }
                        else
                        {
                            ++normalServiceTypeCount;
                        }
                    }
                    else
                    {
                        hasServiceGroupTypes = true;

                        ServiceGroupTypeType serviceGroupTypeType = (ServiceGroupTypeType)manifestServiceTypeType;
                        serviceTypeName      = serviceGroupTypeType.ServiceGroupTypeName;
                        placementConstraints = serviceGroupTypeType.PlacementConstraints;
                    }

                    this.ValidatePlacementConstraints(serviceManifestFileName, placementConstraints);

                    duplicateServiceTypeDetector.Add(serviceTypeName);
                }

                this.ValidateServiceTypeCombination(
                    serviceManifestFileName,
                    implicitServiceTypeCount,
                    normalServiceTypeCount,
                    hasServiceGroupTypes);

                var activatorCodePackageCount = 0;

                // Validates the CodePackage in the ServiceManifest
                var codePackageDuplicateDetector = new DuplicateDetector("CodePackage", "Name", serviceManifestFileName);
                foreach (CodePackageType codePackageType in serviceManifestType.CodePackage)
                {
                    if (!ManifestValidatorUtility.IsValidName(codePackageType.Name))
                    {
                        ImageBuilderUtility.TraceAndThrowValidationErrorWithFileName(
                            TraceType,
                            serviceManifestFileName,
                            StringResources.ImageBuilderError_InvalidName_arg2,
                            "CodePackage",
                            codePackageType.Name,
                            Path.DirectorySeparatorChar,
                            StringConstants.DoubleDot);
                    }

                    if (!ManifestValidatorUtility.IsValidVersion(codePackageType.Version))
                    {
                        ImageBuilderUtility.TraceAndThrowValidationErrorWithFileName(
                            TraceType,
                            serviceManifestFileName,
                            StringResources.ImageBuilderError_InvalidVersion_arg2,
                            "CodePackageVersion",
                            codePackageType.Version,
                            Path.DirectorySeparatorChar,
                            StringConstants.DoubleDot);
                    }

                    codePackageDuplicateDetector.Add(codePackageType.Name);

                    if (codePackageType.IsActivator)
                    {
                        if (implicitServiceTypeCount > 0)
                        {
                            ImageBuilderUtility.TraceAndThrowValidationErrorWithFileName(
                                TraceType,
                                serviceManifestFileName,
                                StringResources.ImageBuilderError_GuestAppWithActivatorCodePackage);
                        }

                        activatorCodePackageCount++;
                        if (activatorCodePackageCount > 1)
                        {
                            ImageBuilderUtility.TraceAndThrowValidationErrorWithFileName(
                                TraceType,
                                serviceManifestFileName,
                                StringResources.ImageBuilderError_MultipleActivatorCodePackage);
                        }
                    }

                    var codePackageFolderName  = context.BuildLayoutSpecification.GetCodePackageFolder(serviceManifestType.Name, codePackageType.Name);
                    var codePackageArchiveName = context.BuildLayoutSpecification.GetSubPackageArchiveFile(codePackageFolderName);

                    FileLocator fileLocator = null;
                    if (FabricFile.Exists(codePackageArchiveName))
                    {
                        fileLocator = new FileLocator(codePackageArchiveName, true);
                    }
                    else if (FabricDirectory.Exists(codePackageFolderName))
                    {
                        fileLocator = new FileLocator(codePackageFolderName, false);
                    }
                    else
                    {
                        // If the code package doesn't exist, it means it was already provisioned;
                        // validation must have passed at the time of first provisioning
                        continue;
                    }

                    if (codePackageType.SetupEntryPoint != null)
                    {
                        this.ValidateEntryPointPath(serviceManifestFileName, fileLocator, codePackageType.SetupEntryPoint.ExeHost.Program);
                    }

                    if (codePackageType.EntryPoint != null && codePackageType.EntryPoint.Item != null)
                    {
                        if (codePackageType.EntryPoint.Item is DllHostEntryPointType)
                        {
                            this.ValidateEntryPoint(serviceManifestFileName, fileLocator, (DllHostEntryPointType)codePackageType.EntryPoint.Item);
                        }
                        else if (codePackageType.EntryPoint.Item is ExeHostEntryPointType)
                        {
                            this.ValidateEntryPoint(serviceManifestFileName, fileLocator, (ExeHostEntryPointType)codePackageType.EntryPoint.Item);
                        }
                    }
                }

                // Validates the ConfigPackage in the ServiceManifest
                if (serviceManifestType.ConfigPackage != null)
                {
                    DuplicateDetector configPackageDuplicateDetector = new DuplicateDetector("ConfigPackage", "Name", serviceManifestFileName);
                    foreach (ConfigPackageType configPackageType in serviceManifestType.ConfigPackage)
                    {
                        if (!ManifestValidatorUtility.IsValidName(configPackageType.Name))
                        {
                            ImageBuilderUtility.TraceAndThrowValidationErrorWithFileName(
                                TraceType,
                                serviceManifestFileName,
                                StringResources.ImageBuilderError_InvalidName_arg2,
                                "ConfigPackage",
                                configPackageType.Name,
                                Path.DirectorySeparatorChar,
                                StringConstants.DoubleDot);
                        }

                        if (!ManifestValidatorUtility.IsValidVersion(configPackageType.Version))
                        {
                            ImageBuilderUtility.TraceAndThrowValidationErrorWithFileName(
                                TraceType,
                                serviceManifestFileName,
                                StringResources.ImageBuilderError_InvalidVersion_arg2,
                                "ConfigPackageVersion",
                                configPackageType.Version,
                                Path.DirectorySeparatorChar,
                                StringConstants.DoubleDot);
                        }

                        configPackageDuplicateDetector.Add(configPackageType.Name);
                    }
                }

                // Validates the DataPackage in the ServiceManifest
                if (serviceManifestType.DataPackage != null)
                {
                    DuplicateDetector dataPackageDuplicateDetector = new DuplicateDetector("DataPackage", "Name", serviceManifestFileName);
                    foreach (DataPackageType dataPackageType in serviceManifestType.DataPackage)
                    {
                        if (!ManifestValidatorUtility.IsValidName(dataPackageType.Name))
                        {
                            ImageBuilderUtility.TraceAndThrowValidationErrorWithFileName(
                                TraceType,
                                serviceManifestFileName,
                                StringResources.ImageBuilderError_InvalidName_arg2,
                                "DataPackage",
                                dataPackageType.Name,
                                Path.DirectorySeparatorChar,
                                StringConstants.DoubleDot);
                        }

                        if (!ManifestValidatorUtility.IsValidVersion(dataPackageType.Version))
                        {
                            ImageBuilderUtility.TraceAndThrowValidationErrorWithFileName(
                                TraceType,
                                serviceManifestFileName,
                                StringResources.ImageBuilderError_InvalidVersion_arg2,
                                "DataPackageVersion",
                                dataPackageType.Version,
                                Path.DirectorySeparatorChar,
                                StringConstants.DoubleDot);
                        }

                        dataPackageDuplicateDetector.Add(dataPackageType.Name);
                    }
                }

                // Validates the Resources in the ServiceManifest
                if (serviceManifestType.Resources != null && serviceManifestType.Resources.Endpoints != null)
                {
                    DuplicateDetector resourceNameDuplicateDetector = new DuplicateDetector("Endpoint", "Name", serviceManifestFileName);
                    foreach (var endpoint in serviceManifestType.Resources.Endpoints)
                    {
                        if (endpoint.Name.Contains(';') || endpoint.Name.Contains(','))
                        {
                            ImageBuilderUtility.TraceAndThrowValidationErrorWithFileName(
                                TraceType,
                                serviceManifestFileName,
                                StringResources.ImageBuilderError_InvalidName_arg2,
                                "EndppointResource",
                                endpoint.Name,
                                ",",
                                ";");
                        }

                        if (!string.IsNullOrEmpty(endpoint.CodePackageRef))
                        {
                            var matchingCodePackage = serviceManifestType.CodePackage.FirstOrDefault(
                                codePackageType => ImageBuilderUtility.Equals(codePackageType.Name, endpoint.CodePackageRef));

                            if (matchingCodePackage == null)
                            {
                                ImageBuilderUtility.TraceAndThrowValidationErrorWithFileName(
                                    TraceType,
                                    serviceManifestFileName,
                                    StringResources.ImageBuilderError_InvalidRefSameFile,
                                    "CodePackageRef",
                                    endpoint.CodePackageRef,
                                    "EndppointResource",
                                    endpoint.Name,
                                    "CodePackage",
                                    "ServiceManifest");
                            }
                        }

                        resourceNameDuplicateDetector.Add(endpoint.Name);
                    }
                }
            }
        }