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(
garden.ProcessSpec{
Path: "/bin/sh",
Args: []string{"-c", "while true; do echo hello; sleep 1; done;"},
},
garden.ProcessIO{
package garden_test
import (
"net"
"code.cloudfoundry.org/garden"
. "github.com/onsi/ginkgo"
. "github.com/onsi/gomega"
)
var _ = Describe("NetOutRule helper functions", func() {
Describe("IPRangeFromIP", func() {
It("Creates an IPRange with the Start and End set to the passed IP", func() {
r := garden.IPRangeFromIP(net.ParseIP("1.2.3.4"))
Ω(r.Start).Should(Equal(net.ParseIP("1.2.3.4")))
Ω(r.End).Should(Equal(r.Start))
})
})
Describe("IPRangeFromIPNet", func() {
It("Creates an IPRange with the Start and End set to the extent of the IPNet", func() {
ip, cidr, err := net.ParseCIDR("1.2.3.0/24")
Ω(err).Should(Succeed())
r := garden.IPRangeFromIPNet(cidr)
Ω(r.Start.String()).Should(Equal(ip.String()))
Ω(r.End.String()).Should(Equal("1.2.3.255"))
})
})
Describe("PortRangeFromPort", func() {
BeforeEach(func() {
fakeConnection.NetInReturns(0, 0, disaster)
})
It("returns the error", func() {
_, _, err := container.NetIn(123, 456)
Ω(err).Should(Equal(disaster))
})
})
})
Describe("NetOut", func() {
It("sends NetOut requests over the connection", func() {
Ω(container.NetOut(garden.NetOutRule{
Networks: []garden.IPRange{garden.IPRangeFromIP(net.ParseIP("1.2.3.4"))},
Ports: []garden.PortRange{
{Start: 12, End: 24},
},
Log: true,
})).Should(Succeed())
h, rule := fakeConnection.NetOutArgsForCall(0)
Ω(h).Should(Equal("some-handle"))
Ω(rule.Networks).Should(HaveLen(1))
Ω(rule.Networks[0]).Should(Equal(garden.IPRange{Start: net.ParseIP("1.2.3.4"), End: net.ParseIP("1.2.3.4")}))
Ω(rule.Ports).Should(HaveLen(1))
Ω(rule.Ports[0]).Should(Equal(garden.PortRange{Start: 12, End: 24}))
b.RecordValue("time in calculation", dur.Seconds())
// Once we have a good baseline...
//Expect(timed).To(BeNumerically(",", ???))
//Expect(b.Seconds()).To(BeNumerically(",", ???))
}, 20)
})
Measure("BulkNetOut", func(b Benchmarker) {
b.Time("3000 rules", func() {
rules := make([]garden.NetOutRule, 0)
for i := 0; i < 3000; i++ {
rules = append(rules, garden.NetOutRule{
Protocol: garden.ProtocolTCP,
Networks: []garden.IPRange{garden.IPRangeFromIP(net.ParseIP("8.8.8.8"))},
Ports: []garden.PortRange{garden.PortRangeFromPort(uint16(i))},
})
}
container, err := gardenClient.Create(garden.ContainerSpec{})
Expect(err).ToNot(HaveOccurred())
Expect(container.BulkNetOut(rules)).To(Succeed())
Expect(gardenClient.Destroy(container.Handle())).To(Succeed())
})
}, 5)
})
func emitMetric(req interface{}) {