opensource/podman
1
0
Fork 0
mirror of https://github.com/containers/podman.git synced 2025-06-01 01:00:22 +08:00
Code Issues Packages Projects Releases Wiki Activity

Merge pull request #5374 from baude/create

Browse Source 
add default network for apiv2 create
This commit is contained in:
OpenShift Merge Robot
2020-03-07 14:16:43 +01:00
committed by GitHub
parent 43bf4f6626 8b5e2a6297
commit c8de26fb08
14 changed files with 329 additions and 190 deletions
Download Patch File Download Diff File Expand all files Collapse all files

1
cmd/podman/main.go
View File

@ -138,6 +138,7 @@ func before(cmd *cobra.Command, args []string) error {
logrus.Info("running as rootless")
}
setUMask()
return profileOn(cmd)
}

2
contrib/cirrus/setup_environment.sh
View File

@ -18,7 +18,7 @@ exithandler() {
echo "$(basename $0) exit status: $RET"
[[ "$RET" -eq "0" ]] && date +%s >> "$SETUP_MARKER_FILEPATH"
show_env_vars
[ "$RET" -eq "0" ]] || warn "Non-zero exit caused by error ABOVE env. var. display."
[[ "$RET" -eq "0" ]] || warn "Non-zero exit caused by error ABOVE env. var. display."
}
trap exithandler EXIT

10
libpod/runtime_ctr.go
View File

@ -10,6 +10,7 @@ import (
"github.com/containers/libpod/libpod/define"
"github.com/containers/libpod/libpod/events"
"github.com/containers/libpod/pkg/cgroups"
"github.com/containers/libpod/pkg/rootless"
"github.com/containers/storage/pkg/stringid"
spec "github.com/opencontainers/runtime-spec/specs-go"
@ -438,9 +439,16 @@ func (r *Runtime) removeContainer(ctx context.Context, c *Container, force bool,
if err := c.ociRuntime.KillContainer(c, 9, false); err != nil {
return err
}
if err := c.unpause(); err != nil {
isV2, err := cgroups.IsCgroup2UnifiedMode()
if err != nil {
return err
}
// cgroups v1 and v2 handle signals on paused processes differently
if !isV2 {
if err := c.unpause(); err != nil {
return err
}
}
// Need to update container state to make sure we know it's stopped
if err := c.waitForExitFileAndSync(); err != nil {
return err

1
pkg/api/handlers/containers.go
View File

@ -72,7 +72,6 @@ func UnpauseContainer(w http.ResponseWriter, r *http.Request) {
return
}
// the api does not error if the Container is already paused, so just into it
if err := con.Unpause(); err != nil {
utils.InternalServerError(w, err)
return

46
pkg/api/server/register_images.go
View File

@ -968,6 +968,50 @@ func (s *APIServer) registerImagesHandlers(r *mux.Router) error {
// 500:
// $ref: '#/responses/InternalError'
r.Handle(VersionedPath("/libpod/images/{name:.*}/tag"), s.APIHandler(handlers.TagImage)).Methods(http.MethodPost)
// swagger:operation POST /commit libpod libpodCommitContainer
// ---
// tags:
// - containers
// summary: Commit
// description: Create a new image from a container
// parameters:
// - in: query
// name: container
// type: string
// description: the name or ID of a container
// - in: query
// name: repo
// type: string
// description: the repository name for the created image
// - in: query
// name: tag
// type: string
// description: tag name for the created image
// - in: query
// name: comment
// type: string
// description: commit message
// - in: query
// name: author
// type: string
// description: author of the image
// - in: query
// name: pause
// type: boolean
// description: pause the container before committing it
// - in: query
// name: changes
// type: string
// description: instructions to apply while committing in Dockerfile format
// produces:
// - application/json
// responses:
// 201:
// description: no error
// 404:
// $ref: '#/responses/NoSuchImage'
// 500:
// $ref: '#/responses/InternalError'
r.Handle(VersionedPath("/commit"), s.APIHandler(generic.CommitContainer)).Methods(http.MethodPost)
return nil
}

2
pkg/bindings/containers/create.go
View File

@ -11,7 +11,7 @@ import (
jsoniter "github.com/json-iterator/go"
)
func CreateWithSpec(ctx context.Context, s specgen.SpecGenerator) (utils.ContainerCreateResponse, error) {
func CreateWithSpec(ctx context.Context, s *specgen.SpecGenerator) (utils.ContainerCreateResponse, error) {
var ccr utils.ContainerCreateResponse
conn, err := bindings.GetClient(ctx)
if err != nil {

44
pkg/bindings/test/common_test.go
View File

@ -1,6 +1,7 @@
package test_bindings
import (
"context"
"fmt"
"io/ioutil"
"os"
@ -8,6 +9,9 @@ import (
"path/filepath"
"strings"
. "github.com/containers/libpod/pkg/bindings"
"github.com/containers/libpod/pkg/bindings/containers"
"github.com/containers/libpod/pkg/specgen"
"github.com/onsi/ginkgo"
"github.com/onsi/gomega/gexec"
"github.com/pkg/errors"
@ -55,6 +59,16 @@ type bindingTest struct {
tempDirPath string
runRoot string
crioRoot string
conn context.Context
}
func (b *bindingTest) NewConnection() error {
connText, err := NewConnection(context.Background(), b.sock)
if err != nil {
return err
}
b.conn = connText
return nil
}
func (b *bindingTest) runPodman(command []string) *gexec.Session {
@ -173,17 +187,27 @@ func (b *bindingTest) restoreImageFromCache(i testImage) {
// Run a container within or without a pod
// and add or append the alpine image to it
func (b *bindingTest) RunTopContainer(containerName *string, insidePod *bool, podName *string) {
cmd := []string{"run", "-dt"}
if insidePod != nil && podName != nil {
pName := *podName
cmd = append(cmd, "--pod", pName)
} else if containerName != nil {
cName := *containerName
cmd = append(cmd, "--name", cName)
func (b *bindingTest) RunTopContainer(containerName *string, insidePod *bool, podName *string) (string, error) {
s := specgen.NewSpecGenerator(alpine.name)
s.Terminal = false
s.Command = []string{"top"}
if containerName != nil {
s.Name = *containerName
}
cmd = append(cmd, alpine.name, "top")
b.runPodman(cmd).Wait(45)
if insidePod != nil && podName != nil {
s.Pod = *podName
}
ctr, err := containers.CreateWithSpec(b.conn, s)
if err != nil {
return "", nil
}
err = containers.Start(b.conn, ctr.ID, nil)
if err != nil {
return "", err
}
waiting := "running"
_, err = containers.Wait(b.conn, ctr.ID, &waiting)
return ctr.ID, err
}
// This method creates a pod with the given pod name.

141
pkg/bindings/test/containers_test.go
View File

@ -1,7 +1,6 @@
package test_bindings
import (
"context"
"net/http"
"strconv"
"time"
@ -18,7 +17,6 @@ var _ = Describe("Podman containers ", func() {
var (
bt *bindingTest
s *gexec.Session
connText context.Context
err error
falseFlag bool = false
trueFlag bool = true
@ -29,18 +27,18 @@ var _ = Describe("Podman containers ", func() {
bt.RestoreImagesFromCache()
s = bt.startAPIService()
time.Sleep(1 * time.Second)
connText, err = bindings.NewConnection(context.Background(), bt.sock)
err := bt.NewConnection()
Expect(err).To(BeNil())
})
AfterEach(func() {
s.Kill()
bt.cleanup()
//bt.cleanup()
})
It("podman pause a bogus container", func() {
// Pausing bogus container should return 404
err = containers.Pause(connText, "foobar")
err = containers.Pause(bt.conn, "foobar")
Expect(err).ToNot(BeNil())
code, _ := bindings.CheckResponseCode(err)
Expect(code).To(BeNumerically("==", http.StatusNotFound))
@ -48,7 +46,7 @@ var _ = Describe("Podman containers ", func() {
It("podman unpause a bogus container", func() {
// Unpausing bogus container should return 404
err = containers.Unpause(connText, "foobar")
err = containers.Unpause(bt.conn, "foobar")
Expect(err).ToNot(BeNil())
code, _ := bindings.CheckResponseCode(err)
Expect(code).To(BeNumerically("==", http.StatusNotFound))
@ -57,12 +55,13 @@ var _ = Describe("Podman containers ", func() {
It("podman pause a running container by name", func() {
// Pausing by name should work
var name = "top"
bt.RunTopContainer(&name, &falseFlag, nil)
err := containers.Pause(connText, name)
_, err := bt.RunTopContainer(&name, &falseFlag, nil)
Expect(err).To(BeNil())
err = containers.Pause(bt.conn, name)
Expect(err).To(BeNil())
// Ensure container is paused
data, err := containers.Inspect(connText, name, nil)
data, err := containers.Inspect(bt.conn, name, nil)
Expect(err).To(BeNil())
Expect(data.State.Status).To(Equal("paused"))
})
@ -70,54 +69,60 @@ var _ = Describe("Podman containers ", func() {
It("podman pause a running container by id", func() {
// Pausing by id should work
var name = "top"
bt.RunTopContainer(&name, &falseFlag, nil)
data, err := containers.Inspect(connText, name, nil)
cid, err := bt.RunTopContainer(&name, &falseFlag, nil)
Expect(err).To(BeNil())
err = containers.Pause(connText, data.ID)
err = containers.Pause(bt.conn, cid)
Expect(err).To(BeNil())
// Ensure container is paused
data, err = containers.Inspect(connText, data.ID, nil)
data, err := containers.Inspect(bt.conn, cid, nil)
Expect(err).To(BeNil())
Expect(data.State.Status).To(Equal("paused"))
})
It("podman unpause a running container by name", func() {
// Unpausing by name should work
var name = "top"
bt.RunTopContainer(&name, &falseFlag, nil)
err := containers.Pause(connText, name)
_, err := bt.RunTopContainer(&name, &falseFlag, nil)
Expect(err).To(BeNil())
err = containers.Unpause(connText, name)
err = containers.Pause(bt.conn, name)
Expect(err).To(BeNil())
err = containers.Unpause(bt.conn, name)
Expect(err).To(BeNil())
// Ensure container is unpaused
data, err := containers.Inspect(connText, name, nil)
data, err := containers.Inspect(bt.conn, name, nil)
Expect(err).To(BeNil())
Expect(data.State.Status).To(Equal("running"))
})
It("podman unpause a running container by ID", func() {
// Unpausing by ID should work
var name = "top"
bt.RunTopContainer(&name, &falseFlag, nil)
// Pause by name
err := containers.Pause(connText, name)
data, err := containers.Inspect(connText, name, nil)
_, err := bt.RunTopContainer(&name, &falseFlag, nil)
Expect(err).To(BeNil())
err = containers.Unpause(connText, data.ID)
// Pause by name
err = containers.Pause(bt.conn, name)
//paused := "paused"
//_, err = containers.Wait(bt.conn, cid, &paused)
//Expect(err).To(BeNil())
err = containers.Unpause(bt.conn, name)
Expect(err).To(BeNil())
// Ensure container is unpaused
data, err = containers.Inspect(connText, name, nil)
data, err := containers.Inspect(bt.conn, name, nil)
Expect(err).To(BeNil())
Expect(data.State.Status).To(Equal("running"))
})
It("podman pause a paused container by name", func() {
// Pausing a paused container by name should fail
var name = "top"
bt.RunTopContainer(&name, &falseFlag, nil)
err := containers.Pause(connText, name)
_, err := bt.RunTopContainer(&name, &falseFlag, nil)
Expect(err).To(BeNil())
err = containers.Pause(connText, name)
err = containers.Pause(bt.conn, name)
Expect(err).To(BeNil())
err = containers.Pause(bt.conn, name)
Expect(err).ToNot(BeNil())
code, _ := bindings.CheckResponseCode(err)
Expect(code).To(BeNumerically("==", http.StatusInternalServerError))
@ -126,12 +131,11 @@ var _ = Describe("Podman containers ", func() {
It("podman pause a paused container by id", func() {
// Pausing a paused container by id should fail
var name = "top"
bt.RunTopContainer(&name, &falseFlag, nil)
data, err := containers.Inspect(connText, name, nil)
cid, err := bt.RunTopContainer(&name, &falseFlag, nil)
Expect(err).To(BeNil())
err = containers.Pause(connText, data.ID)
err = containers.Pause(bt.conn, cid)
Expect(err).To(BeNil())
err = containers.Pause(connText, data.ID)
err = containers.Pause(bt.conn, cid)
Expect(err).ToNot(BeNil())
code, _ := bindings.CheckResponseCode(err)
Expect(code).To(BeNumerically("==", http.StatusInternalServerError))
@ -140,10 +144,11 @@ var _ = Describe("Podman containers ", func() {
It("podman pause a stopped container by name", func() {
// Pausing a stopped container by name should fail
var name = "top"
bt.RunTopContainer(&name, &falseFlag, nil)
err := containers.Stop(connText, name, nil)
_, err := bt.RunTopContainer(&name, &falseFlag, nil)
Expect(err).To(BeNil())
err = containers.Pause(connText, name)
err = containers.Stop(bt.conn, name, nil)
Expect(err).To(BeNil())
err = containers.Pause(bt.conn, name)
Expect(err).ToNot(BeNil())
code, _ := bindings.CheckResponseCode(err)
Expect(code).To(BeNumerically("==", http.StatusInternalServerError))
@ -152,11 +157,11 @@ var _ = Describe("Podman containers ", func() {
It("podman pause a stopped container by id", func() {
// Pausing a stopped container by id should fail
var name = "top"
bt.RunTopContainer(&name, &falseFlag, nil)
data, err := containers.Inspect(connText, name, nil)
err = containers.Stop(connText, data.ID, nil)
cid, err := bt.RunTopContainer(&name, &falseFlag, nil)
Expect(err).To(BeNil())
err = containers.Pause(connText, data.ID)
err = containers.Stop(bt.conn, cid, nil)
Expect(err).To(BeNil())
err = containers.Pause(bt.conn, cid)
Expect(err).ToNot(BeNil())
code, _ := bindings.CheckResponseCode(err)
Expect(code).To(BeNumerically("==", http.StatusInternalServerError))
@ -165,12 +170,11 @@ var _ = Describe("Podman containers ", func() {
It("podman remove a paused container by id without force", func() {
// Removing a paused container without force should fail
var name = "top"
bt.RunTopContainer(&name, &falseFlag, nil)
data, err := containers.Inspect(connText, name, nil)
cid, err := bt.RunTopContainer(&name, &falseFlag, nil)
Expect(err).To(BeNil())
err = containers.Pause(connText, data.ID)
err = containers.Pause(bt.conn, cid)
Expect(err).To(BeNil())
err = containers.Remove(connText, data.ID, &falseFlag, &falseFlag)
err = containers.Remove(bt.conn, cid, &falseFlag, &falseFlag)
Expect(err).ToNot(BeNil())
code, _ := bindings.CheckResponseCode(err)
Expect(code).To(BeNumerically("==", http.StatusInternalServerError))
@ -187,22 +191,22 @@ var _ = Describe("Podman containers ", func() {
// Removing a paused container with force should work
var name = "top"
bt.RunTopContainer(&name, &falseFlag, nil)
data, err := containers.Inspect(connText, name, nil)
cid, err := bt.RunTopContainer(&name, &falseFlag, nil)
Expect(err).To(BeNil())
err = containers.Pause(connText, data.ID)
err = containers.Pause(bt.conn, cid)
Expect(err).To(BeNil())
err = containers.Remove(connText, data.ID, &trueFlag, &falseFlag)
err = containers.Remove(bt.conn, cid, &trueFlag, &falseFlag)
Expect(err).To(BeNil())
})
It("podman stop a paused container by name", func() {
// Stopping a paused container by name should fail
var name = "top"
bt.RunTopContainer(&name, &falseFlag, nil)
err := containers.Pause(connText, name)
_, err := bt.RunTopContainer(&name, &falseFlag, nil)
Expect(err).To(BeNil())
err = containers.Stop(connText, name, nil)
err = containers.Pause(bt.conn, name)
Expect(err).To(BeNil())
err = containers.Stop(bt.conn, name, nil)
Expect(err).ToNot(BeNil())
code, _ := bindings.CheckResponseCode(err)
Expect(code).To(BeNumerically("==", http.StatusInternalServerError))
@ -211,12 +215,11 @@ var _ = Describe("Podman containers ", func() {
It("podman stop a paused container by id", func() {
// Stopping a paused container by id should fail
var name = "top"
bt.RunTopContainer(&name, &falseFlag, nil)
data, err := containers.Inspect(connText, name, nil)
cid, err := bt.RunTopContainer(&name, &falseFlag, nil)
Expect(err).To(BeNil())
err = containers.Pause(connText, data.ID)
err = containers.Pause(bt.conn, cid)
Expect(err).To(BeNil())
err = containers.Stop(connText, data.ID, nil)
err = containers.Stop(bt.conn, cid, nil)
Expect(err).ToNot(BeNil())
code, _ := bindings.CheckResponseCode(err)
Expect(code).To(BeNumerically("==", http.StatusInternalServerError))
@ -225,12 +228,13 @@ var _ = Describe("Podman containers ", func() {
It("podman stop a running container by name", func() {
// Stopping a running container by name should work
var name = "top"
bt.RunTopContainer(&name, &falseFlag, nil)
err := containers.Stop(connText, name, nil)
_, err := bt.RunTopContainer(&name, &falseFlag, nil)
Expect(err).To(BeNil())
err = containers.Stop(bt.conn, name, nil)
Expect(err).To(BeNil())
// Ensure container is stopped
data, err := containers.Inspect(connText, name, nil)
data, err := containers.Inspect(bt.conn, name, nil)
Expect(err).To(BeNil())
Expect(isStopped(data.State.Status)).To(BeTrue())
})
@ -238,14 +242,13 @@ var _ = Describe("Podman containers ", func() {
It("podman stop a running container by ID", func() {
// Stopping a running container by ID should work
var name = "top"
bt.RunTopContainer(&name, &falseFlag, nil)
data, err := containers.Inspect(connText, name, nil)
cid, err := bt.RunTopContainer(&name, &falseFlag, nil)
Expect(err).To(BeNil())
err = containers.Stop(connText, data.ID, nil)
err = containers.Stop(bt.conn, cid, nil)
Expect(err).To(BeNil())
// Ensure container is stopped
data, err = containers.Inspect(connText, name, nil)
data, err := containers.Inspect(bt.conn, name, nil)
Expect(err).To(BeNil())
Expect(isStopped(data.State.Status)).To(BeTrue())
})
@ -255,19 +258,20 @@ var _ = Describe("Podman containers ", func() {
name = "top"
exitCode int32 = -1
)
_, err := containers.Wait(connText, "foobar", nil)
_, err := containers.Wait(bt.conn, "foobar", nil)
Expect(err).ToNot(BeNil())
code, _ := bindings.CheckResponseCode(err)
Expect(code).To(BeNumerically("==", http.StatusNotFound))
errChan := make(chan error)
bt.RunTopContainer(&name, nil, nil)
_, err = bt.RunTopContainer(&name, nil, nil)
Expect(err).To(BeNil())
go func() {
exitCode, err = containers.Wait(connText, name, nil)
exitCode, err = containers.Wait(bt.conn, name, nil)
errChan <- err
close(errChan)
}()
err = containers.Stop(connText, name, nil)
err = containers.Stop(bt.conn, name, nil)
Expect(err).To(BeNil())
wait := <-errChan
Expect(wait).To(BeNil())
@ -282,13 +286,14 @@ var _ = Describe("Podman containers ", func() {
unpause = "running"
)
errChan := make(chan error)
bt.RunTopContainer(&name, nil, nil)
_, err := bt.RunTopContainer(&name, nil, nil)
Expect(err).To(BeNil())
go func() {
exitCode, err = containers.Wait(connText, name, &pause)
exitCode, err = containers.Wait(bt.conn, name, &pause)
errChan <- err
close(errChan)
}()
err := containers.Pause(connText, name)
err = containers.Pause(bt.conn, name)
Expect(err).To(BeNil())
wait := <-errChan
Expect(wait).To(BeNil())
@ -296,11 +301,11 @@ var _ = Describe("Podman containers ", func() {
errChan = make(chan error)
go func() {
exitCode, err = containers.Wait(connText, name, &unpause)
exitCode, err = containers.Wait(bt.conn, name, &unpause)
errChan <- err
close(errChan)
}()
err = containers.Unpause(connText, name)
err = containers.Unpause(bt.conn, name)
Expect(err).To(BeNil())
unPausewait := <-errChan
Expect(unPausewait).To(BeNil())

50
pkg/bindings/test/create_test.go Normal file
View File

@ -0,0 +1,50 @@
package test_bindings
import (
"time"
"github.com/containers/libpod/pkg/bindings/containers"
"github.com/containers/libpod/pkg/specgen"
. "github.com/onsi/ginkgo"
. "github.com/onsi/gomega"
"github.com/onsi/gomega/gexec"
)
var _ = Describe("Create containers ", func() {
var (
bt *bindingTest
s *gexec.Session
)
BeforeEach(func() {
bt = newBindingTest()
bt.RestoreImagesFromCache()
s = bt.startAPIService()
time.Sleep(1 * time.Second)
err := bt.NewConnection()
Expect(err).To(BeNil())
})
AfterEach(func() {
s.Kill()
bt.cleanup()
})
It("create a container running top", func() {
s := specgen.NewSpecGenerator(alpine.name)
s.Command = []string{"top"}
s.Terminal = true
s.Name = "top"
ctr, err := containers.CreateWithSpec(bt.conn, s)
Expect(err).To(BeNil())
data, err := containers.Inspect(bt.conn, ctr.ID, nil)
Expect(err).To(BeNil())
Expect(data.Name).To(Equal("top"))
err = containers.Start(bt.conn, ctr.ID, nil)
Expect(err).To(BeNil())
data, err = containers.Inspect(bt.conn, ctr.ID, nil)
Expect(err).To(BeNil())
Expect(data.State.Status).To(Equal("running"))
})
})

107
pkg/bindings/test/images_test.go
View File

@ -1,7 +1,6 @@
package test_bindings
import (
"context"
"net/http"
"os"
"path/filepath"
@ -22,7 +21,6 @@ var _ = Describe("Podman images", func() {
//podmanTest *PodmanTestIntegration
bt *bindingTest
s *gexec.Session
connText context.Context
err error
falseFlag bool = false
trueFlag bool = true
@ -40,7 +38,7 @@ var _ = Describe("Podman images", func() {
bt.RestoreImagesFromCache()
s = bt.startAPIService()
time.Sleep(1 * time.Second)
connText, err = bindings.NewConnection(context.Background(), bt.sock)
err := bt.NewConnection()
Expect(err).To(BeNil())
})
@ -53,32 +51,32 @@ var _ = Describe("Podman images", func() {
})
It("inspect image", func() {
// Inspect invalid image be 404
_, err = images.GetImage(connText, "foobar5000", nil)
_, err = images.GetImage(bt.conn, "foobar5000", nil)
Expect(err).ToNot(BeNil())
code, _ := bindings.CheckResponseCode(err)
Expect(code).To(BeNumerically("==", http.StatusNotFound))
// Inspect by short name
data, err := images.GetImage(connText, alpine.shortName, nil)
data, err := images.GetImage(bt.conn, alpine.shortName, nil)
Expect(err).To(BeNil())
// Inspect with full ID
_, err = images.GetImage(connText, data.ID, nil)
_, err = images.GetImage(bt.conn, data.ID, nil)
Expect(err).To(BeNil())
// Inspect with partial ID
_, err = images.GetImage(connText, data.ID[0:12], nil)
_, err = images.GetImage(bt.conn, data.ID[0:12], nil)
Expect(err).To(BeNil())
// Inspect by long name
_, err = images.GetImage(connText, alpine.name, nil)
_, err = images.GetImage(bt.conn, alpine.name, nil)
Expect(err).To(BeNil())
// TODO it looks like the images API alwaays returns size regardless
// of bool or not. What should we do ?
//Expect(data.Size).To(BeZero())
// Enabling the size parameter should result in size being populated
data, err = images.GetImage(connText, alpine.name, &trueFlag)
data, err = images.GetImage(bt.conn, alpine.name, &trueFlag)
Expect(err).To(BeNil())
Expect(data.Size).To(BeNumerically(">", 0))
})
@ -86,49 +84,50 @@ var _ = Describe("Podman images", func() {
// Test to validate the remove image api
It("remove image", func() {
// Remove invalid image should be a 404
_, err = images.Remove(connText, "foobar5000", &falseFlag)
_, err = images.Remove(bt.conn, "foobar5000", &falseFlag)
Expect(err).ToNot(BeNil())
code, _ := bindings.CheckResponseCode(err)
Expect(code).To(BeNumerically("==", http.StatusNotFound))
// Remove an image by name, validate image is removed and error is nil
inspectData, err := images.GetImage(connText, busybox.shortName, nil)
inspectData, err := images.GetImage(bt.conn, busybox.shortName, nil)
Expect(err).To(BeNil())
response, err := images.Remove(connText, busybox.shortName, nil)
response, err := images.Remove(bt.conn, busybox.shortName, nil)
Expect(err).To(BeNil())
Expect(inspectData.ID).To(Equal(response[0]["Deleted"]))
inspectData, err = images.GetImage(connText, busybox.shortName, nil)
inspectData, err = images.GetImage(bt.conn, busybox.shortName, nil)
code, _ = bindings.CheckResponseCode(err)
Expect(code).To(BeNumerically("==", http.StatusNotFound))
// Start a container with alpine image
var top string = "top"
bt.RunTopContainer(&top, &falseFlag, nil)
_, err = bt.RunTopContainer(&top, &falseFlag, nil)
Expect(err).To(BeNil())
// we should now have a container called "top" running
containerResponse, err := containers.Inspect(connText, "top", &falseFlag)
containerResponse, err := containers.Inspect(bt.conn, "top", &falseFlag)
Expect(err).To(BeNil())
Expect(containerResponse.Name).To(Equal("top"))
// try to remove the image "alpine". This should fail since we are not force
// deleting hence image cannot be deleted until the container is deleted.
response, err = images.Remove(connText, alpine.shortName, &falseFlag)
response, err = images.Remove(bt.conn, alpine.shortName, &falseFlag)
code, _ = bindings.CheckResponseCode(err)
Expect(code).To(BeNumerically("==", http.StatusInternalServerError))
// Removing the image "alpine" where force = true
response, err = images.Remove(connText, alpine.shortName, &trueFlag)
response, err = images.Remove(bt.conn, alpine.shortName, &trueFlag)
Expect(err).To(BeNil())
// Checking if both the images are gone as well as the container is deleted
inspectData, err = images.GetImage(connText, busybox.shortName, nil)
inspectData, err = images.GetImage(bt.conn, busybox.shortName, nil)
code, _ = bindings.CheckResponseCode(err)
Expect(code).To(BeNumerically("==", http.StatusNotFound))
inspectData, err = images.GetImage(connText, alpine.shortName, nil)
inspectData, err = images.GetImage(bt.conn, alpine.shortName, nil)
code, _ = bindings.CheckResponseCode(err)
Expect(code).To(BeNumerically("==", http.StatusNotFound))
_, err = containers.Inspect(connText, "top", &falseFlag)
_, err = containers.Inspect(bt.conn, "top", &falseFlag)
code, _ = bindings.CheckResponseCode(err)
Expect(code).To(BeNumerically("==", http.StatusNotFound))
})
@ -136,17 +135,17 @@ var _ = Describe("Podman images", func() {
// Tests to validate the image tag command.
It("tag image", func() {
// Validates if invalid image name is given a bad response is encountered.
err = images.Tag(connText, "dummy", "demo", alpine.shortName)
err = images.Tag(bt.conn, "dummy", "demo", alpine.shortName)
Expect(err).ToNot(BeNil())
code, _ := bindings.CheckResponseCode(err)
Expect(code).To(BeNumerically("==", http.StatusNotFound))
// Validates if the image is tagged sucessfully.
err = images.Tag(connText, alpine.shortName, "demo", alpine.shortName)
err = images.Tag(bt.conn, alpine.shortName, "demo", alpine.shortName)
Expect(err).To(BeNil())
//Validates if name updates when the image is retagged.
_, err := images.GetImage(connText, "alpine:demo", nil)
_, err := images.GetImage(bt.conn, "alpine:demo", nil)
Expect(err).To(BeNil())
})
@ -154,7 +153,7 @@ var _ = Describe("Podman images", func() {
// Test to validate the List images command.
It("List image", func() {
// Array to hold the list of images returned
imageSummary, err := images.List(connText, nil, nil)
imageSummary, err := images.List(bt.conn, nil, nil)
// There Should be no errors in the response.
Expect(err).To(BeNil())
// Since in the begin context two images are created the
@ -164,7 +163,7 @@ var _ = Describe("Podman images", func() {
// Adding one more image. There Should be no errors in the response.
// And the count should be three now.
bt.Pull("busybox:glibc")
imageSummary, err = images.List(connText, nil, nil)
imageSummary, err = images.List(bt.conn, nil, nil)
Expect(err).To(BeNil())
Expect(len(imageSummary)).To(Equal(3))
@ -179,13 +178,13 @@ var _ = Describe("Podman images", func() {
// List images with a filter
filters := make(map[string][]string)
filters["reference"] = []string{alpine.name}
filteredImages, err := images.List(connText, &falseFlag, filters)
filteredImages, err := images.List(bt.conn, &falseFlag, filters)
Expect(err).To(BeNil())
Expect(len(filteredImages)).To(BeNumerically("==", 1))
// List images with a bad filter
filters["name"] = []string{alpine.name}
_, err = images.List(connText, &falseFlag, filters)
_, err = images.List(bt.conn, &falseFlag, filters)
Expect(err).ToNot(BeNil())
code, _ := bindings.CheckResponseCode(err)
Expect(code).To(BeNumerically("==", http.StatusInternalServerError))
@ -193,64 +192,64 @@ var _ = Describe("Podman images", func() {
It("Image Exists", func() {
// exists on bogus image should be false, with no error
exists, err := images.Exists(connText, "foobar")
exists, err := images.Exists(bt.conn, "foobar")
Expect(err).To(BeNil())
Expect(exists).To(BeFalse())
// exists with shortname should be true
exists, err = images.Exists(connText, alpine.shortName)
exists, err = images.Exists(bt.conn, alpine.shortName)
Expect(err).To(BeNil())
Expect(exists).To(BeTrue())
// exists with fqname should be true
exists, err = images.Exists(connText, alpine.name)
exists, err = images.Exists(bt.conn, alpine.name)
Expect(err).To(BeNil())
Expect(exists).To(BeTrue())
})
It("Load|Import Image", func() {
// load an image
_, err := images.Remove(connText, alpine.name, nil)
_, err := images.Remove(bt.conn, alpine.name, nil)
Expect(err).To(BeNil())
exists, err := images.Exists(connText, alpine.name)
exists, err := images.Exists(bt.conn, alpine.name)
Expect(err).To(BeNil())
Expect(exists).To(BeFalse())
f, err := os.Open(filepath.Join(ImageCacheDir, alpine.tarballName))
defer f.Close()
Expect(err).To(BeNil())
names, err := images.Load(connText, f, nil)
names, err := images.Load(bt.conn, f, nil)
Expect(err).To(BeNil())
Expect(names).To(Equal(alpine.name))
exists, err = images.Exists(connText, alpine.name)
exists, err = images.Exists(bt.conn, alpine.name)
Expect(err).To(BeNil())
Expect(exists).To(BeTrue())
// load with a repo name
f, err = os.Open(filepath.Join(ImageCacheDir, alpine.tarballName))
Expect(err).To(BeNil())
_, err = images.Remove(connText, alpine.name, nil)
_, err = images.Remove(bt.conn, alpine.name, nil)
Expect(err).To(BeNil())
exists, err = images.Exists(connText, alpine.name)
exists, err = images.Exists(bt.conn, alpine.name)
Expect(err).To(BeNil())
Expect(exists).To(BeFalse())
newName := "quay.io/newname:fizzle"
names, err = images.Load(connText, f, &newName)
names, err = images.Load(bt.conn, f, &newName)
Expect(err).To(BeNil())
Expect(names).To(Equal(alpine.name))
exists, err = images.Exists(connText, newName)
exists, err = images.Exists(bt.conn, newName)
Expect(err).To(BeNil())
Expect(exists).To(BeTrue())
// load with a bad repo name should trigger a 500
f, err = os.Open(filepath.Join(ImageCacheDir, alpine.tarballName))
Expect(err).To(BeNil())
_, err = images.Remove(connText, alpine.name, nil)
_, err = images.Remove(bt.conn, alpine.name, nil)
Expect(err).To(BeNil())
exists, err = images.Exists(connText, alpine.name)
exists, err = images.Exists(bt.conn, alpine.name)
Expect(err).To(BeNil())
Expect(exists).To(BeFalse())
badName := "quay.io/newName:fizzle"
_, err = images.Load(connText, f, &badName)
_, err = images.Load(bt.conn, f, &badName)
Expect(err).ToNot(BeNil())
code, _ := bindings.CheckResponseCode(err)
Expect(code).To(BeNumerically("==", http.StatusInternalServerError))
@ -262,7 +261,7 @@ var _ = Describe("Podman images", func() {
w, err := os.Create(filepath.Join(bt.tempDirPath, alpine.tarballName))
defer w.Close()
Expect(err).To(BeNil())
err = images.Export(connText, alpine.name, w, nil, nil)
err = images.Export(bt.conn, alpine.name, w, nil, nil)
Expect(err).To(BeNil())
_, err = os.Stat(exportPath)
Expect(err).To(BeNil())
@ -272,9 +271,9 @@ var _ = Describe("Podman images", func() {
It("Import Image", func() {
// load an image
_, err = images.Remove(connText, alpine.name, nil)
_, err = images.Remove(bt.conn, alpine.name, nil)
Expect(err).To(BeNil())
exists, err := images.Exists(connText, alpine.name)
exists, err := images.Exists(bt.conn, alpine.name)
Expect(err).To(BeNil())
Expect(exists).To(BeFalse())
f, err := os.Open(filepath.Join(ImageCacheDir, alpine.tarballName))
@ -282,27 +281,27 @@ var _ = Describe("Podman images", func() {
Expect(err).To(BeNil())
changes := []string{"CMD /bin/foobar"}
testMessage := "test_import"
_, err = images.Import(connText, changes, &testMessage, &alpine.name, nil, f)
_, err = images.Import(bt.conn, changes, &testMessage, &alpine.name, nil, f)
Expect(err).To(BeNil())
exists, err = images.Exists(connText, alpine.name)
exists, err = images.Exists(bt.conn, alpine.name)
Expect(err).To(BeNil())
Expect(exists).To(BeTrue())
data, err := images.GetImage(connText, alpine.name, nil)
data, err := images.GetImage(bt.conn, alpine.name, nil)
Expect(err).To(BeNil())
Expect(data.Comment).To(Equal(testMessage))
})
It("History Image", func() {
// a bogus name should return a 404
_, err := images.History(connText, "foobar")
_, err := images.History(bt.conn, "foobar")
Expect(err).To(Not(BeNil()))
code, _ := bindings.CheckResponseCode(err)
Expect(code).To(BeNumerically("==", http.StatusNotFound))
var foundID bool
data, err := images.GetImage(connText, alpine.name, nil)
data, err := images.GetImage(bt.conn, alpine.name, nil)
Expect(err).To(BeNil())
history, err := images.History(connText, alpine.name)
history, err := images.History(bt.conn, alpine.name)
Expect(err).To(BeNil())
for _, i := range history {
if i.ID == data.ID {
@ -314,7 +313,7 @@ var _ = Describe("Podman images", func() {
})
It("Search for an image", func() {
imgs, err := images.Search(connText, "alpine", nil, nil)
imgs, err := images.Search(bt.conn, "alpine", nil, nil)
Expect(err).To(BeNil())
Expect(len(imgs)).To(BeNumerically(">", 1))
var foundAlpine bool
@ -328,21 +327,21 @@ var _ = Describe("Podman images", func() {
// Search for alpine with a limit of 10
ten := 10
imgs, err = images.Search(connText, "docker.io/alpine", &ten, nil)
imgs, err = images.Search(bt.conn, "docker.io/alpine", &ten, nil)
Expect(err).To(BeNil())
Expect(len(imgs)).To(BeNumerically("<=", 10))
// Search for alpine with stars greater than 100
filters := make(map[string][]string)
filters["stars"] = []string{"100"}
imgs, err = images.Search(connText, "docker.io/alpine", nil, filters)
imgs, err = images.Search(bt.conn, "docker.io/alpine", nil, filters)
Expect(err).To(BeNil())
for _, i := range imgs {
Expect(i.Stars).To(BeNumerically(">=", 100))
}
// Search with a fqdn
imgs, err = images.Search(connText, "quay.io/libpod/alpine_nginx", nil, nil)
imgs, err = images.Search(bt.conn, "quay.io/libpod/alpine_nginx", nil, nil)
Expect(len(imgs)).To(BeNumerically(">=", 1))
})

90
pkg/bindings/test/pods_test.go
View File

@ -1,7 +1,6 @@
package test_bindings
import (
"context"
"net/http"
"time"
@ -17,7 +16,6 @@ var _ = Describe("Podman pods", func() {
var (
bt *bindingTest
s *gexec.Session
connText context.Context
newpod string
err error
trueFlag bool = true
@ -30,7 +28,7 @@ var _ = Describe("Podman pods", func() {
bt.Podcreate(&newpod)
s = bt.startAPIService()
time.Sleep(1 * time.Second)
connText, err = bindings.NewConnection(context.Background(), bt.sock)
err := bt.NewConnection()
Expect(err).To(BeNil())
})
@ -41,13 +39,13 @@ var _ = Describe("Podman pods", func() {
It("inspect pod", func() {
//Inspect an invalid pod name
_, err := pods.Inspect(connText, "dummyname")
_, err := pods.Inspect(bt.conn, "dummyname")
Expect(err).ToNot(BeNil())
code, _ := bindings.CheckResponseCode(err)
Expect(code).To(BeNumerically("==", http.StatusNotFound))
//Inspect an valid pod name
response, err := pods.Inspect(connText, newpod)
response, err := pods.Inspect(bt.conn, newpod)
Expect(err).To(BeNil())
Expect(response.Config.Name).To(Equal(newpod))
})
@ -55,12 +53,13 @@ var _ = Describe("Podman pods", func() {
// Test validates the list all api returns
It("list pod", func() {
//List all the pods in the current instance
podSummary, err := pods.List(connText, nil)
podSummary, err := pods.List(bt.conn, nil)
Expect(err).To(BeNil())
Expect(len(podSummary)).To(Equal(1))
// Adding an alpine container to the existing pod
bt.RunTopContainer(nil, &trueFlag, &newpod)
podSummary, err = pods.List(connText, nil)
_, err = bt.RunTopContainer(nil, &trueFlag, &newpod)
Expect(err).To(BeNil())
podSummary, err = pods.List(bt.conn, nil)
// Verify no errors.
Expect(err).To(BeNil())
// Verify number of containers in the pod.
@ -69,7 +68,7 @@ var _ = Describe("Podman pods", func() {
// Add multiple pods and verify them by name and size.
var newpod2 string = "newpod2"
bt.Podcreate(&newpod2)
podSummary, err = pods.List(connText, nil)
podSummary, err = pods.List(bt.conn, nil)
Expect(len(podSummary)).To(Equal(2))
var names []string
for _, i := range podSummary {
@ -83,19 +82,19 @@ var _ = Describe("Podman pods", func() {
// Validate list pod with filters
//filters := make(map[string][]string)
//filters["name"] = []string{newpod}
//filteredPods, err := pods.List(connText, filters)
//filteredPods, err := pods.List(bt.conn, filters)
//Expect(err).To(BeNil())
//Expect(len(filteredPods)).To(BeNumerically("==", 1))
})
// The test validates if the exists responds
It("exists pod", func() {
response, err := pods.Exists(connText, "dummyName")
response, err := pods.Exists(bt.conn, "dummyName")
Expect(err).To(BeNil())
Expect(response).To(BeFalse())
// Should exit with no error and response should be true
response, err = pods.Exists(connText, "newpod")
response, err = pods.Exists(bt.conn, "newpod")
Expect(err).To(BeNil())
Expect(response).To(BeTrue())
})
@ -103,23 +102,24 @@ var _ = Describe("Podman pods", func() {
// This test validates if All running containers within
// each specified pod are paused and unpaused
It("pause upause pod", func() {
// TODO fix this
Skip("Pod behavior is jacked right now.")
// Pause invalid container
err := pods.Pause(connText, "dummyName")
err := pods.Pause(bt.conn, "dummyName")
Expect(err).ToNot(BeNil())
code, _ := bindings.CheckResponseCode(err)
Expect(code).To(BeNumerically("==", http.StatusNotFound))
// Adding an alpine container to the existing pod
bt.RunTopContainer(nil, &trueFlag, &newpod)
response, err := pods.Inspect(connText, newpod)
_, err = bt.RunTopContainer(nil, &trueFlag, &newpod)
Expect(err).To(BeNil())
// Binding needs to be modified to inspect the pod state.
// Since we dont have a pod state we inspect the states of the containers within the pod.
// Pause a valid container
err = pods.Pause(connText, newpod)
err = pods.Pause(bt.conn, newpod)
Expect(err).To(BeNil())
response, err = pods.Inspect(connText, newpod)
response, err := pods.Inspect(bt.conn, newpod)
Expect(response.State.Status).To(Equal(define.PodStatePaused))
for _, i := range response.Containers {
Expect(define.StringToContainerStatus(i.State)).
@ -127,9 +127,9 @@ var _ = Describe("Podman pods", func() {
}
// Unpause a valid container
err = pods.Unpause(connText, newpod)
err = pods.Unpause(bt.conn, newpod)
Expect(err).To(BeNil())
response, err = pods.Inspect(connText, newpod)
response, err = pods.Inspect(bt.conn, newpod)
Expect(response.State.Status).To(Equal(define.PodStateRunning))
for _, i := range response.Containers {
Expect(define.StringToContainerStatus(i.State)).
@ -139,28 +139,28 @@ var _ = Describe("Podman pods", func() {
It("start stop restart pod", func() {
// Start an invalid pod
err = pods.Start(connText, "dummyName")
err = pods.Start(bt.conn, "dummyName")
Expect(err).ToNot(BeNil())
code, _ := bindings.CheckResponseCode(err)
Expect(code).To(BeNumerically("==", http.StatusNotFound))
// Stop an invalid pod
err = pods.Stop(connText, "dummyName", nil)
err = pods.Stop(bt.conn, "dummyName", nil)
Expect(err).ToNot(BeNil())
code, _ = bindings.CheckResponseCode(err)
Expect(code).To(BeNumerically("==", http.StatusNotFound))
// Restart an invalid pod
err = pods.Restart(connText, "dummyName")
err = pods.Restart(bt.conn, "dummyName")
Expect(err).ToNot(BeNil())
code, _ = bindings.CheckResponseCode(err)
Expect(code).To(BeNumerically("==", http.StatusNotFound))
// Start a valid pod and inspect status of each container
err = pods.Start(connText, newpod)
err = pods.Start(bt.conn, newpod)
Expect(err).To(BeNil())
response, err := pods.Inspect(connText, newpod)
response, err := pods.Inspect(bt.conn, newpod)
Expect(response.State.Status).To(Equal(define.PodStateRunning))
for _, i := range response.Containers {
Expect(define.StringToContainerStatus(i.State)).
@ -168,13 +168,13 @@ var _ = Describe("Podman pods", func() {
}
// Start an already running pod
err = pods.Start(connText, newpod)
err = pods.Start(bt.conn, newpod)
Expect(err).To(BeNil())
// Stop the running pods
err = pods.Stop(connText, newpod, nil)
err = pods.Stop(bt.conn, newpod, nil)
Expect(err).To(BeNil())
response, _ = pods.Inspect(connText, newpod)
response, _ = pods.Inspect(bt.conn, newpod)
Expect(response.State.Status).To(Equal(define.PodStateExited))
for _, i := range response.Containers {
Expect(define.StringToContainerStatus(i.State)).
@ -182,12 +182,12 @@ var _ = Describe("Podman pods", func() {
}
// Stop an already stopped pod
err = pods.Stop(connText, newpod, nil)
err = pods.Stop(bt.conn, newpod, nil)
Expect(err).To(BeNil())
err = pods.Restart(connText, newpod)
err = pods.Restart(bt.conn, newpod)
Expect(err).To(BeNil())
response, _ = pods.Inspect(connText, newpod)
response, _ = pods.Inspect(bt.conn, newpod)
Expect(response.State.Status).To(Equal(define.PodStateRunning))
for _, i := range response.Containers {
Expect(define.StringToContainerStatus(i.State)).
@ -201,52 +201,52 @@ var _ = Describe("Podman pods", func() {
var newpod2 string = "newpod2"
bt.Podcreate(&newpod2)
// No pods pruned since no pod in exited state
err = pods.Prune(connText)
err = pods.Prune(bt.conn)
Expect(err).To(BeNil())
podSummary, err := pods.List(connText, nil)
podSummary, err := pods.List(bt.conn, nil)
Expect(err).To(BeNil())
Expect(len(podSummary)).To(Equal(2))
// Prune only one pod which is in exited state.
// Start then stop a pod.
// pod moves to exited state one pod should be pruned now.
err = pods.Start(connText, newpod)
err = pods.Start(bt.conn, newpod)
Expect(err).To(BeNil())
err = pods.Stop(connText, newpod, nil)
err = pods.Stop(bt.conn, newpod, nil)
Expect(err).To(BeNil())
response, err := pods.Inspect(connText, newpod)
response, err := pods.Inspect(bt.conn, newpod)
Expect(response.State.Status).To(Equal(define.PodStateExited))
err = pods.Prune(connText)
err = pods.Prune(bt.conn)
Expect(err).To(BeNil())
podSummary, err = pods.List(connText, nil)
podSummary, err = pods.List(bt.conn, nil)
Expect(err).To(BeNil())
Expect(len(podSummary)).To(Equal(1))
// Test prune all pods in exited state.
bt.Podcreate(&newpod)
err = pods.Start(connText, newpod)
err = pods.Start(bt.conn, newpod)
Expect(err).To(BeNil())
err = pods.Start(connText, newpod2)
err = pods.Start(bt.conn, newpod2)
Expect(err).To(BeNil())
err = pods.Stop(connText, newpod, nil)
err = pods.Stop(bt.conn, newpod, nil)
Expect(err).To(BeNil())
response, err = pods.Inspect(connText, newpod)
response, err = pods.Inspect(bt.conn, newpod)
Expect(response.State.Status).To(Equal(define.PodStateExited))
for _, i := range response.Containers {
Expect(define.StringToContainerStatus(i.State)).
To(Equal(define.ContainerStateStopped))
}
err = pods.Stop(connText, newpod2, nil)
err = pods.Stop(bt.conn, newpod2, nil)
Expect(err).To(BeNil())
response, err = pods.Inspect(connText, newpod2)
response, err = pods.Inspect(bt.conn, newpod2)
Expect(response.State.Status).To(Equal(define.PodStateExited))
for _, i := range response.Containers {
Expect(define.StringToContainerStatus(i.State)).
To(Equal(define.ContainerStateStopped))
}
err = pods.Prune(connText)
err = pods.Prune(bt.conn)
Expect(err).To(BeNil())
podSummary, err = pods.List(connText, nil)
podSummary, err = pods.List(bt.conn, nil)
Expect(err).To(BeNil())
Expect(len(podSummary)).To(Equal(0))
})

10
pkg/specgen/create.go
View File

@ -13,7 +13,6 @@ import (
// MakeContainer creates a container based on the SpecGenerator
func (s *SpecGenerator) MakeContainer(rt *libpod.Runtime) (*libpod.Container, error) {
var pod *libpod.Pod
if err := s.validate(rt); err != nil {
return nil, errors.Wrap(err, "invalid config provided")
}
@ -22,7 +21,7 @@ func (s *SpecGenerator) MakeContainer(rt *libpod.Runtime) (*libpod.Container, er
return nil, err
}
options, err := s.createContainerOptions(rt, pod)
options, err := s.createContainerOptions(rt)
if err != nil {
return nil, err
}
@ -46,7 +45,7 @@ func (s *SpecGenerator) MakeContainer(rt *libpod.Runtime) (*libpod.Container, er
return rt.NewContainer(context.Background(), runtimeSpec, options...)
}
func (s *SpecGenerator) createContainerOptions(rt *libpod.Runtime, pod *libpod.Pod) ([]libpod.CtrCreateOption, error) {
func (s *SpecGenerator) createContainerOptions(rt *libpod.Runtime) ([]libpod.CtrCreateOption, error) {
var options []libpod.CtrCreateOption
var err error
@ -61,6 +60,10 @@ func (s *SpecGenerator) createContainerOptions(rt *libpod.Runtime, pod *libpod.P
options = append(options, libpod.WithName(s.Name))
}
if s.Pod != "" {
pod, err := rt.LookupPod(s.Pod)
if err != nil {
return nil, err
}
logrus.Debugf("adding container to pod %s", s.Pod)
options = append(options, rt.WithPod(pod))
}
@ -116,7 +119,6 @@ func (s *SpecGenerator) createContainerOptions(rt *libpod.Runtime, pod *libpod.P
}
options = append(options, namespaceOptions...)
// TODO NetworkNS still needs to be done!
if len(s.ConmonPidFile) > 0 {
options = append(options, libpod.WithConmonPidFile(s.ConmonPidFile))
}

13
pkg/specgen/namespaces.go
View File

@ -70,9 +70,7 @@ func (n *Namespace) IsPrivate() bool {
return n.NSMode == Private
}
// validate perform simple validation on the namespace to make sure it is not
// invalid from the get-go
func (n *Namespace) validate() error {
func validateNetNS(n *Namespace) error {
if n == nil {
return nil
}
@ -82,6 +80,15 @@ func (n *Namespace) validate() error {
default:
return errors.Errorf("invalid network %q", n.NSMode)
}
return nil
}
// validate perform simple validation on the namespace to make sure it is not
// invalid from the get-go
func (n *Namespace) validate() error {
if n == nil {
return nil
}
// Path and From Container MUST have a string value set
if n.NSMode == Path || n.NSMode == FromContainer {
if len(n.Value) < 1 {

2
pkg/specgen/validate.go
View File

@ -138,7 +138,7 @@ func (s *SpecGenerator) validate(rt *libpod.Runtime) error {
if err := s.IpcNS.validate(); err != nil {
return err
}
if err := s.NetNS.validate(); err != nil {
if err := validateNetNS(&s.NetNS); err != nil {
return err
}
if err := s.PidNS.validate(); err != nil {