func readFile(container garden.Container, dstPath, fileName, user string) garden.Process {
filePath := filepath.Join(dstPath, fileName)
process, err := container.Run(garden.ProcessSpec{
Path: "cat",
Args: []string{filePath},
User: user,
}, garden.ProcessIO{})
Expect(err).ToNot(HaveOccurred())
return process
}
func listenInContainer(container garden.Container, containerPort uint32) error {
_, err := container.Run(garden.ProcessSpec{
User: "******",
Path: "sh",
Args: []string{"-c", fmt.Sprintf("echo %d | nc -l -p %d", containerPort, containerPort)},
}, garden.ProcessIO{
Stdout: GinkgoWriter,
Stderr: GinkgoWriter,
})
Expect(err).ToNot(HaveOccurred())
return err
}
func runCommand(container garden.Container, path string, args []string) {
proc, err := container.Run(
garden.ProcessSpec{
Path: path,
Args: args,
},
ginkgoIO)
Expect(err).NotTo(HaveOccurred())
exitCode, err := proc.Wait()
Expect(err).NotTo(HaveOccurred())
Expect(exitCode).To(Equal(0))
}
func streamin(ctr garden.Container, archive string) {
for i := 0; i < 20; i++ {
By(fmt.Sprintf("preparing stream %d for handle %s", i, ctr.Handle()))
// Stream in a tar file to ctr
var tarStream io.Reader
pwd, err := os.Getwd()
Expect(err).ToNot(HaveOccurred())
tgzPath := path.Join(pwd, archive)
tgz, err := os.Open(tgzPath)
Expect(err).ToNot(HaveOccurred())
tarStream, err = gzip.NewReader(tgz)
Expect(err).ToNot(HaveOccurred())
By(fmt.Sprintf("starting stream %d for handle: %s", i, ctr.Handle()))
Expect(ctr.StreamIn(garden.StreamInSpec{
User: "******",
Path: fmt.Sprintf("/root/stream-file-%d", i),
TarStream: tarStream,
})).To(Succeed())
By(fmt.Sprintf("stream %d done for handle: %s", i, ctr.Handle()))
tgz.Close()
}
}
func (g *Gardener) GraceTime(container garden.Container) time.Duration {
property, ok := g.PropertyManager.Get(container.Handle(), GraceTimeKey)
if !ok {
return 0
}
var graceTime time.Duration
_, err := fmt.Sscanf(property, "%d", &graceTime)
if err != nil {
return 0
}
return graceTime
}
func writeFile(container garden.Container, dstPath, user string) garden.Process {
// try to write a new file
filePath := filepath.Join(dstPath, "checkFileAccess-file")
process, err := container.Run(garden.ProcessSpec{
Path: "touch",
Args: []string{filePath},
User: user,
}, garden.ProcessIO{
Stderr: GinkgoWriter,
Stdout: GinkgoWriter,
})
Expect(err).ToNot(HaveOccurred())
return process
}
func createUser(container garden.Container, username string) {
if container == nil {
return
}
process, err := container.Run(garden.ProcessSpec{
User: "******",
Path: "sh",
Args: []string{"-c", fmt.Sprintf("id -u %s || adduser -D %s", username, username)},
}, garden.ProcessIO{
Stdout: GinkgoWriter,
Stderr: GinkgoWriter,
})
Expect(err).ToNot(HaveOccurred())
Expect(process.Wait()).To(Equal(0))
}
func createAndStream(index int, b Benchmarker, archive string) {
var handle string
var ctr garden.Container
var err error
b.Time(fmt.Sprintf("stream-%d", index), func() {
creationTime := b.Time(fmt.Sprintf("create-%d", index), func() {
By("creating container " + strconv.Itoa(index))
ctr, err = gardenClient.Create(garden.ContainerSpec{
Limits: garden.Limits{
Disk: garden.DiskLimits{ByteHard: 2 * 1024 * 1024 * 1024},
},
Privileged: true,
})
Expect(err).ToNot(HaveOccurred())
handle = ctr.Handle()
By("done creating container " + strconv.Itoa(index))
})
now := time.Now()
emitMetric(map[string]interface{}{
"series": []map[string]interface{}{
{
"metric": "garden.container-creation-time",
"points": [][]int64{
{now.Unix(), int64(creationTime)},
},
"tags": []string{"deployment:" + os.Getenv("ENVIRONMENT") + "-garden"},
},
},
})
By("starting stream in to container " + handle)
streamin(ctr, archive)
By("succefully streamed in to container " + handle)
b.Time(fmt.Sprintf("delete-%d", index), func() {
By("destroying container " + handle)
Expect(gardenClient.Destroy(handle)).To(Succeed())
By("successfully destroyed container " + handle)
})
})
}
func ethInterfaceName(container garden.Container) string {
buffer := gbytes.NewBuffer()
proc, err := container.Run(
garden.ProcessSpec{
Path: "sh",
Args: []string{"-c", "ifconfig | grep 'Ethernet' | cut -f 1 -d ' '"},
User: "******",
},
garden.ProcessIO{
Stdout: buffer,
Stderr: GinkgoWriter,
},
)
Expect(err).NotTo(HaveOccurred())
Expect(proc.Wait()).To(Equal(0))
contIfaceName := string(buffer.Contents()) // g3-abc-1
return contIfaceName[:len(contIfaceName)-2] + "0" // g3-abc-0
}
func checkConnection(container garden.Container, ip string, port int) error {
process, err := container.Run(garden.ProcessSpec{
User: "******",
Path: "sh",
Args: []string{"-c", fmt.Sprintf("echo hello | nc -w1 %s %d", ip, port)},
}, garden.ProcessIO{Stdout: GinkgoWriter, Stderr: GinkgoWriter})
if err != nil {
return err
}
exitCode, err := process.Wait()
if err != nil {
return err
}
if exitCode == 0 {
return nil
} else {
return fmt.Errorf("Request failed. Process exited with code %d", exitCode)
}
}
client = startGarden(netPluginArgs...)
bundleDir := filepath.Join(client.DepotDir, container.Handle())
Expect(bundleDir).To(BeADirectory())
Expect(client.Destroy(container.Handle())).To(Succeed())
bundleDir = filepath.Join(client.DepotDir, container.Handle())
Expect(bundleDir).NotTo(BeADirectory())
})
})
Describe("networking resources", func() {
var (
container garden.Container
networkSpec string
contIfaceName string
networkBridgeName string
)
JustBeforeEach(func() {
var err error
networkSpec = fmt.Sprintf("177.100.%d.0/24", GinkgoParallelNode())
container, err = client.Create(garden.ContainerSpec{
Network: networkSpec,
})
Expect(err).NotTo(HaveOccurred())
contIfaceName = ethInterfaceName(container)
networkBridgeName, err = container.Property("kawasaki.bridge-interface")
Expect(err).NotTo(HaveOccurred())
"io/ioutil"
"os"
"path/filepath"
"code.cloudfoundry.org/garden"
"code.cloudfoundry.org/guardian/gqt/runner"
. "code.cloudfoundry.org/guardian/matchers"
. "github.com/onsi/ginkgo"
. "github.com/onsi/gomega"
archiver "github.com/pivotal-golang/archiver/extractor/test_helper"
)
var _ = Describe("Streaming", func() {
var (
client *runner.RunningGarden
container garden.Container
)
BeforeEach(func() {
var err error
client = startGarden()
container, err = client.Create(garden.ContainerSpec{})
Expect(err).NotTo(HaveOccurred())
})
AfterEach(func() {
Expect(client.DestroyAndStop()).To(Succeed())
})
func containerIP(container garden.Container) string {
properties, err := container.Properties()
Expect(err).NotTo(HaveOccurred())
return properties[gardener.ContainerIPKey]
}
"code.cloudfoundry.org/garden"
"code.cloudfoundry.org/guardian/gqt/runner"
. "code.cloudfoundry.org/guardian/matchers"
. "github.com/onsi/ginkgo"
. "github.com/onsi/ginkgo/extensions/table"
. "github.com/onsi/gomega"
"github.com/onsi/gomega/gbytes"
"github.com/onsi/gomega/gexec"
)
var _ = Describe("Creating a Container", func() {
var (
args []string
client *runner.RunningGarden
container garden.Container
initialSockets int
initialPipes int
)
BeforeEach(func() {
args = nil
})
JustBeforeEach(func() {
client = startGarden(args...)
initialSockets = numOpenSockets(client.Pid)
initialPipes = numPipes(client.Pid)
})
AfterEach(func() {
containers, err := gardenClient.Containers(garden.Properties{"foo": bar})
Expect(err).ToNot(HaveOccurred())
Expect(containers).To(HaveLen(1))
Expect(containers[0].Handle()).To(Equal(container.Handle()))
containers, err = gardenClient.Containers(garden.Properties{"matthew": "mcconaughey"})
Expect(err).ToNot(HaveOccurred())
Expect(containers).To(BeEmpty())
})
})
})
Describe("multiple containers", func() {
var extraContainer garden.Container
BeforeEach(func() {
var err error
extraContainer, err = gardenClient.Create(garden.ContainerSpec{})
Expect(err).ToNot(HaveOccurred())
})
AfterEach(func() {
if extraContainer != nil {
Expect(gardenClient.Destroy(extraContainer.Handle())).To(Succeed())
}
})
It("should list all containers", func() {
containers, err := gardenClient.Containers(garden.Properties{})
"code.cloudfoundry.org/garden"
"code.cloudfoundry.org/guardian/gardener"
"code.cloudfoundry.org/guardian/gqt/runner"
. "github.com/onsi/ginkgo"
. "github.com/onsi/gomega"
"github.com/onsi/gomega/gbytes"
"github.com/onsi/gomega/gexec"
)
var _ = Describe("Networking", func() {
var (
client *runner.RunningGarden
container garden.Container
containerNetwork string
args []string
exampleDotCom net.IP
extraProperties garden.Properties
)
BeforeEach(func() {
args = []string{}
containerNetwork = fmt.Sprintf("192.168.%d.0/24", 12+GinkgoParallelNode())
var ips []net.IP
Eventually(func() error {
var err error
ips, err = net.LookupIP("www.example.com")
return err
"strings"
"code.cloudfoundry.org/garden"
"code.cloudfoundry.org/guardian/gqt/runner"
"code.cloudfoundry.org/guardian/sysinfo"
. "github.com/onsi/ginkgo"
. "github.com/onsi/gomega"
"github.com/onsi/gomega/gbytes"
"github.com/onsi/gomega/types"
)
var dockerRegistryV2RootFSPath = os.Getenv("GARDEN_DOCKER_REGISTRY_V2_TEST_ROOTFS")
var _ = Describe("Rootfs container create parameter", func() {
var container garden.Container
var args []string
var client *runner.RunningGarden
var supplyDefaultRootfs bool
BeforeEach(func() {
container = nil
args = []string{}
})
JustBeforeEach(func() {
if supplyDefaultRootfs {
client = startGarden(args...)
} else {
client = startGardenWithoutDefaultRootfs(args...)
}
AfterEach(func() {
Expect(client.DestroyAndStop()).To(Succeed())
})
const (
subnetName string = "177-100-10-0"
)
Context("when a container is created and then garden is restarted", func() {
var (
container garden.Container
hostNetInPort uint32
externalIP string
interfacePrefix string
propertiesDir string
existingProc garden.Process
containerSpec garden.ContainerSpec
restartArgs []string
gracefulShutdown bool
)
BeforeEach(func() {
var err error
propertiesDir, err = ioutil.TempDir("", "props")
Expect(err).NotTo(HaveOccurred())
args = append(args, "--properties-path", path.Join(propertiesDir, "props.json"))
containerSpec = garden.ContainerSpec{
Network: "177.100.10.30/30",
}
func hostIfName(container garden.Container) string {
properties, err := container.Properties()
Expect(err).NotTo(HaveOccurred())
return properties["kawasaki.host-interface"]
}
"path/filepath"
"code.cloudfoundry.org/garden"
"code.cloudfoundry.org/guardian/gqt/runner"
. "github.com/onsi/ginkgo"
. "github.com/onsi/gomega"
)
var _ = Describe("Bind mount", func() {
var (
client *runner.RunningGarden
container garden.Container
// container create parms
privilegedContainer bool
srcPath string // bm: source
dstPath string // bm: destination
bindMountMode garden.BindMountMode // bm: RO or RW
bindMountOrigin garden.BindMountOrigin // bm: Container or Host
// pre-existing file for permissions testing
testFileName string
)
BeforeEach(func() {
privilegedContainer = false
container = nil
srcPath = ""
dstPath = ""
bindMountMode = garden.BindMountModeRO
bindMountOrigin = garden.BindMountOriginHost
testFileName = ""
package gqt_test
import (
"path"
"code.cloudfoundry.org/garden"
"code.cloudfoundry.org/guardian/gqt/runner"
. "github.com/onsi/ginkgo"
. "github.com/onsi/gomega"
)
var _ = Describe("Info", func() {
var (
client *runner.RunningGarden
container garden.Container
)
BeforeEach(func() {
var err error
client = startGarden()
container, err = client.Create(garden.ContainerSpec{
Network: "10.252.0.2",
Properties: garden.Properties{
"foo": "bar",
},
})
Expect(err).NotTo(HaveOccurred())
})
AfterEach(func() {
Expect(client.DestroyAndStop()).To(Succeed())
"net"
"strings"
"time"
. "github.com/onsi/ginkgo"
. "github.com/onsi/gomega"
"github.com/onsi/gomega/gbytes"
"code.cloudfoundry.org/garden"
. "code.cloudfoundry.org/garden/client"
"code.cloudfoundry.org/garden/client/connection/connectionfakes"
"code.cloudfoundry.org/garden/gardenfakes"
)
var _ = Describe("Container", func() {
var container garden.Container
var fakeConnection *connectionfakes.FakeConnection
BeforeEach(func() {
fakeConnection = new(connectionfakes.FakeConnection)
})
JustBeforeEach(func() {
var err error
client := New(fakeConnection)
fakeConnection.CreateReturns("some-handle", nil)
container, err = client.Create(garden.ContainerSpec{})
func (s *GardenServer) reapContainer(container garden.Container) {
s.logger.Info("reaping", lager.Data{
"handle": container.Handle(),
"grace-time": s.backend.GraceTime(container).String(),
})
s.destroysL.Lock()
_, alreadyDestroying := s.destroys[container.Handle()]
if !alreadyDestroying {
s.destroys[container.Handle()] = struct{}{}
}
s.destroysL.Unlock()
if alreadyDestroying {
s.logger.Info("skipping reap due to concurrent delete request", lager.Data{
"handle": container.Handle(),
"grace-time": s.backend.GraceTime(container).String(),
})
return
}
s.backend.Destroy(container.Handle())
s.destroysL.Lock()
delete(s.destroys, container.Handle())
s.destroysL.Unlock()
}
garden.ProcessIO{
Stdout: io.MultiWriter(GinkgoWriter, out),
Stderr: io.MultiWriter(GinkgoWriter, out),
})
Expect(err).NotTo(HaveOccurred())
exitCode, err := proc.Wait()
Expect(err).NotTo(HaveOccurred())
Expect(exitCode).To(Equal(0))
Expect(out).To(gbytes.Say("alice"))
})
})
Describe("PATH env variable", func() {
var container garden.Container
BeforeEach(func() {
client = startGarden()
var err error
container, err = client.Create(garden.ContainerSpec{})
Expect(err).NotTo(HaveOccurred())
})
DescribeTable("contains the correct values", func(user, path string, env []string) {
out := gbytes.NewBuffer()
proc, err := container.Run(
garden.ProcessSpec{
Path: "sh",
Args: []string{"-c", "echo $PATH"},
User: user,
package gqt_test
import (
"io"
"os"
"code.cloudfoundry.org/garden"
"code.cloudfoundry.org/guardian/gqt/runner"
. "github.com/onsi/ginkgo"
. "github.com/onsi/gomega"
"github.com/onsi/gomega/gbytes"
)
var _ = Describe("Fuse", func() {
var (
client *runner.RunningGarden
container garden.Container
)
BeforeEach(func() {
fuseRootfs := os.Getenv("GARDEN_FUSE_TEST_ROOTFS")
if fuseRootfs == "" {
Skip("GARDEN_FUSE_TEST_ROOTFS not defined, skipping")
}
var err error
client = startGarden()
container, err = client.Create(garden.ContainerSpec{
RootFSPath: fuseRootfs,
Privileged: true,
})
Expect(err).NotTo(HaveOccurred())
"io/ioutil"
"os"
"path"
"code.cloudfoundry.org/garden"
"code.cloudfoundry.org/guardian/gardener"
"code.cloudfoundry.org/guardian/gqt/runner"
. "github.com/onsi/ginkgo"
. "github.com/onsi/gomega"
)
var _ = Describe("Properties", func() {
var (
args []string
client *runner.RunningGarden
container garden.Container
props garden.Properties
propertiesDir string
)
BeforeEach(func() {
var err error
propertiesDir, err = ioutil.TempDir("", "props")
Expect(err).NotTo(HaveOccurred())
args = append(args, "--properties-path", path.Join(propertiesDir, "props.json"))
client = startGarden(args...)
props = garden.Properties{"somename": "somevalue"}
container, err = client.Create(garden.ContainerSpec{
Properties: props,
It("can resolve domain names", func() {
itCanResolve("www.example.com")
})
})
Describe("subnet support", func() {
BeforeEach(func() {
networkSpec = fmt.Sprintf("192.168.%d.0/24", 12+GinkgoParallelNode())
})
Context("when destroying other containers on the same subnet", func() {
It("should continue to route traffic successfully", func() {
var (
err error
googleDNSIP string
otherContainer garden.Container
)
googleDNSIP = "8.8.8.8"
for i := 0; i < 5; i++ {
otherContainer, err = gardenClient.Create(garden.ContainerSpec{
Network: networkSpec,
})
Expect(err).NotTo(HaveOccurred())
Expect(gardenClient.Destroy(otherContainer.Handle())).To(Succeed())
Expect(checkConnection(container, googleDNSIP, 53)).To(Succeed())
}
})
})