private ApplicationManifestTypeServiceManifestImport GetServiceManifestImport(
ApplicationManifestType applicationManifestType,
string serviceNamePrefix,
ComposeServiceTypeDescription serviceTypeDescription,
out DefaultServicesTypeService defaultServiceEntry,
out ServiceManifestType serviceManifest)
{
IList <PortBindingType> portBindingList;
serviceManifest = this.CreateServiceManifest(
serviceNamePrefix,
applicationManifestType.ApplicationTypeVersion,
serviceTypeDescription,
out portBindingList);
var serviceManifestImport = new ApplicationManifestTypeServiceManifestImport()
{
ServiceManifestRef = new ServiceManifestRefType()
{
ServiceManifestName = serviceManifest.Name,
ServiceManifestVersion = serviceManifest.Version
},
};
// Environment variables
if (serviceTypeDescription.EnvironmentVariables.Count > 0)
{
serviceManifestImport.EnvironmentOverrides = new EnvironmentOverridesType[1];
// one codepackage
serviceManifestImport.EnvironmentOverrides[0] = this.GetEnvironmentOverrides(serviceTypeDescription,
serviceManifest);
}
var servicePackageResourceGovernance = this.GetServicePackageResourceGovernancePolicy(serviceTypeDescription);
var resourceGovernancePolicies = this.GetResourceGovernancePolicies(serviceTypeDescription, serviceManifest);
// Resource governance policy for CP, policy for SP and ContainerHost policy
serviceManifestImport.Policies = new object[resourceGovernancePolicies.Count + 2];
int index = 0;
if (resourceGovernancePolicies.Count != 0)
{
resourceGovernancePolicies.ToArray().CopyTo(serviceManifestImport.Policies, index);
index += resourceGovernancePolicies.Count;
}
// Resource governance on SP level
serviceManifestImport.Policies[index] = servicePackageResourceGovernance;
++index;
// Container Host policies
serviceManifestImport.Policies[index] = this.GetContainerHostPolicy(serviceTypeDescription, serviceManifest,
portBindingList);
defaultServiceEntry = this.GetDefaultServiceTypeEntry(serviceNamePrefix, serviceTypeDescription);
return(serviceManifestImport);
}
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);
}
}
private async Task <ServiceManifest> GetServiceManifestAsync(
ApplicationManifestTypeServiceManifestImport serviceManifestImport,
StoreLayoutSpecification storeLayoutSpecification,
TimeSpan timeout)
{
TimeoutHelper timeoutHelper = new TimeoutHelper(timeout);
string serviceManifestFile = storeLayoutSpecification.GetServiceManifestFile(
this.ApplicationTypeName,
serviceManifestImport.ServiceManifestRef.ServiceManifestName,
serviceManifestImport.ServiceManifestRef.ServiceManifestVersion);
string checksumFile = storeLayoutSpecification.GetServiceManifestChecksumFile(
this.ApplicationTypeName,
serviceManifestImport.ServiceManifestRef.ServiceManifestName,
serviceManifestImport.ServiceManifestRef.ServiceManifestVersion);
var getServiceManifestTask = this.ImageStoreWrapper.GetFromStoreAsync <ServiceManifestType>(serviceManifestFile, timeoutHelper.GetRemainingTime());
var getChecksumTask = this.ImageStoreWrapper.TryGetFromStoreAsync(checksumFile, timeoutHelper.GetRemainingTime());
await Task.WhenAll(getServiceManifestTask, getChecksumTask);
timeoutHelper.ThrowIfExpired();
ServiceManifestType serviceManifestType = getServiceManifestTask.Result;
string checksum = getChecksumTask.Result.Item1;
ServiceManifest serviceManifest = new ServiceManifest(serviceManifestType)
{
Checksum = checksum
};
List <Task <CodePackage> > codePackageTaskList = new List <Task <CodePackage> >();
TimeSpan remainingTime = timeoutHelper.GetRemainingTime();
foreach (CodePackageType codePackageType in serviceManifestType.CodePackage)
{
codePackageTaskList.Add(this.GetCodePackageAsync(codePackageType, serviceManifest, storeLayoutSpecification, remainingTime));
}
List <Task <ConfigPackage> > configPackageTaskList = new List <Task <ConfigPackage> >();
if (serviceManifestType.ConfigPackage != null)
{
foreach (ConfigPackageType configPackageType in serviceManifestType.ConfigPackage)
{
configPackageTaskList.Add(this.GetConfigPackageAsync(configPackageType, serviceManifest, storeLayoutSpecification, remainingTime));
}
}
List <Task <DataPackage> > dataPackageTaskList = new List <Task <DataPackage> >();
if (serviceManifestType.DataPackage != null)
{
foreach (DataPackageType dataPackageType in serviceManifestType.DataPackage)
{
dataPackageTaskList.Add(this.GetDataPackageAsync(dataPackageType, serviceManifest, storeLayoutSpecification, remainingTime));
}
}
List <Task> packageTasks = new List <Task>();
packageTasks.AddRange(codePackageTaskList);
packageTasks.AddRange(configPackageTaskList);
packageTasks.AddRange(dataPackageTaskList);
await Task.WhenAll(packageTasks);
codePackageTaskList.ForEach(task => serviceManifest.CodePackages.Add(task.Result));
configPackageTaskList.ForEach(task => serviceManifest.ConfigPackages.Add(task.Result));
dataPackageTaskList.ForEach(task => serviceManifest.DataPackages.Add(task.Result));
return(serviceManifest);
}