Implement missing arguments for podman build

Buildah bud passes a bunch more flags then podman build.

We need to implement hook up all of these flags to get full functionality.

Signed-off-by: Daniel J Walsh <dwalsh@redhat.com>

2 files changed, 230 insertions, 107 deletions

diff --git a/pkg/api/handlers/compat/images_build.go b/pkg/api/handlers/compat/images_build.go
index 415ff85cd..0f27a090f 100644
--- a/pkg/api/handlers/compat/images_build.go
+++ b/pkg/api/handlers/compat/images_build.go
@@ -60,29 +60,39 @@ func BuildImage(w http.ResponseWriter, r *http.Request) {
 	}()
 
 	query := struct {
-		BuildArgs   string   `schema:"buildargs"`
-		CacheFrom   string   `schema:"cachefrom"`
-		CpuPeriod   uint64   `schema:"cpuperiod"`  // nolint
-		CpuQuota    int64    `schema:"cpuquota"`   // nolint
-		CpuSetCpus  string   `schema:"cpusetcpus"` // nolint
-		CpuShares   uint64   `schema:"cpushares"`  // nolint
-		Dockerfile  string   `schema:"dockerfile"`
-		ExtraHosts  string   `schema:"extrahosts"`
-		ForceRm     bool     `schema:"forcerm"`
-		HTTPProxy   bool     `schema:"httpproxy"`
-		Labels      string   `schema:"labels"`
-		Layers      bool     `schema:"layers"`
-		MemSwap     int64    `schema:"memswap"`
-		Memory      int64    `schema:"memory"`
-		NetworkMode string   `schema:"networkmode"`
-		NoCache     bool     `schema:"nocache"`
-		Outputs     string   `schema:"outputs"`
-		Platform    string   `schema:"platform"`
-		Pull        bool     `schema:"pull"`
-		Quiet       bool     `schema:"q"`
-		Registry    string   `schema:"registry"`
-		Remote      string   `schema:"remote"`
-		Rm          bool     `schema:"rm"`
+		AddHosts               string `schema:"extrahosts"`
+		AdditionalCapabilities string `schema:"addcaps"`
+		Annotations            string `schema:"annotations"`
+		BuildArgs              string `schema:"buildargs"`
+		CacheFrom              string `schema:"cachefrom"`
+		ConfigureNetwork       int64  `schema:"networkmode"`
+		CpuPeriod              uint64 `schema:"cpuperiod"`  // nolint
+		CpuQuota               int64  `schema:"cpuquota"`   // nolint
+		CpuSetCpus             string `schema:"cpusetcpus"` // nolint
+		CpuShares              uint64 `schema:"cpushares"`  // nolint
+		Devices                string `schema:"devices"`
+		Dockerfile             string `schema:"dockerfile"`
+		DropCapabilities       string `schema:"dropcaps"`
+		ForceRm                bool   `schema:"forcerm"`
+		From                   string `schema:"from"`
+		HTTPProxy              bool   `schema:"httpproxy"`
+		Isolation              int64  `schema:"isolation"`
+		Jobs                   uint64 `schema:"jobs"` // nolint
+		Labels                 string `schema:"labels"`
+		Layers                 bool   `schema:"layers"`
+		LogRusage              bool   `schema:"rusage"`
+		Manifest               string `schema:"manifest"`
+		MemSwap                int64  `schema:"memswap"`
+		Memory                 int64  `schema:"memory"`
+		NoCache                bool   `schema:"nocache"`
+		OutputFormat           string `schema:"outputformat"`
+		Platform               string `schema:"platform"`
+		Pull                   bool   `schema:"pull"`
+		Quiet                  bool   `schema:"q"`
+		Registry               string `schema:"registry"`
+		Rm                     bool   `schema:"rm"`
+		//FIXME SecurityOpt in remote API is not handled
+		SecurityOpt string   `schema:"securityopt"`
 		ShmSize     int      `schema:"shmsize"`
 		Squash      bool     `schema:"squash"`
 		Tag         []string `schema:"t"`
@@ -101,14 +111,57 @@ func BuildImage(w http.ResponseWriter, r *http.Request) {
 		return
 	}
 
+	// convert label formats
+	var addCaps = []string{}
+	if _, found := r.URL.Query()["addcaps"]; found {
+		var m = []string{}
+		if err := json.Unmarshal([]byte(query.AdditionalCapabilities), &m); err != nil {
+			utils.BadRequest(w, "addcaps", query.AdditionalCapabilities, err)
+			return
+		}
+		addCaps = m
+	}
+	addhosts := []string{}
+	if _, found := r.URL.Query()["extrahosts"]; found {
+		if err := json.Unmarshal([]byte(query.AddHosts), &addhosts); err != nil {
+			utils.BadRequest(w, "extrahosts", query.AddHosts, err)
+			return
+		}
+	}
+
+	// convert label formats
+	var dropCaps = []string{}
+	if _, found := r.URL.Query()["dropcaps"]; found {
+		var m = []string{}
+		if err := json.Unmarshal([]byte(query.DropCapabilities), &m); err != nil {
+			utils.BadRequest(w, "dropcaps", query.DropCapabilities, err)
+			return
+		}
+		dropCaps = m
+	}
+
+	// convert label formats
+	var devices = []string{}
+	if _, found := r.URL.Query()["devices"]; found {
+		var m = []string{}
+		if err := json.Unmarshal([]byte(query.DropCapabilities), &m); err != nil {
+			utils.BadRequest(w, "devices", query.DropCapabilities, err)
+			return
+		}
+		devices = m
+	}
+
 	var output string
 	if len(query.Tag) > 0 {
 		output = query.Tag[0]
 	}
-
-	var additionalNames []string
+	format := buildah.Dockerv2ImageManifest
+	if utils.IsLibpodRequest(r) {
+		format = query.OutputFormat
+	}
+	var additionalTags []string
 	if len(query.Tag) > 1 {
-		additionalNames = query.Tag[1:]
+		additionalTags = query.Tag[1:]
 	}
 
 	var buildArgs = map[string]string{}
@@ -120,17 +173,21 @@ func BuildImage(w http.ResponseWriter, r *http.Request) {
 	}
 
 	// convert label formats
+	var annotations = []string{}
+	if _, found := r.URL.Query()["annotations"]; found {
+		if err := json.Unmarshal([]byte(query.Annotations), &annotations); err != nil {
+			utils.BadRequest(w, "annotations", query.Annotations, err)
+			return
+		}
+	}
+
+	// convert label formats
 	var labels = []string{}
 	if _, found := r.URL.Query()["labels"]; found {
-		var m = map[string]string{}
-		if err := json.Unmarshal([]byte(query.Labels), &m); err != nil {
+		if err := json.Unmarshal([]byte(query.Labels), &labels); err != nil {
 			utils.BadRequest(w, "labels", query.Labels, err)
 			return
 		}
-
-		for k, v := range m {
-			labels = append(labels, k+"="+v)
-		}
 	}
 
 	pullPolicy := buildah.PullIfMissing
@@ -160,27 +217,14 @@ func BuildImage(w http.ResponseWriter, r *http.Request) {
 
 	reporter := channel.NewWriter(make(chan []byte, 1))
 	defer reporter.Close()
+
 	buildOptions := imagebuildah.BuildOptions{
-		ContextDirectory:               contextDirectory,
-		PullPolicy:                     pullPolicy,
-		Registry:                       query.Registry,
-		IgnoreUnrecognizedInstructions: true,
-		Quiet:                          query.Quiet,
-		Layers:                         query.Layers,
-		Isolation:                      buildah.IsolationChroot,
-		Compression:                    archive.Gzip,
-		Args:                           buildArgs,
-		Output:                         output,
-		AdditionalTags:                 additionalNames,
-		Out:                            stdout,
-		Err:                            auxout,
-		ReportWriter:                   reporter,
-		OutputFormat:                   buildah.Dockerv2ImageManifest,
-		SystemContext: &types.SystemContext{
-			AuthFilePath:     authfile,
-			DockerAuthConfig: creds,
-		},
+		AddCapabilities: addCaps,
+		AdditionalTags:  additionalTags,
+		Annotations:     annotations,
+		Args:            buildArgs,
 		CommonBuildOpts: &buildah.CommonBuildOptions{
+			AddHost:    addhosts,
 			CPUPeriod:  query.CpuPeriod,
 			CPUQuota:   query.CpuQuota,
 			CPUShares:  query.CpuShares,
@@ -190,12 +234,37 @@ func BuildImage(w http.ResponseWriter, r *http.Request) {
 			MemorySwap: query.MemSwap,
 			ShmSize:    strconv.Itoa(query.ShmSize),
 		},
-		Squash:                  query.Squash,
-		Labels:                  labels,
-		NoCache:                 query.NoCache,
-		RemoveIntermediateCtrs:  query.Rm,
-		ForceRmIntermediateCtrs: query.ForceRm,
-		Target:                  query.Target,
+		Compression:                    archive.Gzip,
+		ConfigureNetwork:               buildah.NetworkConfigurationPolicy(query.ConfigureNetwork),
+		ContextDirectory:               contextDirectory,
+		Devices:                        devices,
+		DropCapabilities:               dropCaps,
+		Err:                            auxout,
+		ForceRmIntermediateCtrs:        query.ForceRm,
+		From:                           query.From,
+		IgnoreUnrecognizedInstructions: true,
+		// FIXME, This is very broken.  Buildah will only work with chroot
+		//		Isolation:                      buildah.Isolation(query.Isolation),
+		Isolation: buildah.IsolationChroot,
+
+		Labels:                 labels,
+		Layers:                 query.Layers,
+		Manifest:               query.Manifest,
+		NoCache:                query.NoCache,
+		Out:                    stdout,
+		Output:                 output,
+		OutputFormat:           format,
+		PullPolicy:             pullPolicy,
+		Quiet:                  query.Quiet,
+		Registry:               query.Registry,
+		RemoveIntermediateCtrs: query.Rm,
+		ReportWriter:           reporter,
+		Squash:                 query.Squash,
+		SystemContext: &types.SystemContext{
+			AuthFilePath:     authfile,
+			DockerAuthConfig: creds,
+		},
+		Target: query.Target,
 	}
 
 	runtime := r.Context().Value("runtime").(*libpod.Runtime)
diff --git a/pkg/bindings/images/build.go b/pkg/bindings/images/build.go
index 02765816f..8ea09b881 100644
--- a/pkg/bindings/images/build.go
+++ b/pkg/bindings/images/build.go
@@ -31,36 +31,31 @@ import (
 func Build(ctx context.Context, containerFiles []string, options entities.BuildOptions) (*entities.BuildReport, error) {
 	params := url.Values{}
 
-	if t := options.Output; len(t) > 0 {
-		params.Set("t", t)
+	if caps := options.AddCapabilities; len(caps) > 0 {
+		c, err := jsoniter.MarshalToString(caps)
+		if err != nil {
+			return nil, err
+		}
+		params.Add("addcaps", c)
 	}
+
+	if annotations := options.Annotations; len(annotations) > 0 {
+		l, err := jsoniter.MarshalToString(annotations)
+		if err != nil {
+			return nil, err
+		}
+		params.Set("annotations", l)
+	}
+	params.Add("t", options.Output)
 	for _, tag := range options.AdditionalTags {
 		params.Add("t", tag)
 	}
-	if options.Quiet {
-		params.Set("q", "1")
-	}
-	if options.NoCache {
-		params.Set("nocache", "1")
-	}
-	if options.Layers {
-		params.Set("layers", "1")
-	}
-	//	 TODO cachefrom
-	if options.PullPolicy == buildah.PullAlways {
-		params.Set("pull", "1")
-	}
-	if options.RemoveIntermediateCtrs {
-		params.Set("rm", "1")
-	}
-	if options.ForceRmIntermediateCtrs {
-		params.Set("forcerm", "1")
-	}
-	if mem := options.CommonBuildOpts.Memory; mem > 0 {
-		params.Set("memory", strconv.Itoa(int(mem)))
-	}
-	if memSwap := options.CommonBuildOpts.MemorySwap; memSwap > 0 {
-		params.Set("memswap", strconv.Itoa(int(memSwap)))
+	if buildArgs := options.Args; len(buildArgs) > 0 {
+		bArgs, err := jsoniter.MarshalToString(buildArgs)
+		if err != nil {
+			return nil, err
+		}
+		params.Set("buildargs", bArgs)
 	}
 	if cpuShares := options.CommonBuildOpts.CPUShares; cpuShares > 0 {
 		params.Set("cpushares", strconv.Itoa(int(cpuShares)))
@@ -74,22 +69,38 @@ func Build(ctx context.Context, containerFiles []string, options entities.BuildO
 	if cpuQuota := options.CommonBuildOpts.CPUQuota; cpuQuota > 0 {
 		params.Set("cpuquota", strconv.Itoa(int(cpuQuota)))
 	}
-	if buildArgs := options.Args; len(buildArgs) > 0 {
-		bArgs, err := jsoniter.MarshalToString(buildArgs)
+	params.Set("networkmode", strconv.Itoa(int(options.ConfigureNetwork)))
+	params.Set("outputformat", options.OutputFormat)
+
+	if devices := options.Devices; len(devices) > 0 {
+		d, err := jsoniter.MarshalToString(devices)
 		if err != nil {
 			return nil, err
 		}
-		params.Set("buildargs", bArgs)
+		params.Add("devices", d)
 	}
-	if shmSize := options.CommonBuildOpts.ShmSize; len(shmSize) > 0 {
-		shmBytes, err := units.RAMInBytes(shmSize)
+
+	if caps := options.DropCapabilities; len(caps) > 0 {
+		c, err := jsoniter.MarshalToString(caps)
 		if err != nil {
 			return nil, err
 		}
-		params.Set("shmsize", strconv.Itoa(int(shmBytes)))
+		params.Add("dropcaps", c)
 	}
-	if options.Squash {
-		params.Set("squash", "1")
+
+	if options.ForceRmIntermediateCtrs {
+		params.Set("forcerm", "1")
+	}
+	if len(options.From) > 0 {
+		params.Set("from", options.From)
+	}
+
+	params.Set("isolation", strconv.Itoa(int(options.Isolation)))
+	if options.CommonBuildOpts.HTTPProxy {
+		params.Set("httpproxy", "1")
+	}
+	if options.Jobs != nil {
+		params.Set("jobs", strconv.FormatUint(uint64(*options.Jobs), 10))
 	}
 	if labels := options.Labels; len(labels) > 0 {
 		l, err := jsoniter.MarshalToString(labels)
@@ -98,10 +109,66 @@ func Build(ctx context.Context, containerFiles []string, options entities.BuildO
 		}
 		params.Set("labels", l)
 	}
-	if options.CommonBuildOpts.HTTPProxy {
-		params.Set("httpproxy", "1")
+	if options.Layers {
+		params.Set("layers", "1")
+	}
+	if options.LogRusage {
+		params.Set("rusage", "1")
+	}
+	if len(options.Manifest) > 0 {
+		params.Set("manifest", options.Manifest)
+	}
+	if memSwap := options.CommonBuildOpts.MemorySwap; memSwap > 0 {
+		params.Set("memswap", strconv.Itoa(int(memSwap)))
+	}
+	if mem := options.CommonBuildOpts.Memory; mem > 0 {
+		params.Set("memory", strconv.Itoa(int(mem)))
+	}
+	if options.NoCache {
+		params.Set("nocache", "1")
+	}
+	if t := options.Output; len(t) > 0 {
+		params.Set("output", t)
+	}
+	var platform string
+	if len(options.OS) > 0 {
+		platform = options.OS
+	}
+	if len(options.Architecture) > 0 {
+		if len(platform) == 0 {
+			platform = "linux"
+		}
+		platform += "/" + options.Architecture
+	}
+	if len(platform) > 0 {
+		params.Set("platform", platform)
+	}
+	if options.PullPolicy == buildah.PullAlways {
+		params.Set("pull", "1")
+	}
+	if options.Quiet {
+		params.Set("q", "1")
+	}
+	if options.RemoveIntermediateCtrs {
+		params.Set("rm", "1")
+	}
+	if hosts := options.CommonBuildOpts.AddHost; len(hosts) > 0 {
+		h, err := jsoniter.MarshalToString(hosts)
+		if err != nil {
+			return nil, err
+		}
+		params.Set("extrahosts", h)
+	}
+	if shmSize := options.CommonBuildOpts.ShmSize; len(shmSize) > 0 {
+		shmBytes, err := units.RAMInBytes(shmSize)
+		if err != nil {
+			return nil, err
+		}
+		params.Set("shmsize", strconv.Itoa(int(shmBytes)))
+	}
+	if options.Squash {
+		params.Set("squash", "1")
 	}
-
 	var (
 		headers map[string]string
 		err     error
@@ -124,19 +191,6 @@ func Build(ctx context.Context, containerFiles []string, options entities.BuildO
 		stdout = options.Out
 	}
 
-	// TODO network?
-
-	var platform string
-	if OS := options.OS; len(OS) > 0 {
-		platform += OS
-	}
-	if arch := options.Architecture; len(arch) > 0 {
-		platform += "/" + arch
-	}
-	if len(platform) > 0 {
-		params.Set("platform", platform)
-	}
-
 	entries := make([]string, len(containerFiles))
 	copy(entries, containerFiles)
 	entries = append(entries, options.ContextDirectory)