github.com/rish1988/moby@v25.0.2+incompatible/daemon/containerd/image_exporter.go (about) 1 package containerd 2 3 import ( 4 "context" 5 "fmt" 6 "io" 7 "strings" 8 9 "github.com/containerd/containerd" 10 "github.com/containerd/containerd/content" 11 cerrdefs "github.com/containerd/containerd/errdefs" 12 containerdimages "github.com/containerd/containerd/images" 13 "github.com/containerd/containerd/images/archive" 14 "github.com/containerd/containerd/leases" 15 "github.com/containerd/containerd/platforms" 16 "github.com/containerd/log" 17 "github.com/distribution/reference" 18 "github.com/docker/docker/api/types/events" 19 "github.com/docker/docker/container" 20 "github.com/docker/docker/daemon/images" 21 "github.com/docker/docker/errdefs" 22 dockerarchive "github.com/docker/docker/pkg/archive" 23 "github.com/docker/docker/pkg/streamformatter" 24 ocispec "github.com/opencontainers/image-spec/specs-go/v1" 25 "github.com/pkg/errors" 26 ) 27 28 func (i *ImageService) PerformWithBaseFS(ctx context.Context, c *container.Container, fn func(root string) error) error { 29 snapshotter := i.client.SnapshotService(c.Driver) 30 mounts, err := snapshotter.Mounts(ctx, c.ID) 31 if err != nil { 32 return err 33 } 34 path, err := i.refCountMounter.Mount(mounts, c.ID) 35 if err != nil { 36 return err 37 } 38 defer i.refCountMounter.Unmount(path) 39 40 return fn(path) 41 } 42 43 // ExportImage exports a list of images to the given output stream. The 44 // exported images are archived into a tar when written to the output 45 // stream. All images with the given tag and all versions containing 46 // the same tag are exported. names is the set of tags to export, and 47 // outStream is the writer which the images are written to. 48 // 49 // TODO(thaJeztah): produce JSON stream progress response and image events; see https://github.com/moby/moby/issues/43910 50 func (i *ImageService) ExportImage(ctx context.Context, names []string, outStream io.Writer) error { 51 platform := matchAllWithPreference(platforms.Default()) 52 opts := []archive.ExportOpt{ 53 archive.WithSkipNonDistributableBlobs(), 54 55 // This makes the exported archive also include `manifest.json` 56 // when the image is a manifest list. It is needed for backwards 57 // compatibility with Docker image format. 58 // The containerd will choose only one manifest for the `manifest.json`. 59 // Our preference is to have it point to the default platform. 60 // Example: 61 // Daemon is running on linux/arm64 62 // When we export linux/amd64 and linux/arm64, manifest.json will point to linux/arm64. 63 // When we export linux/amd64 only, manifest.json will point to linux/amd64. 64 // Note: This is only applicable if importing this archive into non-containerd Docker. 65 // Importing the same archive into containerd, will not restrict the platforms. 66 archive.WithPlatform(platform), 67 archive.WithSkipMissing(i.content), 68 } 69 70 leasesManager := i.client.LeasesService() 71 lease, err := leasesManager.Create(ctx, leases.WithRandomID()) 72 if err != nil { 73 return errdefs.System(err) 74 } 75 defer func() { 76 if err := leasesManager.Delete(ctx, lease); err != nil { 77 log.G(ctx).WithError(err).Warn("cleaning up lease") 78 } 79 }() 80 81 addLease := func(ctx context.Context, target ocispec.Descriptor) error { 82 return leaseContent(ctx, i.content, leasesManager, lease, target) 83 } 84 85 exportImage := func(ctx context.Context, target ocispec.Descriptor, ref reference.Named) error { 86 if err := addLease(ctx, target); err != nil { 87 return err 88 } 89 90 if ref != nil { 91 opts = append(opts, archive.WithManifest(target, ref.String())) 92 93 log.G(ctx).WithFields(log.Fields{ 94 "target": target, 95 "name": ref, 96 }).Debug("export image") 97 } else { 98 orgTarget := target 99 target.Annotations = make(map[string]string) 100 101 for k, v := range orgTarget.Annotations { 102 switch k { 103 case containerdimages.AnnotationImageName, ocispec.AnnotationRefName: 104 // Strip image name/tag annotations from the descriptor. 105 // Otherwise containerd will use it as name. 106 default: 107 target.Annotations[k] = v 108 } 109 } 110 111 opts = append(opts, archive.WithManifest(target)) 112 113 log.G(ctx).WithFields(log.Fields{ 114 "target": target, 115 }).Debug("export image without name") 116 } 117 118 i.LogImageEvent(target.Digest.String(), target.Digest.String(), events.ActionSave) 119 return nil 120 } 121 122 exportRepository := func(ctx context.Context, ref reference.Named) error { 123 imgs, err := i.getAllImagesWithRepository(ctx, ref) 124 if err != nil { 125 return errdefs.System(fmt.Errorf("failed to list all images from repository %s: %w", ref.Name(), err)) 126 } 127 128 if len(imgs) == 0 { 129 return images.ErrImageDoesNotExist{Ref: ref} 130 } 131 132 for _, img := range imgs { 133 ref, err := reference.ParseNamed(img.Name) 134 135 if err != nil { 136 log.G(ctx).WithFields(log.Fields{ 137 "image": img.Name, 138 "error": err, 139 }).Warn("couldn't parse image name as a valid named reference") 140 continue 141 } 142 143 if err := exportImage(ctx, img.Target, ref); err != nil { 144 return err 145 } 146 } 147 148 return nil 149 } 150 151 for _, name := range names { 152 target, resolveErr := i.resolveDescriptor(ctx, name) 153 154 // Check if the requested name is a truncated digest of the resolved descriptor. 155 // If yes, that means that the user specified a specific image ID so 156 // it's not referencing a repository. 157 specificDigestResolved := false 158 if resolveErr == nil { 159 nameWithoutDigestAlgorithm := strings.TrimPrefix(name, target.Digest.Algorithm().String()+":") 160 specificDigestResolved = strings.HasPrefix(target.Digest.Encoded(), nameWithoutDigestAlgorithm) 161 } 162 163 log.G(ctx).WithFields(log.Fields{ 164 "name": name, 165 "resolveErr": resolveErr, 166 "specificDigestResolved": specificDigestResolved, 167 }).Debug("export requested") 168 169 ref, refErr := reference.ParseNormalizedNamed(name) 170 171 if resolveErr != nil || !specificDigestResolved { 172 // Name didn't resolve to anything, or name wasn't explicitly referencing a digest 173 if refErr == nil && reference.IsNameOnly(ref) { 174 // Reference is valid, but doesn't include a specific tag. 175 // Export all images with the same repository. 176 if err := exportRepository(ctx, ref); err != nil { 177 return err 178 } 179 continue 180 } 181 } 182 183 if resolveErr != nil { 184 return resolveErr 185 } 186 if refErr != nil { 187 return refErr 188 } 189 190 // If user exports a specific digest, it shouldn't have a tag. 191 if specificDigestResolved { 192 ref = nil 193 } 194 if err := exportImage(ctx, target, ref); err != nil { 195 return err 196 } 197 } 198 199 return i.client.Export(ctx, outStream, opts...) 200 } 201 202 // leaseContent will add a resource to the lease for each child of the descriptor making sure that it and 203 // its children won't be deleted while the lease exists 204 func leaseContent(ctx context.Context, store content.Store, leasesManager leases.Manager, lease leases.Lease, desc ocispec.Descriptor) error { 205 return containerdimages.Walk(ctx, containerdimages.HandlerFunc(func(ctx context.Context, desc ocispec.Descriptor) ([]ocispec.Descriptor, error) { 206 _, err := store.Info(ctx, desc.Digest) 207 if err != nil { 208 if errors.Is(err, cerrdefs.ErrNotFound) { 209 return nil, nil 210 } 211 return nil, errdefs.System(err) 212 } 213 214 r := leases.Resource{ 215 ID: desc.Digest.String(), 216 Type: "content", 217 } 218 if err := leasesManager.AddResource(ctx, lease, r); err != nil { 219 return nil, errdefs.System(err) 220 } 221 222 return containerdimages.Children(ctx, store, desc) 223 }), desc) 224 } 225 226 // LoadImage uploads a set of images into the repository. This is the 227 // complement of ExportImage. The input stream is an uncompressed tar 228 // ball containing images and metadata. 229 func (i *ImageService) LoadImage(ctx context.Context, inTar io.ReadCloser, outStream io.Writer, quiet bool) error { 230 decompressed, err := dockerarchive.DecompressStream(inTar) 231 if err != nil { 232 return errors.Wrap(err, "failed to decompress input tar archive") 233 } 234 defer decompressed.Close() 235 236 opts := []containerd.ImportOpt{ 237 // TODO(vvoland): Allow user to pass platform 238 containerd.WithImportPlatform(platforms.All), 239 240 containerd.WithSkipMissing(), 241 242 // Create an additional image with dangling name for imported images... 243 containerd.WithDigestRef(danglingImageName), 244 // ... but only if they don't have a name or it's invalid. 245 containerd.WithSkipDigestRef(func(nameFromArchive string) bool { 246 if nameFromArchive == "" { 247 return false 248 } 249 _, err := reference.ParseNormalizedNamed(nameFromArchive) 250 return err == nil 251 }), 252 } 253 254 imgs, err := i.client.Import(ctx, decompressed, opts...) 255 if err != nil { 256 log.G(ctx).WithError(err).Debug("failed to import image to containerd") 257 return errdefs.System(err) 258 } 259 260 progress := streamformatter.NewStdoutWriter(outStream) 261 262 for _, img := range imgs { 263 name := img.Name 264 loadedMsg := "Loaded image" 265 266 if isDanglingImage(img) { 267 name = img.Target.Digest.String() 268 loadedMsg = "Loaded image ID" 269 } else if named, err := reference.ParseNormalizedNamed(img.Name); err == nil { 270 name = reference.FamiliarString(reference.TagNameOnly(named)) 271 } 272 273 err = i.walkImageManifests(ctx, img, func(platformImg *ImageManifest) error { 274 logger := log.G(ctx).WithFields(log.Fields{ 275 "image": name, 276 "manifest": platformImg.Target().Digest, 277 }) 278 279 if isPseudo, err := platformImg.IsPseudoImage(ctx); isPseudo || err != nil { 280 if err != nil { 281 logger.WithError(err).Warn("failed to read manifest") 282 } else { 283 logger.Debug("don't unpack non-image manifest") 284 } 285 return nil 286 } 287 288 unpacked, err := platformImg.IsUnpacked(ctx, i.snapshotter) 289 if err != nil { 290 logger.WithError(err).Warn("failed to check if image is unpacked") 291 return nil 292 } 293 294 if !unpacked { 295 err = platformImg.Unpack(ctx, i.snapshotter) 296 297 if err != nil { 298 return errdefs.System(err) 299 } 300 } 301 logger.WithField("alreadyUnpacked", unpacked).WithError(err).Debug("unpack") 302 return nil 303 }) 304 if err != nil { 305 return errors.Wrap(err, "failed to unpack loaded image") 306 } 307 308 fmt.Fprintf(progress, "%s: %s\n", loadedMsg, name) 309 i.LogImageEvent(img.Target.Digest.String(), img.Target.Digest.String(), events.ActionLoad) 310 } 311 312 return nil 313 }