func TestGardenIntegrationTests(t *testing.T) {
RegisterFailHandler(Fail)
SetDefaultEventuallyTimeout(5 * time.Second)
BeforeEach(func() {
assertContainerCreate = true
handle = ""
rootfs = ""
networkSpec = ""
privilegedContainer = false
properties = garden.Properties{}
limits = garden.Limits{}
env = []string{}
gardenHost = os.Getenv("GARDEN_ADDRESS")
if gardenHost == "" {
gardenHost = "10.244.16.6"
}
gardenPort = os.Getenv("GARDEN_PORT")
if gardenPort == "" {
gardenPort = "7777"
}
gardenDebugPort = os.Getenv("GARDEN_DEBUG_PORT")
if gardenDebugPort == "" {
gardenDebugPort = "17013"
}
gardenClient = client.New(connection.New("tcp", fmt.Sprintf("%s:%s", gardenHost, gardenPort)))
})
JustBeforeEach(func() {
container, containerCreateErr = gardenClient.Create(garden.ContainerSpec{
Handle: handle,
RootFSPath: rootfs,
Privileged: privilegedContainer,
Properties: properties,
Env: env,
Limits: limits,
Network: networkSpec,
})
if assertContainerCreate {
Expect(containerCreateErr).ToNot(HaveOccurred())
}
})
AfterEach(func() {
if container != nil {
// ignoring the error since it can return unknown handle error
theContainer, _ := gardenClient.Lookup(container.Handle())
if theContainer != nil {
Expect(gardenClient.Destroy(container.Handle())).To(Succeed())
}
}
})
RunSpecs(t, "GardenIntegrationTests Suite")
}
func TestPerformance(t *testing.T) {
RegisterFailHandler(Fail)
SetDefaultEventuallyTimeout(5 * time.Second)
BeforeEach(func() {
gardenHost = os.Getenv("GARDEN_ADDRESS")
if gardenHost == "" {
gardenHost = "10.244.16.6"
}
gardenPort = os.Getenv("GARDEN_PORT")
if gardenPort == "" {
gardenPort = "7777"
}
rootfs = "docker:///cfgarden/garden-busybox"
})
JustBeforeEach(func() {
gardenClient = client.New(connection.New("tcp", fmt.Sprintf("%s:%s", gardenHost, gardenPort)))
var err error
container, err = gardenClient.Create(garden.ContainerSpec{
RootFSPath: rootfs,
})
Expect(err).ToNot(HaveOccurred())
stdout := gbytes.NewBuffer()
stderr := gbytes.NewBuffer()
process, err := container.Run(garden.ProcessSpec{
User: "******",
Path: "sh",
Args: []string{"-c", "while true; do sleep 1; done"},
}, garden.ProcessIO{
Stdout: stdout,
Stderr: stderr,
})
Expect(err).ToNot(HaveOccurred())
go process.Wait()
})
AfterEach(func() {
Expect(gardenClient.Destroy(container.Handle())).To(Succeed())
})
RunSpecs(t, "Performance Suite")
}
func Start(bin, initBin, nstarBin, dadooBin, grootfsBin, rootfs, tarBin string, argv ...string) *RunningGarden {
runner := NewGardenRunner(bin, initBin, nstarBin, dadooBin, grootfsBin, rootfs, tarBin, "unix", fmt.Sprintf("/tmp/garden_%d.sock", GinkgoParallelNode()), argv...)
r := &RunningGarden{
runner: runner,
DepotDir: runner.DepotDir,
DataDir: DataDir,
GraphPath: runner.GraphPath,
Tmpdir: runner.TmpDir,
logger: lagertest.NewTestLogger("garden-runner"),
debugIP: runner.DebugIp,
debugPort: runner.DebugPort,
Client: client.New(connection.New(runner.Network, runner.Addr)),
}
r.process = ifrit.Invoke(r.runner)
r.Pid = runner.Cmd.Process.Pid
return r
}
})
XContext("when passed a socket", func() {
It("listens on the given socket path and chmods it to 0777", func() {
var err error
tmpdir, err = ioutil.TempDir(os.TempDir(), "api-server-test")
Ω(err).ShouldNot(HaveOccurred())
socketPath := path.Join(tmpdir, "api.sock")
apiServer := server.New("unix", socketPath, 0, new(fakes.FakeBackend), logger)
err = apiServer.Start()
Ω(err).ShouldNot(HaveOccurred())
apiClient = client.New(connection.New("unix", socketPath))
Eventually(apiClient.Ping).Should(Succeed())
stat, err := os.Stat(socketPath)
Ω(err).ShouldNot(HaveOccurred())
Ω(int(stat.Mode() & 0777)).Should(Equal(0777))
})
It("deletes the socket file if it is already there", func() {
var err error
tmpdir, err = ioutil.TempDir(os.TempDir(), "api-server-test")
Ω(err).ShouldNot(HaveOccurred())
socketPath := path.Join(tmpdir, "api.sock")