aboutsummaryrefslogtreecommitdiff
path: root/cmd/podman/exists.go
blob: 7645bb716468e72fdc157140cd956f6cd91647da (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
140
package main

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

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

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

	imageExistsDescription = `
	podman image exists

	Check if an image exists in local storage
`
	containerExistsDescription = `
	podman container exists

	Check if a container exists in local storage
`
	podExistsDescription = `
	podman pod exists

	Check if a pod exists in local storage
`
	_imageExistsCommand = &cobra.Command{
		Use:   "exists",
		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`,
	}

	_containerExistsCommand = &cobra.Command{
		Use:   "exists",
		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`,
	}

	_podExistsCommand = &cobra.Command{
		Use:   "exists",
		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`,
	}
)

func init() {
	imageExistsCommand.Command = _imageExistsCommand
	imageExistsCommand.SetUsageTemplate(UsageTemplate())
	containerExistsCommand.Command = _containerExistsCommand
	containerExistsCommand.SetUsageTemplate(UsageTemplate())
	podExistsCommand.Command = _podExistsCommand
	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 := libpodruntime.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 {
			os.Exit(1)
		}
		return err
	}
	return nil
}