publicWagsHome
/
buildx
1
0
Fork 1
Code Issues Pull Requests Packages Projects Releases Wiki Activity

build: small readability improvements by reversal of conditions

Browse Source 
This adds some ideomatic earlier returns and loop continuations
to avoid deeply nested coditional blocks that are several lines
long.

Signed-off-by: Ilya Dmitrichenko <errordeveloper@gmail.com>
pull/1466/head
Ilya Dmitrichenko 3 years ago
parent 387cc633c7
commit 08b6d36deb
No known key found for this signature in database
GPG Key ID: E7889175A6C0CEB9
1 changed files with 150 additions and 135 deletions
Show Stats Download Patch File Download Diff File

285
build/build.go
Unescape Escape View File

@ -691,92 +691,99 @@ func BuildWithResultHandler(ctx context.Context, nodes []builder.Node, opt map[s
return nil return nil
} }
if pushNames != "" { if pushNames == "" {
progress.Write(pw, fmt.Sprintf("merging manifest list %s", pushNames), func() error { return nil
descs := make([]specs.Descriptor, 0, len(res)) }
for _, r := range res { progress.Write(pw, fmt.Sprintf("merging manifest list %s", pushNames), func() error {
s, ok := r.ExporterResponse[exptypes.ExporterImageDigestKey] descs := make([]specs.Descriptor, 0, len(res))
if ok {
descs = append(descs, specs.Descriptor{ for _, r := range res {
Digest: digest.Digest(s), s, ok := r.ExporterResponse[exptypes.ExporterImageDigestKey]
MediaType: images.MediaTypeDockerSchema2ManifestList, if ok {
Size: -1, descs = append(descs, specs.Descriptor{
}) Digest: digest.Digest(s),
} MediaType: images.MediaTypeDockerSchema2ManifestList,
Size: -1,
})
} }
if len(descs) > 0 { }
var imageopt imagetools.Opt
for _, dp := range dps {
imageopt = nodes[dp.driverIndex].ImageOpt
break
}
names := strings.Split(pushNames, ",")
if insecurePush { if len(descs) == 0 {
insecureTrue := true return nil
httpTrue := true }
nn, err := reference.ParseNormalizedNamed(names[0])
if err != nil {
return err
}
imageopt.RegistryConfig = map[string]resolver.RegistryConfig{
reference.Domain(nn): {
Insecure: &insecureTrue,
PlainHTTP: &httpTrue,
},
}
}
itpull := imagetools.New(imageopt) var imageopt imagetools.Opt
for _, dp := range dps {
imageopt = nodes[dp.driverIndex].ImageOpt
break
}
names := strings.Split(pushNames, ",")
ref, err := reference.ParseNormalizedNamed(names[0]) if insecurePush {
if err != nil { insecureTrue := true
return err httpTrue := true
} nn, err := reference.ParseNormalizedNamed(names[0])
ref = reference.TagNameOnly(ref) if err != nil {
return err
}
imageopt.RegistryConfig = map[string]resolver.RegistryConfig{
reference.Domain(nn): {
Insecure: &insecureTrue,
PlainHTTP: &httpTrue,
},
}
}
srcs := make([]*imagetools.Source, len(descs)) itpull := imagetools.New(imageopt)
for i, desc := range descs {
srcs[i] = &imagetools.Source{
Desc: desc,
Ref: ref,
}
}
dt, desc, err := itpull.Combine(ctx, srcs) ref, err := reference.ParseNormalizedNamed(names[0])
if err != nil { if err != nil {
return err return err
} }
if opt.ImageIDFile != "" { ref = reference.TagNameOnly(ref)
if err := os.WriteFile(opt.ImageIDFile, []byte(desc.Digest), 0644); err != nil {
return err
}
}
itpush := imagetools.New(imageopt) srcs := make([]*imagetools.Source, len(descs))
for i, desc := range descs {
srcs[i] = &imagetools.Source{
Desc: desc,
Ref: ref,
}
}
for _, n := range names { dt, desc, err := itpull.Combine(ctx, srcs)
nn, err := reference.ParseNormalizedNamed(n) if err != nil {
if err != nil { return err
return err }
} if opt.ImageIDFile != "" {
if err := itpush.Push(ctx, nn, desc, dt); err != nil { if err := os.WriteFile(opt.ImageIDFile, []byte(desc.Digest), 0644); err != nil {
return err return err
} }
} }
respMu.Lock() itpush := imagetools.New(imageopt)
resp[k] = &client.SolveResponse{
ExporterResponse: map[string]string{ for _, n := range names {
"containerimage.digest": desc.Digest.String(), nn, err := reference.ParseNormalizedNamed(n)
}, if err != nil {
} return err
respMu.Unlock()
} }
return nil if err := itpush.Push(ctx, nn, desc, dt); err != nil {
}) return err
} }
}
respMu.Lock()
resp[k] = &client.SolveResponse{
ExporterResponse: map[string]string{
"containerimage.digest": desc.Digest.String(),
},
}
respMu.Unlock()
return nil
})
return nil return nil
}) })
@ -866,22 +873,23 @@ func BuildWithResultHandler(ctx context.Context, nodes []builder.Node, opt map[s
return nil, err return nil, err
} }
var reqErr *errdefs.UnsupportedSubrequestError var reqErr *errdefs.UnsupportedSubrequestError
if !isFallback { if isFallback {
if errors.As(err, &reqErr) { return nil, err
switch reqErr.Name { }
case "frontend.outline", "frontend.targets": if errors.As(err, &reqErr) {
isFallback = true switch reqErr.Name {
origErr = err case "frontend.outline", "frontend.targets":
continue
}
return nil, err
}
// buildkit v0.8 vendored in Docker 20.10 does not support typed errors
if strings.Contains(err.Error(), "unsupported request frontend.outline") || strings.Contains(err.Error(), "unsupported request frontend.targets") {
isFallback = true isFallback = true
origErr = err origErr = err
continue continue
} }
return nil, err
}
// buildkit v0.8 vendored in Docker 20.10 does not support typed errors
if strings.Contains(err.Error(), "unsupported request frontend.outline") || strings.Contains(err.Error(), "unsupported request frontend.targets") {
isFallback = true
origErr = err
continue
} }
return nil, err return nil, err
} }
@ -908,40 +916,44 @@ func BuildWithResultHandler(ctx context.Context, nodes []builder.Node, opt map[s
} }
node := nodes[dp.driverIndex].Driver node := nodes[dp.driverIndex].Driver
if node.IsMobyDriver() { if !node.IsMobyDriver() {
for _, e := range so.Exports { return nil
if e.Type == "moby" && e.Attrs["push"] != "" { }
if ok, _ := strconv.ParseBool(e.Attrs["push"]); ok {
pushNames = e.Attrs["name"] for _, e := range so.Exports {
if pushNames == "" { if e.Type == "moby" && e.Attrs["push"] != "" {
return errors.Errorf("tag is needed when pushing to registry") if ok, _ := strconv.ParseBool(e.Attrs["push"]); !ok {
} continue
pw := progress.ResetTime(pw) }
pushList := strings.Split(pushNames, ",") pushNames = e.Attrs["name"]
for _, name := range pushList { if pushNames == "" {
if err := progress.Wrap(fmt.Sprintf("pushing %s with docker", name), pw.Write, func(l progress.SubLogger) error { return errors.Errorf("tag is needed when pushing to registry")
return pushWithMoby(ctx, node, name, l) }
}); err != nil { pw := progress.ResetTime(pw)
return err pushList := strings.Split(pushNames, ",")
} for _, name := range pushList {
} if err := progress.Wrap(fmt.Sprintf("pushing %s with docker", name), pw.Write, func(l progress.SubLogger) error {
remoteDigest, err := remoteDigestWithMoby(ctx, node, pushList[0]) return pushWithMoby(ctx, node, name, l)
if err == nil && remoteDigest != "" { }); err != nil {
// old daemons might not have containerimage.config.digest set return err
// in response so use containerimage.digest value for it if available }
if _, ok := rr.ExporterResponse[exptypes.ExporterImageConfigDigestKey]; !ok { }
if v, ok := rr.ExporterResponse[exptypes.ExporterImageDigestKey]; ok { remoteDigest, err := remoteDigestWithMoby(ctx, node, pushList[0])
rr.ExporterResponse[exptypes.ExporterImageConfigDigestKey] = v if err == nil && remoteDigest != "" {
} // old daemons might not have containerimage.config.digest set
} // in response so use containerimage.digest value for it if available
rr.ExporterResponse[exptypes.ExporterImageDigestKey] = remoteDigest if _, ok := rr.ExporterResponse[exptypes.ExporterImageConfigDigestKey]; !ok {
} else if err != nil { if v, ok := rr.ExporterResponse[exptypes.ExporterImageDigestKey]; ok {
return err rr.ExporterResponse[exptypes.ExporterImageConfigDigestKey] = v
} }
} }
rr.ExporterResponse[exptypes.ExporterImageDigestKey] = remoteDigest
} else if err != nil {
return err
} }
} }
} }
return nil return nil
}) })
@ -1315,27 +1327,30 @@ func waitContextDeps(ctx context.Context, index int, results *waitmap.Map, so *c
} }
delete(so.FrontendAttrs, v) delete(so.FrontendAttrs, v)
} }
if rr.Ref != nil {
st, err := rr.Ref.ToState() if rr.Ref == nil {
continue
}
st, err := rr.Ref.ToState()
if err != nil {
return err
}
so.FrontendInputs[k] = st
so.FrontendAttrs[v] = "input:" + k
metadata := make(map[string][]byte)
if dt, ok := rr.Metadata[exptypes.ExporterImageConfigKey]; ok {
metadata[exptypes.ExporterImageConfigKey] = dt
}
if dt, ok := rr.Metadata[exptypes.ExporterBuildInfo]; ok {
metadata[exptypes.ExporterBuildInfo] = dt
}
if len(metadata) > 0 {
dt, err := json.Marshal(metadata)
if err != nil { if err != nil {
return err return err
} }
so.FrontendInputs[k] = st so.FrontendAttrs["input-metadata:"+k] = string(dt)
so.FrontendAttrs[v] = "input:" + k
metadata := make(map[string][]byte)
if dt, ok := rr.Metadata[exptypes.ExporterImageConfigKey]; ok {
metadata[exptypes.ExporterImageConfigKey] = dt
}
if dt, ok := rr.Metadata[exptypes.ExporterBuildInfo]; ok {
metadata[exptypes.ExporterBuildInfo] = dt
}
if len(metadata) > 0 {
dt, err := json.Marshal(metadata)
if err != nil {
return err
}
so.FrontendAttrs["input-metadata:"+k] = string(dt)
}
} }
} }
return nil return nil

Write Preview
Loading…
Cancel
Save