/** * Retrieves the cached base image. * * @return the cached image * @throws IOException when an I/O exception occurs * @throws CacheCorruptedException if the cache is corrupted * @throws LayerPropertyNotFoundException if adding image layers fails * @throws BadContainerConfigurationFormatException if the container configuration is in a bad * format */ private Image PullBaseImageOffline() { IImageReference baseImage = buildConfiguration.GetBaseImageConfiguration().GetImage(); Maybe <ManifestAndConfig> metadata = buildConfiguration.GetBaseImageLayersCache().RetrieveMetadata(baseImage); if (!metadata.IsPresent()) { throw new IOException( "Cannot run Fib in offline mode; " + baseImage + " not found in local Fib cache"); } IManifestTemplate manifestTemplate = metadata.Get().GetManifest(); if (manifestTemplate is V21ManifestTemplate v21ManifestTemplate) { return(JsonToImageTranslator.ToImage(v21ManifestTemplate)); } ContainerConfigurationTemplate configurationTemplate = metadata.Get().GetConfig().OrElseThrow(() => new InvalidOperationException()); return(JsonToImageTranslator.ToImage( (IBuildableManifestTemplate)manifestTemplate, configurationTemplate)); }
/** * Saves a manifest and container configuration for a V2.2 or OCI image. * * @param imageReference the image reference to save the manifest and container configuration for * @param manifestTemplate the V2.2 or OCI manifest * @param containerConfigurationTemplate the container configuration * @throws IOException if an I/O exception occurs */ public async Task WriteMetadataAsync( IImageReference imageReference, IBuildableManifestTemplate manifestTemplate, ContainerConfigurationTemplate containerConfigurationTemplate) { await cacheStorageWriter.WriteMetadataAsync( imageReference, manifestTemplate, containerConfigurationTemplate).ConfigureAwait(false); }
/** * Writes a V2.1 manifest for a given image reference. * * @param imageReference the image reference to store the metadata for * @param manifestTemplate the manifest */ public async Task WriteMetadataAsync(IImageReference imageReference, V21ManifestTemplate manifestTemplate) { SystemPath imageDirectory = cacheStorageFiles.GetImageDirectory(imageReference); Files.CreateDirectories(imageDirectory); using (LockFile ignored1 = LockFile.Create(imageDirectory.Resolve("lock"))) { await WriteMetadataAsync(manifestTemplate, imageDirectory.Resolve("manifest.json")).ConfigureAwait(false); } }
public ImageDialog(EditorBindableCollapsiblePanel parent, IServerConnection conn, ISimpleSymbolDefinition ssd, IImageGraphic image) { InitializeComponent(); _ed = parent; _ssd = ssd; _image = image; _conn = conn; try { _init = true; if (_image.Item.Type == ImageType.Reference) { _imageRef = (IImageReference)_image.Item; rdResourceRef.Checked = true; } else { _imageInline = (IInlineImage)_image.Item; rdInline.Checked = true; } if (_imageRef == null) { _imageRef = ssd.CreateImageReference(string.Empty, string.Empty); } else { rdResourceRef.Checked = true; } if (_imageInline == null) { _imageInline = ssd.CreateInlineImage(new byte[0]); } else { rdInline.Checked = true; } txtResourceId.Text = _imageRef.ResourceId; txtResData.Text = _imageRef.LibraryItemName; txtImageBase64.Text = Convert.ToBase64String(_imageInline.Content); txtImageBase64.Tag = _imageInline.Content; imageType_CheckedChanged(this, null); } finally { _init = false; } }
/** * Gets the directory corresponding to the given image reference. * * @param imageReference the image reference * @return a path in the form of {@code * (fib-cache)/images/registry[!port]/repository!(tag|digest-type!digest)} */ public SystemPath GetImageDirectory(IImageReference imageReference) { imageReference = imageReference ?? throw new ArgumentNullException(nameof(imageReference)); // Replace ':' and '@' with '!' to avoid directory-naming restrictions string replacedReference = imageReference.ToStringWithTag().Replace(':', '!').Replace('@', '!'); // Split image reference on '/' to build directory structure IEnumerable <string> directories = Splitter.On('/').Split(replacedReference); SystemPath destination = GetImagesDirectory(); foreach (string dir in directories) { destination = destination.Resolve(dir); } return(destination); }
public ImageDialog(EditorBindableCollapsiblePanel parent, IResourceService resSvc, ISimpleSymbolDefinition ssd, IImageGraphic image) { InitializeComponent(); _ed = parent; _ssd = ssd; _image = image; _resSvc = resSvc; try { _init = true; if (_image.Item.Type == ImageType.Reference) { _imageRef = (IImageReference)_image.Item; rdResourceRef.Checked = true; } else { _imageInline = (IInlineImage)_image.Item; rdInline.Checked = true; } if (_imageRef == null) _imageRef = ssd.CreateImageReference("", ""); else rdResourceRef.Checked = true; if (_imageInline == null) _imageInline = ssd.CreateInlineImage(new byte[0]); else rdInline.Checked = true; txtResourceId.Text = _imageRef.ResourceId; txtResData.Text = _imageRef.LibraryItemName; txtImageBase64.Text = Convert.ToBase64String(_imageInline.Content); txtImageBase64.Tag = _imageInline.Content; imageType_CheckedChanged(this, null); } finally { _init = false; } }
/** * Saves the manifest and container configuration for a V2.2 or OCI image. * * @param imageReference the image reference to store the metadata for * @param manifestTemplate the manifest * @param containerConfiguration the container configuration */ public async Task WriteMetadataAsync( IImageReference imageReference, IBuildableManifestTemplate manifestTemplate, ContainerConfigurationTemplate containerConfiguration) { manifestTemplate = manifestTemplate ?? throw new ArgumentNullException(nameof(manifestTemplate)); Preconditions.CheckNotNull(manifestTemplate.GetContainerConfiguration()); Preconditions.CheckNotNull(manifestTemplate.GetContainerConfiguration().Digest); SystemPath imageDirectory = cacheStorageFiles.GetImageDirectory(imageReference); Files.CreateDirectories(imageDirectory); using (LockFile ignored1 = LockFile.Create(imageDirectory.Resolve("lock"))) { await WriteMetadataAsync(manifestTemplate, imageDirectory.Resolve("manifest.json")).ConfigureAwait(false); await WriteMetadataAsync(containerConfiguration, imageDirectory.Resolve("config.json")).ConfigureAwait(false); } }
/** * Tags the image referenced by {@code originalImageReference} with a new image reference {@code * newImageReference}. * * @param originalImageReference the existing image reference on the Docker daemon * @param newImageReference the new image reference * @see <a * href="https://docs.docker.com/engine/reference/commandline/tag/">https://docs.docker.com/engine/reference/commandline/tag/</a> * @throws InterruptedException if the 'docker tag' process is interrupted. * @throws IOException if an I/O exception occurs or {@code docker tag} failed */ public async Task TagAsync(IImageReference originalImageReference, ImageReference newImageReference) { originalImageReference = originalImageReference ?? throw new ArgumentNullException(nameof(originalImageReference)); newImageReference = newImageReference ?? throw new ArgumentNullException(nameof(newImageReference)); // Runs 'docker tag'. IProcess dockerProcess = Docker("tag", originalImageReference.ToString(), newImageReference.ToString()); if (dockerProcess.WaitFor() != 0) { using (StreamReader stderr = new StreamReader(dockerProcess.GetErrorStream(), Encoding.UTF8)) { string errorMessage = await stderr.ReadToEndAsync().ConfigureAwait(false); throw new IOException( "'docker tag' command failed with error: " + errorMessage); } } }
public async Task <BuildResult> CallAsync() { await pullAndCacheBaseImageLayersStep.GetFuture().ConfigureAwait(false); await buildAndCacheApplicationLayersStep.GetFuture().ConfigureAwait(false); await buildImageStep.GetFuture().ConfigureAwait(false); buildConfiguration .GetEventHandlers() .Dispatch(LogEvent.Progress(Resources.LoadDockerStepDescription)); using (progressEventDispatcherFactory.Create(Resources.LoadDockerStepDescription, 1)) { Image image = await buildImageStep.GetFuture().ConfigureAwait(false); IImageReference targetImageReference = buildConfiguration.GetTargetImageConfiguration().GetImage(); // Load the image to docker daemon. buildConfiguration .GetEventHandlers() .Dispatch( LogEvent.Debug(await dockerClient.LoadAsync(new ImageTarball(image, targetImageReference)).ConfigureAwait(false))); // Tags the image with all the additional tags, skipping the one 'docker load' already loaded. foreach (string tag in buildConfiguration.GetAllTargetImageTags()) { if (tag.Equals(targetImageReference.GetTag(), StringComparison.Ordinal)) { continue; } ImageReference taggedImageReference = targetImageReference.WithTag(tag); await dockerClient.TagAsync(targetImageReference, taggedImageReference).ConfigureAwait(false); } return(await BuildResult.FromImageAsync(image, buildConfiguration.GetTargetFormat()).ConfigureAwait(false)); } }
/** * Retrieves the cached manifest and container configuration for an image reference. * * @param imageReference the image reference * @return the manifest and container configuration for the image reference, if found * @throws IOException if an I/O exception occurs * @throws CacheCorruptedException if the cache is corrupted */ public Maybe <ManifestAndConfig> RetrieveMetadata(IImageReference imageReference) { return(cacheStorageReader.RetrieveMetadata(imageReference)); }
/** * Retrieves the cached manifest and container configuration for an image reference. * * @param imageReference the image reference * @return the manifest and container configuration for the image reference, if found * @throws IOException if an I/O exception occurs * @throws CacheCorruptedException if the cache is corrupted */ public Maybe <ManifestAndConfig> RetrieveMetadata(IImageReference imageReference) { SystemPath imageDirectory = cacheStorageFiles.GetImageDirectory(imageReference); SystemPath manifestPath = imageDirectory.Resolve("manifest.json"); if (!Files.Exists(manifestPath)) { return(Maybe.Empty <ManifestAndConfig>()); } // TODO: Consolidate with ManifestPuller JToken token; using (JsonTextReader reader = new JsonTextReader(File.OpenText(manifestPath))) { token = JToken.ReadFrom(reader); } if (!(token is JObject node)) { throw new CacheCorruptedException( cacheStorageFiles.GetCacheDirectory(), Resources.CacheStorageReaderNotJsonExecpetionMessage); } if (!node.ContainsKey("schemaVersion")) { throw new CacheCorruptedException( cacheStorageFiles.GetCacheDirectory(), Resources.CacheStorageReaderSchemaVersionMissingExecpetionMessage); } int schemaVersion = node["schemaVersion"].Value <int>(); if (schemaVersion == -1) { throw new CacheCorruptedException( cacheStorageFiles.GetCacheDirectory(), Resources.CacheStorageReaderInvalidSchemaVersionExecpetionMessageFormat); } if (schemaVersion == 1) { return(Maybe.Of( new ManifestAndConfig( JsonTemplateMapper.ReadJsonFromFile <V21ManifestTemplate>(manifestPath), null))); } if (schemaVersion == 2) { // 'schemaVersion' of 2 can be either Docker V2.2 or OCI. string mediaType = node["mediaType"].Value <string>(); IManifestTemplate manifestTemplate; if (V22ManifestTemplate.ManifestMediaType == mediaType) { manifestTemplate = JsonTemplateMapper.ReadJsonFromFile <V22ManifestTemplate>(manifestPath); } else if (OCIManifestTemplate.ManifestMediaType == mediaType) { manifestTemplate = JsonTemplateMapper.ReadJsonFromFile <OCIManifestTemplate>(manifestPath); } else { throw new CacheCorruptedException( cacheStorageFiles.GetCacheDirectory(), string.Format( CultureInfo.CurrentCulture, Resources.CacheStorageReaderUnknownMediaTypeExecpetionMessageFormat, mediaType)); } SystemPath configPath = imageDirectory.Resolve("config.json"); if (!Files.Exists(configPath)) { throw new CacheCorruptedException( cacheStorageFiles.GetCacheDirectory(), Resources.CacheStorageReaderContainerConfigurationMissingExecpetionMessage); } ContainerConfigurationTemplate config = JsonTemplateMapper.ReadJsonFromFile <ContainerConfigurationTemplate>(configPath); return(Maybe.Of(new ManifestAndConfig(manifestTemplate, config))); } throw new CacheCorruptedException( cacheStorageFiles.GetCacheDirectory(), string.Format( CultureInfo.CurrentCulture, Resources.CacheStorageReaderInvalidSchemaVersionExecpetionMessageFormat, schemaVersion)); }
/// <summary> /// Validates the simple symbol definition. /// </summary> /// <param name="ssym">The ssym.</param> /// <param name="context">The context.</param> /// <returns></returns> protected IEnumerable <ValidationIssue> ValidateSimpleSymbolDefinition(ISimpleSymbolDefinition ssym, ResourceValidationContext context) { //Check that one geometry usage context has been specified if (ssym.AreaUsage == null && ssym.LineUsage == null && ssym.PointUsage == null) { yield return(new ValidationIssue(ssym, ValidationStatus.Error, ValidationStatusCode.Error_SymbolDefinition_NoGeometryUsageContexts, Strings.SSDF_NoGeometryUsageContext)); } //Validate image graphics foreach (var graphic in ssym.Graphics) { if (graphic.Type == GraphicElementType.Image) { IImageGraphic image = (IImageGraphic)graphic; if (image.Item != null) { if (image.Item.Type == ImageType.Reference) { IImageReference imgRef = (IImageReference)image.Item; if (!context.ResourceExists(imgRef.ResourceId)) { yield return(new ValidationIssue(ssym, ValidationStatus.Error, ValidationStatusCode.Error_SymbolDefinition_ImageGraphicReferenceResourceIdNotFound, Strings.SSDF_ImageGraphicReferenceResourceIdNotFound)); } else { var res = context.GetResource(imgRef.ResourceId); var resData = this.Connection.ResourceService.EnumerateResourceData(res.ResourceID); bool found = false; foreach (var item in resData.ResourceData) { if (item.Name == imgRef.LibraryItemName) { found = true; } } if (!found) { yield return(new ValidationIssue(ssym, ValidationStatus.Error, ValidationStatusCode.Error_SymbolDefinition_ImageGraphicReferenceResourceDataNotFound, string.Format(Strings.SSDF_ImageGraphicReferenceResourceDataNotFound, imgRef.ResourceId, imgRef.LibraryItemName))); } } } else //inline { //TODO: Validate inline image content } } } } string xml = ObjectFactory.SerializeAsString(ssym); //Check non existent symbol parameters foreach (var paramDef in ssym.ParameterDefinition.Parameter) { string name = "%" + paramDef.Identifier + "%"; //NOXLATE if (!xml.Contains(name) && string.IsNullOrEmpty(paramDef.DefaultValue)) { yield return(new ValidationIssue(ssym, ValidationStatus.Warning, ValidationStatusCode.Warning_SymbolDefinition_SymbolParameterNotUsed, string.Format(Strings.SSDF_SymbolParameterNotUsed, paramDef.Identifier))); } } //TODO: Do the reverse check. Placeholders not pointing to a symbol parameter }
/** * Saves a V2.1 image manifest. * * @param imageReference the image reference to save the manifest and container configuration for * @param manifestTemplate the V2.1 manifest * @throws IOException if an I/O exception occurs */ public async Task WriteMetadataAsync(IImageReference imageReference, V21ManifestTemplate manifestTemplate) { await cacheStorageWriter.WriteMetadataAsync(imageReference, manifestTemplate).ConfigureAwait(false); }
/** * Instantiate with an {@link Image}. * * @param image the image to convert into a tarball * @param imageReference image reference to set in the manifest */ public ImageTarball(Image image, IImageReference imageReference) { this.image = image; this.imageReference = imageReference; }
private ImageConfiguration( IImageReference image, ImmutableArray <CredentialRetriever> credentialRetrievers) { this.image = image; this.credentialRetrievers = credentialRetrievers; }
/** * Constructs a builder for an {@link ImageConfiguration}. * * @param imageReference the image reference, which is a required field * @return the builder */ public static Builder CreateBuilder(IImageReference imageReference) { return(new Builder(imageReference)); }
public Builder(IImageReference imageReference) { this.imageReference = imageReference; }