public ServiceManifest(ServiceManifestType serviceManifestType)
{
this.ServiceManifestType = serviceManifestType;
this.CodePackages = new Collection <CodePackage>();
this.ConfigPackages = new Collection <ConfigPackage>();
this.DataPackages = new Collection <DataPackage>();
}
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 static ServiceManifestType ReplaceVersion(ServiceManifestType manifest, string version)
{
var replacedManifest = manifest;
manifest.Version = version;
if (manifest.CodePackage != null)
{
for (int i = 0; i < manifest.CodePackage.Count(); ++i)
{
ReplaceVersion(ref manifest.CodePackage[i], version);
}
}
if (manifest.ConfigPackage != null)
{
for (int i = 0; i < manifest.ConfigPackage.Count(); ++i)
{
ReplaceVersion(ref manifest.ConfigPackage[i], version);
}
}
if (manifest.DataPackage != null)
{
for (int i = 0; i < manifest.DataPackage.Count(); ++i)
{
ReplaceVersion(ref manifest.DataPackage[i], version);
}
}
return(manifest);
}
private EnvironmentOverridesType GetEnvironmentOverrides(
ComposeServiceTypeDescription containerServiceTypeDescription, ServiceManifestType serviceManifest)
{
var envOverrides = new EnvironmentOverridesType
{
CodePackageRef = serviceManifest.CodePackage[0].Name,
EnvironmentVariable =
new EnvironmentVariableOverrideType[containerServiceTypeDescription.EnvironmentVariables.Count]
};
var index = 0;
foreach (var environment in containerServiceTypeDescription.EnvironmentVariables)
{
var envVariableType = new EnvironmentVariableOverrideType
{
Name = environment.Key,
Value = environment.Value
};
envOverrides.EnvironmentVariable[index] = envVariableType;
++index;
}
return(envOverrides);
}
private ServiceManifestType CreateServiceManifest(
string namePrefix,
string version,
ComposeServiceTypeDescription serviceTypeDescription,
out IList <PortBindingType> portBindings)
{
var serviceManifestType = new ServiceManifestType()
{
Name = DockerComposeUtils.GetServicePackageName(namePrefix),
Version = version
};
// Service Type
serviceManifestType.ServiceTypes = new object[1];
serviceManifestType.ServiceTypes[0] = this.GetContainerServiceType(namePrefix);
// CodePackage
serviceManifestType.CodePackage = new CodePackageType[1];
serviceManifestType.CodePackage[0] = this.GetCodePackage(namePrefix, serviceTypeDescription);
var endpointResources = this.GetEndpointResources(namePrefix, serviceTypeDescription, out portBindings);
if (endpointResources.Count() > 0)
{
serviceManifestType.Resources = new ResourcesType
{
Endpoints = endpointResources.ToArray()
};
}
return(serviceManifestType);
}
public static void SaveServiceManifest(string v, ServiceManifestType srv)
{
if (File.Exists(v))
{
File.Delete(v);
}
using (var stream = new StreamWriter(v))
serviceManifestSerializer.Serialize(stream, srv);
}
public static void ModifyCodePackage(string codePackageName, ServiceManifestType serviceManifestType, BuildLayoutInfo buildLayoutInfo)
{
string codeFolderName = buildLayoutInfo.BuildLayoutSpecification.GetCodePackageFolder(
serviceManifestType.Name,
codePackageName);
buildLayoutInfo.ImageStore.UploadContent(
Path.Combine(codeFolderName, string.Format("AdditionalAssembly.dll", serviceManifestType.Name)),
Path.Combine(TestDirectory, "System.Fabric.Management.dll"),
TimeSpan.MaxValue,
CopyFlag.AtomicCopy,
false);
}
public static void SortServiceManifestType(ServiceManifestType serviceManifest)
{
serviceManifest.ServiceTypes = SortServiceTypes(serviceManifest.ServiceTypes);
serviceManifest.CodePackage = SortCodePackages(serviceManifest.CodePackage);
serviceManifest.ConfigPackage = SortConfigPackages(serviceManifest.ConfigPackage);
serviceManifest.DataPackage = SortDataPackages(serviceManifest.DataPackage);
if (serviceManifest.Resources != null)
{
serviceManifest.Resources.Endpoints = SortResourceEndpoints(serviceManifest.Resources.Endpoints);
}
SortServiceDiagnostics(serviceManifest.Diagnostics);
}
private static ServiceManifestType GenerateServiceManifest(string app, string version, string main, string argv,
int[] ports)
{
var serviceManifest = new ServiceManifestType()
{
Name = $"{app}SFServicePkg",
Version = version
};
serviceManifest.ServiceTypes = new[]
{
new StatelessServiceTypeType()
{
ServiceTypeName = $"{app}SFServiceType",
UseImplicitHost = true,
}
};
serviceManifest.CodePackage = new[]
{
new CodePackageType()
{
Name = "Code",
Version = version,
EntryPoint = new EntryPointDescriptionType()
{
Item = new EntryPointDescriptionTypeExeHost()
{
Program = main,
Arguments = argv,
WorkingFolder = ExeHostEntryPointTypeWorkingFolder.CodePackage
}
}
}
};
serviceManifest.Resources = new ResourcesType()
{
Endpoints = ports.Select((p, i) => new EndpointType()
{
Name = $"{app}Port{i}",
Port = p,
Protocol = EndpointTypeProtocol.tcp,
PortSpecified = true,
}).ToArray()
};
return(serviceManifest);
}
public void TestBuildApplicationTypeWithConflictingCodePackage_IgnoreConflict()
{
BuildLayoutInfo buildLayoutInfo = new BuildLayoutInfo(this.imageStore);
string applicationTypeName = buildLayoutInfo.CreateBuildLayout();
this.imageBuilder.BuildApplicationType(applicationTypeName, TimeSpan.MaxValue);
buildLayoutInfo.ApplicationManifestType.ApplicationTypeVersion = "2.0";
applicationTypeName = buildLayoutInfo.CreateBuildLayout();
ServiceManifestType serviceManifestType = buildLayoutInfo.ServiceManifestTypes[0];
TestUtility.ModifyCodePackage(serviceManifestType.CodePackage[0].Name, serviceManifestType, buildLayoutInfo);
this.imageBuilder.BuildApplicationType(applicationTypeName, TimeSpan.MaxValue, null, null, true);
}
private List <ResourceGovernancePolicyType> GetResourceGovernancePolicies(
ComposeServiceTypeDescription containerServiceTypeDescription,
ServiceManifestType serviceManifest)
{
List <ResourceGovernancePolicyType> resourceGovernancePolicies = new List <ResourceGovernancePolicyType>();
if (containerServiceTypeDescription.ResourceGovernance != null &&
containerServiceTypeDescription.ResourceGovernance.IsSpecified())
{
// There is a single code package in the container service type.
ResourceGovernancePolicyType resourceGovernancePolicy = new ResourceGovernancePolicyType();
var containerResourceGovernance = containerServiceTypeDescription.ResourceGovernance;
resourceGovernancePolicy.CodePackageRef = serviceManifest.CodePackage[0].Name;
if (containerResourceGovernance.LimitCpuShares.Length != 0)
{
resourceGovernancePolicy.CpuShares = containerResourceGovernance.LimitCpuShares;
}
if (containerResourceGovernance.LimitMemoryInMb.Length != 0)
{
resourceGovernancePolicy.MemoryInMB = containerResourceGovernance.LimitMemoryInMb;
}
if (containerResourceGovernance.LimitMemorySwapInMb.Length != 0)
{
resourceGovernancePolicy.MemorySwapInMB = containerResourceGovernance.LimitMemorySwapInMb;
}
if (containerResourceGovernance.ReservationMemoryInMb.Length != 0)
{
resourceGovernancePolicy.MemoryReservationInMB = containerResourceGovernance.ReservationMemoryInMb;
}
resourceGovernancePolicies.Add(resourceGovernancePolicy);
}
return(resourceGovernancePolicies);
}
private void ValidateServiceManifestDiagnostics(ServiceManifestType serviceManifestType)
{
if ((null == serviceManifestType.Diagnostics) ||
(null == serviceManifestType.Diagnostics.ETW) ||
(null == serviceManifestType.Diagnostics.ETW.ManifestDataPackages))
{
return;
}
DataPackageType[] dataPackageTypes = serviceManifestType.Diagnostics.ETW.ManifestDataPackages;
foreach (DataPackageType dataPackageType in dataPackageTypes)
{
Version version;
if (!Version.TryParse(dataPackageType.Version, out version))
{
ImageBuilderUtility.TraceAndThrowValidationError(
TraceType,
StringResources.ImageBuilderError_DiagnosticValidator_InvalidETWManifestDataPackageVersion,
dataPackageType.Version,
dataPackageType.Name,
serviceManifestType.Name);
}
}
}
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);
}
public static ServiceManifestType SetHashVersion(this ServiceManifestType srv, string baseDir, string targetDir, int maxHashLength)
{
SHA512Managed sha;
List <byte> configHash = new List <byte>();
int offset = 0;
if (srv.CodePackage != null)
{
foreach (var cv in srv.CodePackage)
{
sha = new SHA512Managed();
offset = 0;
var path = cv.Name == "Code" ? targetDir : Path.Combine(baseDir, "PackageRoot", cv.Name);
foreach (var f in Directory.GetFiles(path, "*.dll").Concat(Directory.GetFiles(path, "*.exe")))
{
var b = File.ReadAllBytes(f);
sha.TransformBlock(b, offset, b.Length, b, offset);
}
sha.TransformFinalBlock(new byte[0], offset, 0);
cv.Version += "." + Uri.EscapeDataString(Convert.ToBase64String(sha.Hash));
configHash.AddRange(sha.Hash);
}
}
if (srv.ConfigPackage != null)
{
foreach (var cv in srv.ConfigPackage)
{
sha = new SHA512Managed();
offset = 0;
foreach (var f in Directory.GetFiles(Path.Combine(baseDir, "PackageRoot", cv.Name)))
{
var b = File.ReadAllBytes(f);
sha.TransformBlock(b, offset, b.Length, b, offset);
}
sha.TransformFinalBlock(new byte[0], offset, 0);
cv.Version += "." + Uri.EscapeDataString(Convert.ToBase64String(sha.Hash));
configHash.AddRange(sha.Hash);
}
}
if (srv.DataPackage != null)
{
foreach (var cv in srv.DataPackage)
{
sha = new SHA512Managed();
offset = 0;
foreach (var f in Directory.GetFiles(Path.Combine(baseDir, "PackageRoot", cv.Name)))
{
var b = File.ReadAllBytes(f);
sha.TransformBlock(b, offset, b.Length, b, offset);
}
sha.TransformFinalBlock(new byte[0], offset, 0);
cv.Version += "." + Uri.EscapeDataString(Convert.ToBase64String(sha.Hash));
configHash.AddRange(sha.Hash);
}
}
srv.Version += "." + Uri.EscapeDataString(Convert.ToBase64String(new SHA512Managed().ComputeHash(configHash.ToArray())));
return(srv);
}
public static (string diff, DateTimeOffset date, string version) SetGitVersion(this ServiceManifestType srv, string baseVersion, string baseDir, string targetDir, bool checkPackages, IEnumerable <string> additionalPaths, int maxHashLength, bool skipHash)
{
(var latest, string latestFull, var date) = Git.GitCommit(baseDir);
var diff = skipHash ? "" : Git.GitDiff(baseDir);
var addDiff = new StringBuilder();
foreach (var item in additionalPaths)
{
(var v, var s, var d) = Git.GitCommit(item, latestFull);
if (!skipHash)
{
addDiff.Append(Git.GitDiff(item));
}
if (date < d)
{
date = d;
latest = v;
latestFull = s;
}
}
DateTimeOffset codeDate = date;
srv.Version = VersionHelper.AppendVersion(baseVersion, latest, VersionHelper.Hash(diff + addDiff, maxHashLength));
if (srv.ConfigPackage != null)
{
foreach (var cv in srv.ConfigPackage)
{
cv.Version = checkPackages ? VersionHelper.AppendVersion(baseVersion, GetPackageVersion(cv.Name, baseDir, ref date, ref latest, ref latestFull, maxHashLength)) : srv.Version;
}
}
if (srv.DataPackage != null)
{
foreach (var cv in srv.DataPackage)
{
cv.Version = checkPackages ? VersionHelper.AppendVersion(baseVersion, GetPackageVersion(cv.Name, baseDir, ref date, ref latest, ref latestFull, maxHashLength)) : srv.Version;
}
}
if (srv.CodePackage != null)
{
foreach (var cv in srv.CodePackage)
{
if (cv.Name == "Code" && checkPackages)
{
if (date > codeDate)
{
var codeFiles = Directory.GetFileSystemEntries(targetDir).Where(p => !p.EndsWith("PackageRoot")).Concat(Directory.GetFiles(Path.Combine(baseDir, "PackageRoot")));
foreach (var cf in codeFiles)
{
(var v, var s, var d) = Git.GitCommit(cf, latestFull);
if (date < d)
{
date = d;
latest = v;
latestFull = s;
}
}
cv.Version = VersionHelper.AppendVersion(baseVersion, latest + VersionHelper.Hash(string.Join("", codeFiles.Select(cf => Git.GitDiff(cf))) + addDiff, maxHashLength));
}
else
{
cv.Version = srv.Version;
}
}
else
{
cv.Version = checkPackages ? VersionHelper.AppendVersion(baseVersion, GetPackageVersion(cv.Name, baseDir, ref date, ref latest, ref latestFull, maxHashLength)) : srv.Version;
}
}
}
return(diff + addDiff, date, latest);
}
private ContainerHostPoliciesType GetContainerHostPolicy(
ComposeServiceTypeDescription containerServiceTypeDescription,
ServiceManifestType serviceManifest,
IList <PortBindingType> portBindingList)
{
var containerHostPolicy = new ContainerHostPoliciesType()
{
CodePackageRef = serviceManifest.CodePackage[0].Name,
};
if (!string.IsNullOrEmpty(containerServiceTypeDescription.Isolation))
{
containerHostPolicy.Isolation = containerServiceTypeDescription.Isolation;
}
var containerVolumeTypes = this.GetContainerVolumeTypes(containerServiceTypeDescription);
var containerNetworkTypes = this.GetContainerNetworkTypes(containerServiceTypeDescription);
var containerHostPolicies = 0;
if (this.repositoryCredentials.IsCredentialsSpecified())
{
containerHostPolicies = 1;
}
if (containerServiceTypeDescription.LoggingOptions.IsSpecified())
{
++containerHostPolicies;
}
containerHostPolicies += portBindingList.Count + containerVolumeTypes.Count + containerNetworkTypes.Count;
if (containerHostPolicies != 0)
{
containerHostPolicy.Items = new object[containerHostPolicies];
var nextIndex = 0;
if (this.repositoryCredentials.IsCredentialsSpecified())
{
var repositoryCredentialsType = new RepositoryCredentialsType()
{
AccountName = this.repositoryCredentials.RepositoryUserName,
Password = this.repositoryCredentials.RepositoryPassword,
PasswordEncrypted = this.repositoryCredentials.IsPasswordEncrypted,
PasswordEncryptedSpecified = this.repositoryCredentials.IsPasswordEncrypted
};
containerHostPolicy.Items[0] = repositoryCredentialsType;
++nextIndex;
}
if (containerServiceTypeDescription.LoggingOptions.IsSpecified())
{
var composeLoggingOptions = containerServiceTypeDescription.LoggingOptions;
var loggingOptions = new ContainerLoggingDriverType()
{
Driver = composeLoggingOptions.DriverName,
};
if (composeLoggingOptions.DriverOptions.Count != 0)
{
var driverOptions = new List <DriverOptionType>();
foreach (var item in composeLoggingOptions.DriverOptions)
{
var driverOption = new DriverOptionType()
{
Name = item.Key,
Value = item.Value
};
driverOptions.Add(driverOption);
}
loggingOptions.Items = new DriverOptionType[composeLoggingOptions.DriverOptions.Count];
driverOptions.ToArray().CopyTo(loggingOptions.Items, 0);
}
containerHostPolicy.Items[nextIndex] = loggingOptions;
++nextIndex;
}
if (portBindingList.Count != 0)
{
portBindingList.ToArray().CopyTo(containerHostPolicy.Items, nextIndex);
nextIndex += portBindingList.Count;
}
if (containerVolumeTypes.Count != 0)
{
containerVolumeTypes.ToArray().CopyTo(containerHostPolicy.Items, nextIndex);
nextIndex += containerVolumeTypes.Count;
}
if (containerNetworkTypes.Count != 0)
{
containerNetworkTypes.ToArray().CopyTo(containerHostPolicy.Items, nextIndex);
nextIndex += containerNetworkTypes.Count;
}
}
return(containerHostPolicy);
}
