Merge branch 'master' of github.com:kubernetes-incubator/cri-o into lastError

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

cmd/kpod/main.go

@@ -105,7 +105,7 @@ func main() {
 		if debug {
 			logrus.Errorf(err.Error())
 		} else {
-			fmt.Println(err.Error())
+			fmt.Fprintln(os.Stderr, err.Error())
 		}
 		cli.OsExiter(1)
 	}

cmd/kpod/ps.go

@@ -75,16 +75,16 @@ type psJSONParams struct {
 	Labels           fields.Set          `json:"labels"`
 	Mounts           []specs.Mount       `json:"mounts"`
 	ContainerRunning bool                `json:"ctrRunning"`
-	Namespaces       namespace           `json:"namespace,omitempty"`
+	Namespaces       *namespace          `json:"namespace,omitempty"`
 }
 
 type namespace struct {
-	PID    string `json:"ctrPID,omitempty"`
+	PID    string `json:"pid,omitempty"`
 	Cgroup string `json:"cgroup,omitempty"`
 	IPC    string `json:"ipc,omitempty"`
 	MNT    string `json:"mnt,omitempty"`
 	NET    string `json:"net,omitempty"`
-	PIDNS  string `json:"pid,omitempty"`
+	PIDNS  string `json:"pidns,omitempty"`
 	User   string `json:"user,omitempty"`
 	UTS    string `json:"uts,omitempty"`
 }
@@ -334,7 +334,7 @@ func getTemplateOutput(containers []*libkpod.ContainerData, opts psOptions) (psO
 	return
 }
 
-func getNamespaces(pid int) namespace {
+func getNamespaces(pid int) *namespace {
 	ctrPID := strconv.Itoa(pid)
 	cgroup, _ := getNamespaceInfo(filepath.Join("/proc", ctrPID, "ns", "cgroup"))
 	ipc, _ := getNamespaceInfo(filepath.Join("/proc", ctrPID, "ns", "ipc"))
@@ -344,7 +344,7 @@ func getNamespaces(pid int) namespace {
 	user, _ := getNamespaceInfo(filepath.Join("/proc", ctrPID, "ns", "user"))
 	uts, _ := getNamespaceInfo(filepath.Join("/proc", ctrPID, "ns", "uts"))
 
-	return namespace{
+	return &namespace{
 		PID:    ctrPID,
 		Cgroup: cgroup,
 		IPC:    ipc,
@@ -366,7 +366,7 @@ func getNamespaceInfo(path string) (string, error) {
 
 // getJSONOutput returns the container info in its raw form
 func getJSONOutput(containers []*libkpod.ContainerData, nSpace bool) (psOutput []psJSONParams) {
-	var ns namespace
+	var ns *namespace
 	for _, ctr := range containers {
 		if nSpace {
 			ns = getNamespaces(ctr.State.Pid)

cmd/kpod/pull.go

@@ -3,6 +3,11 @@ package main
 import (
 	"os"
 
+	"fmt"
+	"github.com/containers/image/docker/reference"
+	"github.com/containers/image/pkg/sysregistries"
+	"github.com/containers/image/transports/alltransports"
+	"github.com/containers/image/types"
 	"github.com/pkg/errors"
 	"github.com/sirupsen/logrus"
 	"github.com/urfave/cli"
@@ -31,9 +36,84 @@ var (
 	}
 )
 
+// struct for when a user passes a short or incomplete
+// image name
+type imagePullStruct struct {
+	imageName   string
+	tag         string
+	registry    string
+	hasRegistry bool
+	transport   string
+}
+
+func (ips imagePullStruct) returnFQName() string {
+	return fmt.Sprintf("%s%s/%s:%s", ips.transport, ips.registry, ips.imageName, ips.tag)
+}
+
+func getRegistriesToTry(image string) ([]string, error) {
+	var registries []string
+	var imageError = fmt.Sprintf("unable to parse '%s'\n", image)
+	imgRef, err := reference.Parse(image)
+	if err != nil {
+		return nil, errors.Wrapf(err, imageError)
+	}
+	tagged, isTagged := imgRef.(reference.NamedTagged)
+	tag := "latest"
+	if isTagged {
+		tag = tagged.Tag()
+	}
+	hasDomain := true
+	registry := reference.Domain(imgRef.(reference.Named))
+	if registry == "" {
+		hasDomain = false
+	}
+	imageName := reference.Path(imgRef.(reference.Named))
+	pImage := imagePullStruct{
+		imageName,
+		tag,
+		registry,
+		hasDomain,
+		"docker://",
+	}
+	if pImage.hasRegistry {
+		// If input has a registry, we have to assume they included an image
+		// name but maybe not a tag
+		pullRef, err := alltransports.ParseImageName(pImage.returnFQName())
+		if err != nil {
+			return nil, errors.Errorf(imageError)
+		}
+		registries = append(registries, pullRef.DockerReference().String())
+	} else {
+		// No registry means we check the globals registries configuration file
+		// and assemble a list of candidate sources to try
+		registryConfigPath := ""
+		envOverride := os.Getenv("REGISTRIES_CONFIG_PATH")
+		if len(envOverride) > 0 {
+			registryConfigPath = envOverride
+		}
+		searchRegistries, err := sysregistries.GetRegistries(&types.SystemContext{SystemRegistriesConfPath: registryConfigPath})
+		if err != nil {
+			fmt.Println(err)
+			return nil, errors.Errorf("unable to parse the registries.conf file and"+
+				" the image name '%s' is incomplete.", imageName)
+		}
+		for _, searchRegistry := range searchRegistries {
+			pImage.registry = searchRegistry
+			pullRef, err := alltransports.ParseImageName(pImage.returnFQName())
+			if err != nil {
+				return nil, errors.Errorf("unable to parse '%s'", pImage.returnFQName())
+			}
+			registries = append(registries, pullRef.DockerReference().String())
+		}
+	}
+	return registries, nil
+}
+
 // pullCmd gets the data from the command line and calls pullImage
 // to copy an image from a registry to a local machine
 func pullCmd(c *cli.Context) error {
+	var fqRegistries []string
+
 	args := c.Args()
 	if len(args) == 0 {
 		logrus.Errorf("an image name must be specified")
@@ -44,13 +124,28 @@ func pullCmd(c *cli.Context) error {
 		return nil
 	}
 	image := args[0]
-
+	srcRef, err := alltransports.ParseImageName(image)
+	if err != nil {
+		fqRegistries, err = getRegistriesToTry(image)
+		if err != nil {
+			fmt.Println(err)
+		}
+	} else {
+		fqRegistries = append(fqRegistries, srcRef.DockerReference().String())
+	}
 	runtime, err := getRuntime(c)
+	defer runtime.Shutdown(false)
+
 	if err != nil {
 		return errors.Wrapf(err, "could not create runtime")
 	}
-	if err := runtime.PullImage(image, c.Bool("all-tags"), os.Stdout); err != nil {
-		return errors.Errorf("error pulling image from %q: %v", image, err)
+	for _, fqname := range fqRegistries {
+		fmt.Printf("Trying to pull %s...", fqname)
+		if err := runtime.PullImage(fqname, c.Bool("all-tags"), os.Stdout); err != nil {
+			fmt.Printf(" Failed\n")
+		} else {
+			return nil
+		}
 	}
-	return nil
+	return errors.Errorf("error pulling image from %q", image)
 }

cmd/kpod/stop.go

@@ -2,9 +2,10 @@ package main
 
 import (
 	"fmt"
+	"os"
+
 	"github.com/kubernetes-incubator/cri-o/libkpod"
 	"github.com/pkg/errors"
-	"github.com/sirupsen/logrus"
 	"github.com/urfave/cli"
 )
 
@@ -60,9 +61,9 @@ func stopCmd(c *cli.Context) error {
 		cid, err := server.ContainerStop(container, stopTimeout)
 		if err != nil {
 			if lastError != nil {
-				logrus.Error(lastError)
+				fmt.Fprintln(os.Stderr, lastError)
 			}
-			lastError = errors.Wrapf(err, "failed to stop %v", container)
+			lastError = errors.Wrapf(err, "failed to stop container %v", container)
 		} else {
 			fmt.Println(cid)
 		}