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); }