args = append(args, "--properties-path", path.Join(propertiesDir, "props.json"))
containerSpec = garden.ContainerSpec{
Network: "177.100.10.30/30",
}
restartArgs = []string{}
gracefulShutdown = true
})
JustBeforeEach(func() {
var err error
container, err = client.Create(containerSpec)
Expect(err).NotTo(HaveOccurred())
hostNetInPort, _, err = container.NetIn(hostNetInPort, 8080)
Expect(err).NotTo(HaveOccurred())
container.NetOut(garden.NetOutRule{
Networks: []garden.IPRange{
garden.IPRangeFromIP(net.ParseIP("8.8.8.8")),
},
})
info, err := container.Info()
Expect(err).NotTo(HaveOccurred())
externalIP = info.ExternalIP
interfacePrefix = info.Properties["kawasaki.iptable-prefix"]
out := gbytes.NewBuffer()
existingProc, err = container.Run(
Expect(err).NotTo(HaveOccurred())
Expect(info.ContainerPath).To(Equal(path.Join(client.DepotDir, container.Handle())))
})
It("can return the list of properties", func() {
Expect(container.SetProperty("abc", "xyz")).To(Succeed())
info, err := container.Info()
Expect(err).NotTo(HaveOccurred())
Expect(info.Properties).To(HaveKeyWithValue("foo", "bar"))
Expect(info.Properties).To(HaveKeyWithValue("abc", "xyz"))
})
It("can return port mappings", func() {
hostPort, containerPort, err := container.NetIn(0, 0)
Expect(err).NotTo(HaveOccurred())
info, err := container.Info()
Expect(err).NotTo(HaveOccurred())
portMapping := info.MappedPorts[0]
Expect(portMapping.HostPort).To(Equal(hostPort))
Expect(portMapping.ContainerPort).To(Equal(containerPort))
})
})
var _ = Describe("BulkInfo", func() {
var (
client *runner.RunningGarden
)
Ω(process.ID()).Should(Equal("process-handle"))
status, err := process.Wait()
Ω(err).ShouldNot(HaveOccurred())
Ω(status).Should(Equal(123))
Eventually(stdout).Should(gbytes.Say("stdout data"))
Eventually(stderr).Should(gbytes.Say("stderr data"))
})
})
Describe("NetIn", func() {
It("sends a net in request", func() {
fakeConnection.NetInReturns(111, 222, nil)
hostPort, containerPort, err := container.NetIn(123, 456)
Ω(err).ShouldNot(HaveOccurred())
Ω(hostPort).Should(Equal(uint32(111)))
Ω(containerPort).Should(Equal(uint32(222)))
h, hp, cp := fakeConnection.NetInArgsForCall(0)
Ω(h).Should(Equal("some-handle"))
Ω(hp).Should(Equal(uint32(123)))
Ω(cp).Should(Equal(uint32(456)))
})
Context("when the request fails", func() {
disaster := errors.New("oh no!")
BeforeEach(func() {
fakeConnection.NetInReturns(0, 0, disaster)
Expect(client.Destroy(container.Handle())).To(Succeed())
container, err = client.Create(garden.ContainerSpec{
Network: containerNetwork,
})
Expect(err).ToNot(HaveOccurred())
})
It("reuses IP addresses", func() {
newIpAddress := containerIP(container)
Expect(newIpAddress).To(Equal(contIP))
})
It("is accessible from the outside", func() {
hostPort, containerPort, err := container.NetIn(0, 4321)
Expect(err).ToNot(HaveOccurred())
Expect(listenInContainer(container, containerPort)).To(Succeed())
externalIP := externalIP(container)
// retry because listener process inside other container
// may not start immediately
Eventually(func() int {
session := sendRequest(externalIP, hostPort)
return session.Wait().ExitCode()
}).Should(Equal(0))
})
})