summaryrefslogtreecommitdiff
path: root/cmd/podman/exists.go
blob: 8a2f78c88075ce975ee38816726efa75d26a58d3 (plain)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
package main

import (
	"github.com/containers/libpod/cmd/podman/cliconfig"
	"github.com/spf13/cobra"
	"os"

	"github.com/containers/libpod/libpod"
	"github.com/containers/libpod/libpod/image"
	"github.com/containers/libpod/pkg/adapter"
	"github.com/pkg/errors"
)

var (
	imageExistsCommand     cliconfig.ImageExistsValues
	containerExistsCommand cliconfig.ContainerExistsValues
	podExistsCommand       cliconfig.PodExistsValues

	imageExistsDescription = `If the named image exists in local storage, podman image exists exits with 0, otherwise the exit code will be 1.`

	containerExistsDescription = `If the named container exists in local storage, podman container exists exits with 0, otherwise the exit code will be 1.`

	podExistsDescription = `If the named pod exists in local storage, podman pod exists exits with 0, otherwise the exit code will be 1.`

	_imageExistsCommand = &cobra.Command{
		Use:   "exists IMAGE",
		Short: "Check if an image exists in local storage",
		Long:  imageExistsDescription,
		RunE: func(cmd *cobra.Command, args []string) error {
			imageExistsCommand.InputArgs = args
			imageExistsCommand.GlobalFlags = MainGlobalOpts
			return imageExistsCmd(&imageExistsCommand)
		},
		Example: `podman image exists imageID
  podman image exists alpine || podman pull alpine`,
	}

	_containerExistsCommand = &cobra.Command{
		Use:   "exists CONTAINER",
		Short: "Check if a container exists in local storage",
		Long:  containerExistsDescription,
		RunE: func(cmd *cobra.Command, args []string) error {
			containerExistsCommand.InputArgs = args
			containerExistsCommand.GlobalFlags = MainGlobalOpts
			return containerExistsCmd(&containerExistsCommand)

		},
		Example: `podman container exists containerID
  podman container exists myctr || podman run --name myctr [etc...]`,
	}

	_podExistsCommand = &cobra.Command{
		Use:   "exists POD",
		Short: "Check if a pod exists in local storage",
		Long:  podExistsDescription,
		RunE: func(cmd *cobra.Command, args []string) error {
			podExistsCommand.InputArgs = args
			podExistsCommand.GlobalFlags = MainGlobalOpts
			return podExistsCmd(&podExistsCommand)
		},
		Example: `podman pod exists podID
  podman pod exists mypod || podman pod create --name mypod`,
	}
)

func init() {
	imageExistsCommand.Command = _imageExistsCommand
	imageExistsCommand.DisableFlagsInUseLine = true
	imageExistsCommand.SetHelpTemplate(HelpTemplate())
	imageExistsCommand.SetUsageTemplate(UsageTemplate())
	containerExistsCommand.Command = _containerExistsCommand
	containerExistsCommand.DisableFlagsInUseLine = true
	containerExistsCommand.SetHelpTemplate(HelpTemplate())
	containerExistsCommand.SetUsageTemplate(UsageTemplate())
	podExistsCommand.Command = _podExistsCommand
	podExistsCommand.DisableFlagsInUseLine = true
	podExistsCommand.SetHelpTemplate(HelpTemplate())
	podExistsCommand.SetUsageTemplate(UsageTemplate())
}

func imageExistsCmd(c *cliconfig.ImageExistsValues) error {
	args := c.InputArgs
	if len(args) > 1 || len(args) < 1 {
		return errors.New("you may only check for the existence of one image at a time")
	}
	runtime, err := adapter.GetRuntime(&c.PodmanCommand)
	if err != nil {
		return errors.Wrapf(err, "could not get runtime")
	}
	defer runtime.Shutdown(false)
	if _, err := runtime.NewImageFromLocal(args[0]); err != nil {
		//TODO we need to ask about having varlink defined errors exposed
		//so we can reuse them
		if errors.Cause(err) == image.ErrNoSuchImage || err.Error() == "io.podman.ImageNotFound" {
			os.Exit(1)
		}
		return err
	}
	return nil
}

func containerExistsCmd(c *cliconfig.ContainerExistsValues) error {
	args := c.InputArgs
	if len(args) > 1 || len(args) < 1 {
		return errors.New("you may only check for the existence of one container at a time")
	}
	runtime, err := adapter.GetRuntime(&c.PodmanCommand)
	if err != nil {
		return errors.Wrapf(err, "could not get runtime")
	}
	defer runtime.Shutdown(false)
	if _, err := runtime.LookupContainer(args[0]); err != nil {
		if errors.Cause(err) == libpod.ErrNoSuchCtr || err.Error() == "io.podman.ContainerNotFound" {
			os.Exit(1)
		}
		return err
	}
	return nil
}

func podExistsCmd(c *cliconfig.PodExistsValues) error {
	args := c.InputArgs
	if len(args) > 1 || len(args) < 1 {
		return errors.New("you may only check for the existence of one pod at a time")
	}
	runtime, err := adapter.GetRuntime(&c.PodmanCommand)
	if err != nil {
		return errors.Wrapf(err, "could not get runtime")
	}
	defer runtime.Shutdown(false)

	if _, err := runtime.LookupPod(args[0]); err != nil {
		if errors.Cause(err) == libpod.ErrNoSuchPod || err.Error() == "io.podman.PodNotFound" {
			os.Exit(1)
		}
		return err
	}
	return nil
}