-
Notifications
You must be signed in to change notification settings - Fork 106
/
exporter.go
158 lines (130 loc) · 4.86 KB
/
exporter.go
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
package lifecycle
import (
"encoding/json"
"fmt"
"log"
"path/filepath"
"github.com/buildpack/imgutil"
"github.com/pkg/errors"
"github.com/buildpack/lifecycle/archive"
"github.com/buildpack/lifecycle/cmd"
"github.com/buildpack/lifecycle/metadata"
)
type Exporter struct {
Buildpacks []*Buildpack
ArtifactsDir string
In []byte
Out, Err *log.Logger
UID, GID int
}
func (e *Exporter) Export(layersDir, appDir string, runImage, origImage imgutil.Image, launcher string, stack metadata.StackMetadata) error {
var err error
meta := metadata.AppImageMetadata{}
meta.RunImage.TopLayer, err = runImage.TopLayer()
if err != nil {
return errors.Wrap(err, "get run image top layer SHA")
}
meta.RunImage.SHA, err = runImage.Digest()
if err != nil {
return errors.Wrap(err, "get run image digest")
}
meta.Stack = stack
origMetadata, err := metadata.GetAppMetadata(origImage)
if err != nil {
return errors.Wrap(err, "metadata for previous image")
}
runImage.Rename(origImage.Name())
appImage := runImage
meta.App.SHA, err = e.addOrReuseLayer(appImage, &layer{path: appDir, identifier: "app"}, origMetadata.App.SHA)
if err != nil {
return errors.Wrap(err, "exporting app layer")
}
meta.Config.SHA, err = e.addOrReuseLayer(appImage, &layer{path: filepath.Join(layersDir, "config"), identifier: "config"}, origMetadata.Config.SHA)
if err != nil {
return errors.Wrap(err, "exporting config layer")
}
meta.Launcher.SHA, err = e.addOrReuseLayer(appImage, &layer{path: launcher, identifier: "launcher"}, origMetadata.Launcher.SHA)
if err != nil {
return errors.Wrap(err, "exporting launcher layer")
}
for _, bp := range e.Buildpacks {
bpDir, err := readBuildpackLayersDir(layersDir, *bp)
if err != nil {
return errors.Wrapf(err, "reading layers for buildpack '%s'", bp.ID)
}
bpMD := metadata.BuildpackMetadata{ID: bp.ID, Version: bp.Version, Layers: map[string]metadata.LayerMetadata{}}
for _, layer := range bpDir.findLayers(launch) {
lmd, err := layer.read()
if err != nil {
return errors.Wrapf(err, "reading '%s' metadata", layer.Identifier())
}
if layer.hasLocalContents() {
origLayerMetadata := origMetadata.MetadataForBuildpack(bp.ID).Layers[layer.name()]
lmd.SHA, err = e.addOrReuseLayer(appImage, &layer, origLayerMetadata.SHA)
if err != nil {
return err
}
} else {
if lmd.Cache {
return fmt.Errorf("layer '%s' is cache=true but has no contents", layer.Identifier())
}
origLayerMetadata, ok := origMetadata.MetadataForBuildpack(bp.ID).Layers[layer.name()]
if !ok {
return fmt.Errorf("cannot reuse '%s', previous image has no metadata for layer '%s'", layer.Identifier(), layer.Identifier())
}
e.Out.Printf("Reusing layer '%s' with SHA %s\n", layer.Identifier(), origLayerMetadata.SHA)
if err := appImage.ReuseLayer(origLayerMetadata.SHA); err != nil {
return errors.Wrapf(err, "reusing layer: '%s'", layer.Identifier())
}
lmd.SHA = origLayerMetadata.SHA
}
bpMD.Layers[layer.name()] = lmd
}
if malformedLayers := bpDir.findLayers(malformed); len(malformedLayers) > 0 {
ids := make([]string, 0, len(malformedLayers))
for _, ml := range malformedLayers {
ids = append(ids, ml.Identifier())
}
return fmt.Errorf("failed to parse metadata for layers '%s'", ids)
}
meta.Buildpacks = append(meta.Buildpacks, bpMD)
}
data, err := json.Marshal(meta)
if err != nil {
return errors.Wrap(err, "marshall metadata")
}
if err := appImage.SetLabel(metadata.AppMetadataLabel, string(data)); err != nil {
return errors.Wrap(err, "set app image metadata label")
}
if err := appImage.SetEnv(cmd.EnvLayersDir, layersDir); err != nil {
return errors.Wrapf(err, "set app image env %s", cmd.EnvLayersDir)
}
if err := appImage.SetEnv(cmd.EnvAppDir, appDir); err != nil {
return errors.Wrapf(err, "set app image env %s", cmd.EnvAppDir)
}
if err := appImage.SetEntrypoint(launcher); err != nil {
return errors.Wrap(err, "setting entrypoint")
}
if err := appImage.SetCmd(); err != nil { // Note: Command intentionally empty
return errors.Wrap(err, "setting cmd")
}
sha, err := appImage.Save()
if err != nil {
return errors.Wrap(err, "saving")
}
e.Out.Printf("\n*** Image: %s@%s\n", runImage.Name(), sha)
return nil
}
func (e *Exporter) addOrReuseLayer(image imgutil.Image, layer identifiableLayer, previousSha string) (string, error) {
tarPath := filepath.Join(e.ArtifactsDir, escapeIdentifier(layer.Identifier())+".tar")
sha, err := archive.WriteTarFile(layer.Path(), tarPath, e.UID, e.GID)
if err != nil {
return "", errors.Wrapf(err, "exporting layer '%s'", layer.Identifier())
}
if sha == previousSha {
e.Out.Printf("Reusing layer '%s' with SHA %s\n", layer.Identifier(), sha)
return sha, image.ReuseLayer(previousSha)
}
e.Out.Printf("Exporting layer '%s' with SHA %s\n", layer.Identifier(), sha)
return sha, image.AddLayer(tarPath)
}