podman

1
package bindings_test
2

3
import (
4
	"context"
5
	"fmt"
6
	"net/http"
7
	"time"
8

9
	"github.com/containers/common/libnetwork/types"
10
	"github.com/containers/podman/v5/pkg/bindings"
11
	"github.com/containers/podman/v5/pkg/bindings/containers"
12
	"github.com/containers/podman/v5/pkg/bindings/network"
13
	. "github.com/onsi/ginkgo/v2"
14
	. "github.com/onsi/gomega"
15
	"github.com/onsi/gomega/gexec"
16
	"golang.org/x/exp/slices"
17
)
18

19
var _ = Describe("Podman networks", func() {
20
	var (
21
		bt       *bindingTest
22
		s        *gexec.Session
23
		connText context.Context
24
		err      error
25
	)
26

27
	BeforeEach(func() {
28

29
		bt = newBindingTest()
30
		bt.RestoreImagesFromCache()
31
		s = bt.startAPIService()
32
		time.Sleep(1 * time.Second)
33
		connText, err = bindings.NewConnection(context.Background(), bt.sock)
34
		Expect(err).ToNot(HaveOccurred())
35
		_, err = network.Prune(connText, &network.PruneOptions{})
36
		Expect(err).ToNot(HaveOccurred())
37
	})
38

39
	AfterEach(func() {
40
		s.Kill()
41
		bt.cleanup()
42
	})
43

44
	It("podman prune unused networks with filters", func() {
45
		name := "foobar"
46
		net := types.Network{
47
			Name: name,
48
		}
49
		_, err = network.Create(connText, &net)
50
		Expect(err).ToNot(HaveOccurred())
51

52
		// Invalid filters should return error
53
		filtersIncorrect := map[string][]string{
54
			"status": {"dummy"},
55
		}
56
		_, err = network.Prune(connText, new(network.PruneOptions).WithFilters(filtersIncorrect))
57
		Expect(err).To(HaveOccurred())
58

59
		// List filter params should not work with prune.
60
		filtersIncorrect = map[string][]string{
61
			"name": {name},
62
		}
63
		_, err = network.Prune(connText, new(network.PruneOptions).WithFilters(filtersIncorrect))
64
		Expect(err).To(HaveOccurred())
65

66
		// Mismatched label, correct filter params => no network should be pruned.
67
		filtersIncorrect = map[string][]string{
68
			"label": {"xyz"},
69
		}
70
		pruneResponse, err := network.Prune(connText, new(network.PruneOptions).WithFilters(filtersIncorrect))
71
		Expect(err).ToNot(HaveOccurred())
72
		Expect(pruneResponse).To(BeEmpty())
73

74
		// Mismatched until, correct filter params => no network should be pruned.
75
		filters := map[string][]string{
76
			"until": {"50"}, // January 1, 1970
77
		}
78
		pruneResponse, err = network.Prune(connText, new(network.PruneOptions).WithFilters(filters))
79
		Expect(err).ToNot(HaveOccurred())
80
		Expect(pruneResponse).To(BeEmpty())
81

82
		// Valid filter params => network should be pruned now.
83
		filters = map[string][]string{
84
			"until": {"5000000000"}, // June 11, 2128
85
		}
86
		pruneResponse, err = network.Prune(connText, new(network.PruneOptions).WithFilters(filters))
87
		Expect(err).ToNot(HaveOccurred())
88
		Expect(pruneResponse).To(HaveLen(1))
89
	})
90

91
	It("create network", func() {
92
		// create a network with blank config should work
93
		_, err = network.Create(connText, nil)
94
		Expect(err).ToNot(HaveOccurred())
95

96
		name := "foobar"
97
		net := types.Network{
98
			Name: name,
99
		}
100

101
		report, err := network.Create(connText, &net)
102
		Expect(err).ToNot(HaveOccurred())
103
		Expect(report.Name).To(Equal(name))
104

105
		// create network with same name should 409
106
		_, err = network.Create(connText, &net)
107
		Expect(err).To(HaveOccurred())
108
		code, _ := bindings.CheckResponseCode(err)
109
		Expect(code).To(BeNumerically("==", http.StatusConflict))
110

111
		// create network with same name and ignore false should 409
112
		options := new(network.ExtraCreateOptions).WithIgnoreIfExists(false)
113
		_, err = network.CreateWithOptions(connText, &net, options)
114
		Expect(err).To(HaveOccurred())
115
		code, _ = bindings.CheckResponseCode(err)
116
		Expect(code).To(BeNumerically("==", http.StatusConflict))
117

118
		// create network with same name and ignore true succeed
119
		options = new(network.ExtraCreateOptions).WithIgnoreIfExists(true)
120
		report, err = network.CreateWithOptions(connText, &net, options)
121
		Expect(err).ToNot(HaveOccurred())
122
		Expect(report.Name).To(Equal(name))
123
	})
124

125
	It("inspect network", func() {
126
		name := "foobar"
127
		net := types.Network{
128
			Name: name,
129
		}
130
		_, err = network.Create(connText, &net)
131
		Expect(err).ToNot(HaveOccurred())
132
		data, err := network.Inspect(connText, name, nil)
133
		Expect(err).ToNot(HaveOccurred())
134
		Expect(data.Name).To(Equal(name))
135
	})
136

137
	It("list networks", func() {
138
		// create a bunch of named networks and make verify with list
139
		netNames := []string{"homer", "bart", "lisa", "maggie", "marge"}
140
		for i := 0; i < 5; i++ {
141
			net := types.Network{
142
				Name: netNames[i],
143
			}
144
			_, err = network.Create(connText, &net)
145
			Expect(err).ToNot(HaveOccurred())
146
		}
147
		list, err := network.List(connText, nil)
148
		Expect(err).ToNot(HaveOccurred())
149
		Expect(len(list)).To(BeNumerically(">=", 5))
150
		for _, n := range list {
151
			if n.Name != "podman" {
152
				Expect(slices.Contains(netNames, n.Name)).To(BeTrue())
153
			}
154
		}
155

156
		// list with bad filter should be 500
157
		filters := make(map[string][]string)
158
		filters["foobar"] = []string{"1234"}
159
		options := new(network.ListOptions).WithFilters(filters)
160
		_, err = network.List(connText, options)
161
		Expect(err).To(HaveOccurred())
162
		code, _ := bindings.CheckResponseCode(err)
163
		Expect(code).To(BeNumerically("==", http.StatusInternalServerError))
164

165
		// filter list with success
166
		filters = make(map[string][]string)
167
		filters["name"] = []string{"homer"}
168
		options = new(network.ListOptions).WithFilters(filters)
169
		list, err = network.List(connText, options)
170
		Expect(err).ToNot(HaveOccurred())
171
		Expect(list).To(HaveLen(1))
172
		Expect(list[0].Name).To(Equal("homer"))
173
	})
174

175
	It("remove network", func() {
176
		// removing a noName network should result in 404
177
		_, err := network.Remove(connText, "noName", nil)
178
		code, err := bindings.CheckResponseCode(err)
179
		Expect(err).ToNot(HaveOccurred())
180
		Expect(code).To(BeNumerically("==", http.StatusNotFound))
181

182
		// Removing an unused network should work
183
		name := "unused"
184
		net := types.Network{
185
			Name: name,
186
		}
187
		_, err = network.Create(connText, &net)
188
		Expect(err).ToNot(HaveOccurred())
189
		report, err := network.Remove(connText, name, nil)
190
		Expect(err).ToNot(HaveOccurred())
191
		Expect(report[0].Name).To(Equal(name))
192

193
		// Removing a network that is being used without force should be 500
194
		name = "used"
195
		net = types.Network{
196
			Name: name,
197
		}
198
		_, err = network.Create(connText, &net)
199
		Expect(err).ToNot(HaveOccurred())
200

201
		// Start container and wait
202
		container := "ntest"
203
		session := bt.runPodman([]string{"run", "-dt", fmt.Sprintf("--network=%s", name), "--name", container, alpine.name, "top"})
204
		session.Wait(45)
205
		Expect(session.ExitCode()).To(BeZero())
206

207
		_, err = network.Remove(connText, name, nil)
208
		code, err = bindings.CheckResponseCode(err)
209
		Expect(err).ToNot(HaveOccurred())
210
		Expect(code).To(BeNumerically("==", http.StatusInternalServerError))
211

212
		// Removing with a network in use with force should work with a stopped container
213
		err = containers.Stop(connText, container, new(containers.StopOptions).WithTimeout(0))
214
		Expect(err).ToNot(HaveOccurred())
215
		options := new(network.RemoveOptions).WithForce(true)
216
		report, err = network.Remove(connText, name, options)
217
		Expect(err).ToNot(HaveOccurred())
218
		Expect(report[0].Name).To(Equal(name))
219
	})
220
})
221