mirror of https://github.com/containers/podman.git
95 lines
2.2 KiB
Go
95 lines
2.2 KiB
Go
package imagebuilder
|
|
|
|
import (
|
|
"flag"
|
|
"fmt"
|
|
"os"
|
|
"path/filepath"
|
|
"runtime"
|
|
"strings"
|
|
"time"
|
|
)
|
|
|
|
// hasEnvName returns true if the provided environment contains the named ENV var.
|
|
func hasEnvName(env []string, name string) bool {
|
|
for _, e := range env {
|
|
if strings.HasPrefix(e, name+"=") {
|
|
return true
|
|
}
|
|
}
|
|
return false
|
|
}
|
|
|
|
// platformSupports is a short-term function to give users a quality error
|
|
// message if a Dockerfile uses a command not supported on the platform.
|
|
func platformSupports(command string) error {
|
|
if runtime.GOOS != "windows" {
|
|
return nil
|
|
}
|
|
switch command {
|
|
case "expose", "user", "stopsignal", "arg":
|
|
return fmt.Errorf("The daemon on this platform does not support the command '%s'", command)
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func handleJSONArgs(args []string, attributes map[string]bool) []string {
|
|
if len(args) == 0 {
|
|
return []string{}
|
|
}
|
|
|
|
if attributes != nil && attributes["json"] {
|
|
return args
|
|
}
|
|
|
|
// literal string command, not an exec array
|
|
return []string{strings.Join(args, " ")}
|
|
}
|
|
|
|
func hasSlash(input string) bool {
|
|
return strings.HasSuffix(input, string(os.PathSeparator)) || strings.HasSuffix(input, string(os.PathSeparator)+".")
|
|
}
|
|
|
|
// makeAbsolute ensures that the provided path is absolute.
|
|
func makeAbsolute(dest, workingDir string) string {
|
|
// Twiddle the destination when its a relative path - meaning, make it
|
|
// relative to the WORKINGDIR
|
|
if dest == "." {
|
|
if !hasSlash(workingDir) {
|
|
workingDir += string(os.PathSeparator)
|
|
}
|
|
dest = workingDir
|
|
}
|
|
|
|
if !filepath.IsAbs(dest) {
|
|
hasSlash := hasSlash(dest)
|
|
dest = filepath.Join(string(os.PathSeparator), filepath.FromSlash(workingDir), dest)
|
|
|
|
// Make sure we preserve any trailing slash
|
|
if hasSlash {
|
|
dest += string(os.PathSeparator)
|
|
}
|
|
}
|
|
return dest
|
|
}
|
|
|
|
// parseOptInterval(flag) is the duration of flag.Value, or 0 if
|
|
// empty. An error is reported if the value is given and is not positive.
|
|
func parseOptInterval(f *flag.Flag) (time.Duration, error) {
|
|
if f == nil {
|
|
return 0, fmt.Errorf("No flag defined")
|
|
}
|
|
s := f.Value.String()
|
|
if s == "" {
|
|
return 0, nil
|
|
}
|
|
d, err := time.ParseDuration(s)
|
|
if err != nil {
|
|
return 0, err
|
|
}
|
|
if d <= 0 {
|
|
return 0, fmt.Errorf("Interval %#v must be positive", f.Name)
|
|
}
|
|
return d, nil
|
|
}
|