github.com/DaoCloud/dao@v0.0.0-20161212064103-c3dbfd13ee36/image/tarexport/save.go (about) 1 package tarexport 2 3 import ( 4 "encoding/json" 5 "fmt" 6 "io" 7 "io/ioutil" 8 "os" 9 "path/filepath" 10 "time" 11 12 "github.com/docker/distribution" 13 "github.com/docker/distribution/digest" 14 "github.com/docker/docker/image" 15 "github.com/docker/docker/image/v1" 16 "github.com/docker/docker/layer" 17 "github.com/docker/docker/pkg/archive" 18 "github.com/docker/docker/pkg/system" 19 "github.com/docker/docker/reference" 20 ) 21 22 type imageDescriptor struct { 23 refs []reference.NamedTagged 24 layers []string 25 } 26 27 type saveSession struct { 28 *tarexporter 29 outDir string 30 images map[image.ID]*imageDescriptor 31 savedLayers map[string]struct{} 32 diffIDPaths map[layer.DiffID]string // cache every diffID blob to avoid duplicates 33 } 34 35 func (l *tarexporter) Save(names []string, outStream io.Writer) error { 36 images, err := l.parseNames(names) 37 if err != nil { 38 return err 39 } 40 41 return (&saveSession{tarexporter: l, images: images}).save(outStream) 42 } 43 44 func (l *tarexporter) parseNames(names []string) (map[image.ID]*imageDescriptor, error) { 45 imgDescr := make(map[image.ID]*imageDescriptor) 46 47 addAssoc := func(id image.ID, ref reference.Named) { 48 if _, ok := imgDescr[id]; !ok { 49 imgDescr[id] = &imageDescriptor{} 50 } 51 52 if ref != nil { 53 var tagged reference.NamedTagged 54 if _, ok := ref.(reference.Canonical); ok { 55 return 56 } 57 var ok bool 58 if tagged, ok = ref.(reference.NamedTagged); !ok { 59 var err error 60 if tagged, err = reference.WithTag(ref, reference.DefaultTag); err != nil { 61 return 62 } 63 } 64 65 for _, t := range imgDescr[id].refs { 66 if tagged.String() == t.String() { 67 return 68 } 69 } 70 imgDescr[id].refs = append(imgDescr[id].refs, tagged) 71 } 72 } 73 74 for _, name := range names { 75 id, ref, err := reference.ParseIDOrReference(name) 76 if err != nil { 77 return nil, err 78 } 79 if id != "" { 80 _, err := l.is.Get(image.ID(id)) 81 if err != nil { 82 return nil, err 83 } 84 addAssoc(image.ID(id), nil) 85 continue 86 } 87 if ref.Name() == string(digest.Canonical) { 88 imgID, err := l.is.Search(name) 89 if err != nil { 90 return nil, err 91 } 92 addAssoc(imgID, nil) 93 continue 94 } 95 if reference.IsNameOnly(ref) { 96 assocs := l.rs.ReferencesByName(ref) 97 for _, assoc := range assocs { 98 addAssoc(assoc.ImageID, assoc.Ref) 99 } 100 if len(assocs) == 0 { 101 imgID, err := l.is.Search(name) 102 if err != nil { 103 return nil, err 104 } 105 addAssoc(imgID, nil) 106 } 107 continue 108 } 109 var imgID image.ID 110 if imgID, err = l.rs.Get(ref); err != nil { 111 return nil, err 112 } 113 addAssoc(imgID, ref) 114 115 } 116 return imgDescr, nil 117 } 118 119 func (s *saveSession) save(outStream io.Writer) error { 120 s.savedLayers = make(map[string]struct{}) 121 s.diffIDPaths = make(map[layer.DiffID]string) 122 123 // get image json 124 tempDir, err := ioutil.TempDir("", "docker-export-") 125 if err != nil { 126 return err 127 } 128 defer os.RemoveAll(tempDir) 129 130 s.outDir = tempDir 131 reposLegacy := make(map[string]map[string]string) 132 133 var manifest []manifestItem 134 var parentLinks []parentLink 135 136 for id, imageDescr := range s.images { 137 foreignSrcs, err := s.saveImage(id) 138 if err != nil { 139 return err 140 } 141 142 var repoTags []string 143 var layers []string 144 145 for _, ref := range imageDescr.refs { 146 if _, ok := reposLegacy[ref.Name()]; !ok { 147 reposLegacy[ref.Name()] = make(map[string]string) 148 } 149 reposLegacy[ref.Name()][ref.Tag()] = imageDescr.layers[len(imageDescr.layers)-1] 150 repoTags = append(repoTags, ref.String()) 151 } 152 153 for _, l := range imageDescr.layers { 154 layers = append(layers, filepath.Join(l, legacyLayerFileName)) 155 } 156 157 manifest = append(manifest, manifestItem{ 158 Config: digest.Digest(id).Hex() + ".json", 159 RepoTags: repoTags, 160 Layers: layers, 161 LayerSources: foreignSrcs, 162 }) 163 164 parentID, _ := s.is.GetParent(id) 165 parentLinks = append(parentLinks, parentLink{id, parentID}) 166 s.tarexporter.loggerImgEvent.LogImageEvent(id.String(), id.String(), "save") 167 } 168 169 for i, p := range validatedParentLinks(parentLinks) { 170 if p.parentID != "" { 171 manifest[i].Parent = p.parentID 172 } 173 } 174 175 if len(reposLegacy) > 0 { 176 reposFile := filepath.Join(tempDir, legacyRepositoriesFileName) 177 f, err := os.OpenFile(reposFile, os.O_RDWR|os.O_CREATE|os.O_TRUNC, 0644) 178 if err != nil { 179 f.Close() 180 return err 181 } 182 if err := json.NewEncoder(f).Encode(reposLegacy); err != nil { 183 return err 184 } 185 if err := f.Close(); err != nil { 186 return err 187 } 188 if err := system.Chtimes(reposFile, time.Unix(0, 0), time.Unix(0, 0)); err != nil { 189 return err 190 } 191 } 192 193 manifestFileName := filepath.Join(tempDir, manifestFileName) 194 f, err := os.OpenFile(manifestFileName, os.O_RDWR|os.O_CREATE|os.O_TRUNC, 0644) 195 if err != nil { 196 f.Close() 197 return err 198 } 199 if err := json.NewEncoder(f).Encode(manifest); err != nil { 200 return err 201 } 202 if err := f.Close(); err != nil { 203 return err 204 } 205 if err := system.Chtimes(manifestFileName, time.Unix(0, 0), time.Unix(0, 0)); err != nil { 206 return err 207 } 208 209 fs, err := archive.Tar(tempDir, archive.Uncompressed) 210 if err != nil { 211 return err 212 } 213 defer fs.Close() 214 215 if _, err := io.Copy(outStream, fs); err != nil { 216 return err 217 } 218 return nil 219 } 220 221 func (s *saveSession) saveImage(id image.ID) (map[layer.DiffID]distribution.Descriptor, error) { 222 img, err := s.is.Get(id) 223 if err != nil { 224 return nil, err 225 } 226 227 if len(img.RootFS.DiffIDs) == 0 { 228 return nil, fmt.Errorf("empty export - not implemented") 229 } 230 231 var parent digest.Digest 232 var layers []string 233 var foreignSrcs map[layer.DiffID]distribution.Descriptor 234 for i := range img.RootFS.DiffIDs { 235 v1Img := image.V1Image{} 236 if i == len(img.RootFS.DiffIDs)-1 { 237 v1Img = img.V1Image 238 } 239 rootFS := *img.RootFS 240 rootFS.DiffIDs = rootFS.DiffIDs[:i+1] 241 v1ID, err := v1.CreateID(v1Img, rootFS.ChainID(), parent) 242 if err != nil { 243 return nil, err 244 } 245 246 v1Img.ID = v1ID.Hex() 247 if parent != "" { 248 v1Img.Parent = parent.Hex() 249 } 250 251 src, err := s.saveLayer(rootFS.ChainID(), v1Img, img.Created) 252 if err != nil { 253 return nil, err 254 } 255 layers = append(layers, v1Img.ID) 256 parent = v1ID 257 if src.Digest != "" { 258 if foreignSrcs == nil { 259 foreignSrcs = make(map[layer.DiffID]distribution.Descriptor) 260 } 261 foreignSrcs[img.RootFS.DiffIDs[i]] = src 262 } 263 } 264 265 configFile := filepath.Join(s.outDir, digest.Digest(id).Hex()+".json") 266 if err := ioutil.WriteFile(configFile, img.RawJSON(), 0644); err != nil { 267 return nil, err 268 } 269 if err := system.Chtimes(configFile, img.Created, img.Created); err != nil { 270 return nil, err 271 } 272 273 s.images[id].layers = layers 274 return foreignSrcs, nil 275 } 276 277 func (s *saveSession) saveLayer(id layer.ChainID, legacyImg image.V1Image, createdTime time.Time) (distribution.Descriptor, error) { 278 if _, exists := s.savedLayers[legacyImg.ID]; exists { 279 return distribution.Descriptor{}, nil 280 } 281 282 outDir := filepath.Join(s.outDir, legacyImg.ID) 283 if err := os.Mkdir(outDir, 0755); err != nil { 284 return distribution.Descriptor{}, err 285 } 286 287 // todo: why is this version file here? 288 if err := ioutil.WriteFile(filepath.Join(outDir, legacyVersionFileName), []byte("1.0"), 0644); err != nil { 289 return distribution.Descriptor{}, err 290 } 291 292 imageConfig, err := json.Marshal(legacyImg) 293 if err != nil { 294 return distribution.Descriptor{}, err 295 } 296 297 if err := ioutil.WriteFile(filepath.Join(outDir, legacyConfigFileName), imageConfig, 0644); err != nil { 298 return distribution.Descriptor{}, err 299 } 300 301 // serialize filesystem 302 layerPath := filepath.Join(outDir, legacyLayerFileName) 303 l, err := s.ls.Get(id) 304 if err != nil { 305 return distribution.Descriptor{}, err 306 } 307 defer layer.ReleaseAndLog(s.ls, l) 308 309 if oldPath, exists := s.diffIDPaths[l.DiffID()]; exists { 310 relPath, err := filepath.Rel(outDir, oldPath) 311 if err != nil { 312 return distribution.Descriptor{}, err 313 } 314 os.Symlink(relPath, layerPath) 315 } else { 316 317 tarFile, err := os.Create(layerPath) 318 if err != nil { 319 return distribution.Descriptor{}, err 320 } 321 defer tarFile.Close() 322 323 arch, err := l.TarStream() 324 if err != nil { 325 return distribution.Descriptor{}, err 326 } 327 defer arch.Close() 328 329 if _, err := io.Copy(tarFile, arch); err != nil { 330 return distribution.Descriptor{}, err 331 } 332 333 for _, fname := range []string{"", legacyVersionFileName, legacyConfigFileName, legacyLayerFileName} { 334 // todo: maybe save layer created timestamp? 335 if err := system.Chtimes(filepath.Join(outDir, fname), createdTime, createdTime); err != nil { 336 return distribution.Descriptor{}, err 337 } 338 } 339 340 s.diffIDPaths[l.DiffID()] = layerPath 341 } 342 s.savedLayers[legacyImg.ID] = struct{}{} 343 344 var src distribution.Descriptor 345 if fs, ok := l.(distribution.Describable); ok { 346 src = fs.Descriptor() 347 } 348 return src, nil 349 }