containers
/
podman
mirror of https://github.com/containers/podman.git
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

add default network for apiv2 create 

during container creation, if no network is provided, we need to add a default value so the container can be later started.

use apiv2 container creation for RunTopContainer instead of an exec to the system podman. RunTopContainer now also returns the container id and an error.

added a libpod commit endpoint.

also, changed the use of the connections and bindings slightly to make it more convenient to write tests.

Fixes: 5366
Signed-off-by: Brent Baude <bbaude@redhat.com>
This commit is contained in:
Brent Baude 2020-02-26 15:15:36 -06:00
parent a61d05f667
commit 8b5e2a6297
14 changed files with 329 additions and 190 deletions
Show Stats 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

@ -942,6 +942,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 {