Tinkerbell.Sandbox/cmd/getbinariesfromquay/main.go

139 lines
3.4 KiB
Go
Raw Normal View History

package main
import (
"context"
"encoding/json"
"flag"
"fmt"
"io/ioutil"
"log"
"os"
"path"
"github.com/containers/image/manifest"
"github.com/containers/image/v5/types"
"github.com/tinkerbell/sandbox/cmd/getbinariesfromquay/docker"
"github.com/tinkerbell/sandbox/cmd/getbinariesfromquay/tar"
)
type Config struct {
ProgramName string
OutDirectory string
Image string
Binary string
}
var config = Config{}
func init() {
flag.StringVar(&config.ProgramName, "program", "hegel", "The name of the program you are extracing binaries for. (eg tink-worker, hegel, tink-server, tink, boots)")
flag.StringVar(&config.OutDirectory, "out", "./out", "The directory that will be used to store the release binaries")
flag.StringVar(&config.Image, "image", "docker://quay.io/tinkerbell/hegel", "The image you want to download binaries from. It has to be a multi stage image.")
flag.StringVar(&config.Binary, "binary-to-copy", "/usr/bin/hegel", "The location of the binary you want to copy from inside the image.")
}
func main() {
flag.Parse()
println("Extracing binary: " + config.Binary)
println("From Image: " + config.Image)
imageR := config.Image
binaryToCopy := config.Binary
baseDir, err := os.Getwd()
if err != nil {
log.Fatal(err)
}
programName := config.ProgramName
outDir := path.Join(baseDir, config.OutDirectory)
releaseDir := path.Join(outDir, "release")
err = os.MkdirAll(releaseDir, 0755)
if err != nil {
log.Fatal(err)
}
println("Binaries will be located in: " + releaseDir)
imgsDir := path.Join(outDir, "imgs")
err = os.MkdirAll(imgsDir, 0755)
if err != nil {
log.Fatal(err)
}
ctx := context.Background()
img, err := docker.ImageFromName(ctx, &types.SystemContext{}, imageR)
if err != nil {
log.Fatal(err)
}
rawManifest, mt, err := img.GetManifest(ctx)
if err != nil {
log.Fatal(err)
}
if mt != manifest.DockerV2ListMediaType {
log.Fatal("manifest not supported, it is not a multi arch image")
}
archList := docker.SchemaV2List{}
err = json.Unmarshal(rawManifest, &archList)
if err != nil {
log.Fatal(err)
}
for _, arch := range archList.Manifests {
imgDir := fmt.Sprintf("%s-%s-%s", programName, arch.Platform.Os, arch.Platform.Architecture)
println("Extracting ", imgDir)
syss := &types.SystemContext{
ArchitectureChoice: arch.Platform.Architecture,
OSChoice: arch.Platform.Os,
}
if arch.Platform.Variant != "" {
syss.VariantChoice = arch.Platform.Variant
imgDir = imgDir + arch.Platform.Variant
}
archImg, err := docker.ImageFromName(ctx, syss, imageR)
if err != nil {
log.Fatal(err)
}
err = archImg.Copy(ctx, fmt.Sprintf("dir:%s", path.Join(imgsDir, imgDir)))
if err != nil {
log.Fatal(err)
}
err = untarLayers(path.Join(imgsDir, imgDir), path.Join(releaseDir, imgDir), binaryToCopy)
if err != nil {
log.Fatal(err)
}
}
}
func untarLayers(src, dest, binaryPath string) error {
b, err := ioutil.ReadFile(path.Join(src, "manifest.json"))
if err != nil {
return err
}
man, err := manifest.FromBlob(b, manifest.DockerV2Schema2MediaType)
if err != nil {
return err
}
for _, l := range man.LayerInfos() {
layerTar, err := os.Open(path.Join(src, l.Digest.String()[7:]))
if err != nil {
return err
}
err = tar.Untar(src, layerTar)
if err != nil {
return err
}
}
input, err := ioutil.ReadFile(path.Join(src, binaryPath))
if err != nil {
return err
}
err = ioutil.WriteFile(dest, input, 0755)
if err != nil {
return err
}
return nil
}