698 lines
23 KiB
Go
698 lines
23 KiB
Go
// Copyright 2015 CNI authors
|
|
//
|
|
// Licensed under the Apache License, Version 2.0 (the "License");
|
|
// you may not use this file except in compliance with the License.
|
|
// You may obtain a copy of the License at
|
|
//
|
|
// http://www.apache.org/licenses/LICENSE-2.0
|
|
//
|
|
// Unless required by applicable law or agreed to in writing, software
|
|
// distributed under the License is distributed on an "AS IS" BASIS,
|
|
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
|
// See the License for the specific language governing permissions and
|
|
// limitations under the License.
|
|
package main
|
|
|
|
import (
|
|
"encoding/json"
|
|
"fmt"
|
|
"io/ioutil"
|
|
"os"
|
|
|
|
"github.com/containernetworking/cni/pkg/skel"
|
|
current "github.com/containernetworking/cni/pkg/types/100"
|
|
"github.com/containernetworking/plugins/pkg/ns"
|
|
"github.com/containernetworking/plugins/pkg/testutils"
|
|
|
|
. "github.com/onsi/ginkgo"
|
|
. "github.com/onsi/gomega"
|
|
)
|
|
|
|
var _ = Describe("Flannel", func() {
|
|
var (
|
|
originalNS ns.NetNS
|
|
targetNS ns.NetNS
|
|
onlyIpv4Input string
|
|
onlyIpv6Input string
|
|
dualStackInput string
|
|
onlyIpv4SubnetFile string
|
|
onlyIpv6SubnetFile string
|
|
dualStackSubnetFile string
|
|
dataDir string
|
|
)
|
|
|
|
const inputTemplate = `{
|
|
"name": "cni-flannel",
|
|
"type": "flannel",
|
|
"cniVersion": "%s",
|
|
"subnetFile": "%s",
|
|
"dataDir": "%s"%s
|
|
}`
|
|
|
|
const inputIPAMTemplate = `
|
|
"unknown-param": "unknown-value",
|
|
"routes": [%s]%s`
|
|
|
|
const inputIPAMType = "my-ipam"
|
|
|
|
const inputIPAMNoTypeTemplate = `
|
|
{
|
|
"unknown-param": "unknown-value",
|
|
"routes": [%s]%s
|
|
}`
|
|
|
|
const inputIPAMRoutes = `
|
|
{ "dst": "10.96.0.0/12" },
|
|
{ "dst": "192.168.244.0/24", "gw": "10.1.17.20" }`
|
|
|
|
const onlyIpv4FlannelSubnetEnv = `
|
|
FLANNEL_NETWORK=10.1.0.0/16
|
|
FLANNEL_SUBNET=10.1.17.1/24
|
|
FLANNEL_MTU=1472
|
|
FLANNEL_IPMASQ=true
|
|
`
|
|
const onlyIpv6FlannelSubnetEnv = `
|
|
FLANNEL_IPV6_NETWORK=fc00::/48
|
|
FLANNEL_IPV6_SUBNET=fc00::1/64
|
|
FLANNEL_MTU=1472
|
|
FLANNEL_IPMASQ=true
|
|
`
|
|
const dualStackFlannelSubnetEnv = `
|
|
FLANNEL_NETWORK=10.1.0.0/16
|
|
FLANNEL_SUBNET=10.1.17.1/24
|
|
FLANNEL_IPV6_NETWORK=fc00::/48
|
|
FLANNEL_IPV6_SUBNET=fc00::1/64
|
|
FLANNEL_MTU=1472
|
|
FLANNEL_IPMASQ=true
|
|
`
|
|
|
|
const IFNAME = "eth0"
|
|
|
|
var writeSubnetEnv = func(contents string) string {
|
|
file, err := ioutil.TempFile("", "subnet.env")
|
|
Expect(err).NotTo(HaveOccurred())
|
|
_, err = file.WriteString(contents)
|
|
Expect(err).NotTo(HaveOccurred())
|
|
return file.Name()
|
|
}
|
|
|
|
var makeInputIPAM = func(ipamType, routes, extra string) string {
|
|
c := "{\n"
|
|
if len(ipamType) > 0 {
|
|
c += fmt.Sprintf(" \"type\": \"%s\",", ipamType)
|
|
}
|
|
c += fmt.Sprintf(inputIPAMTemplate, routes, extra)
|
|
c += "\n}"
|
|
|
|
return c
|
|
}
|
|
|
|
var makeInput = func(cniVersion, inputIPAM string, subnetFile string) string {
|
|
ipamPart := ""
|
|
if len(inputIPAM) > 0 {
|
|
ipamPart = ",\n \"ipam\":\n" + inputIPAM
|
|
}
|
|
|
|
return fmt.Sprintf(inputTemplate, cniVersion, subnetFile, dataDir, ipamPart)
|
|
}
|
|
|
|
var makeHostLocalIPAM = func(dataDir string) string {
|
|
return fmt.Sprintf(`{
|
|
"type": "host-local",
|
|
"dataDir": "%s"
|
|
}`, dataDir)
|
|
}
|
|
|
|
BeforeEach(func() {
|
|
var err error
|
|
originalNS, err = testutils.NewNS()
|
|
Expect(err).NotTo(HaveOccurred())
|
|
targetNS, err = testutils.NewNS()
|
|
Expect(err).NotTo(HaveOccurred())
|
|
|
|
// flannel subnet.env
|
|
onlyIpv4SubnetFile = writeSubnetEnv(onlyIpv4FlannelSubnetEnv)
|
|
onlyIpv6SubnetFile = writeSubnetEnv(onlyIpv6FlannelSubnetEnv)
|
|
dualStackSubnetFile = writeSubnetEnv(dualStackFlannelSubnetEnv)
|
|
|
|
// flannel state dir
|
|
dataDir, err = ioutil.TempDir("", "dataDir")
|
|
Expect(err).NotTo(HaveOccurred())
|
|
})
|
|
|
|
AfterEach(func() {
|
|
Expect(targetNS.Close()).To(Succeed())
|
|
Expect(testutils.UnmountNS(targetNS)).To(Succeed())
|
|
Expect(originalNS.Close()).To(Succeed())
|
|
Expect(testutils.UnmountNS(originalNS)).To(Succeed())
|
|
|
|
os.Remove(onlyIpv4SubnetFile)
|
|
os.Remove(onlyIpv6SubnetFile)
|
|
os.Remove(dualStackSubnetFile)
|
|
Expect(os.RemoveAll(dataDir)).To(Succeed())
|
|
})
|
|
|
|
Describe("CNI lifecycle", func() {
|
|
for _, ver := range testutils.AllSpecVersions {
|
|
// Redefine ver inside for scope so real value is picked up by each dynamically defined It()
|
|
// See Gingkgo's "Patterns for dynamically generating tests" documentation.
|
|
ver := ver
|
|
|
|
Context("when using only ipv4 stack", func() {
|
|
It(fmt.Sprintf("[%s] uses dataDir for storing network configuration with ipv4 stack", ver), func() {
|
|
inputIPAM := makeHostLocalIPAM(dataDir)
|
|
args := &skel.CmdArgs{
|
|
ContainerID: "some-container-id-ipv4",
|
|
Netns: targetNS.Path(),
|
|
IfName: IFNAME,
|
|
StdinData: []byte(makeInput(ver, inputIPAM, onlyIpv4SubnetFile)),
|
|
}
|
|
|
|
err := originalNS.Do(func(ns.NetNS) error {
|
|
defer GinkgoRecover()
|
|
|
|
By("calling ADD with ipv4 stack")
|
|
GinkgoT().Logf("dataDir is %s", dataDir)
|
|
GinkgoT().Logf("conf is %s", args.StdinData)
|
|
resI, _, err := testutils.CmdAddWithArgs(args, func() error {
|
|
return cmdAdd(args)
|
|
})
|
|
Expect(err).NotTo(HaveOccurred())
|
|
|
|
By("check that plugin writes the net config to dataDir with ipv4 stack")
|
|
path := fmt.Sprintf("%s/%s", dataDir, "some-container-id-ipv4")
|
|
Expect(path).Should(BeAnExistingFile())
|
|
|
|
netConfBytes, err := ioutil.ReadFile(path)
|
|
Expect(err).NotTo(HaveOccurred())
|
|
expected := fmt.Sprintf(`{
|
|
"cniVersion": "%s",
|
|
"ipMasq": false,
|
|
"ipam": {
|
|
"routes": [
|
|
{
|
|
"dst": "10.1.0.0/16"
|
|
}
|
|
],
|
|
"ranges": [
|
|
[{
|
|
"subnet": "10.1.17.0/24"
|
|
}]
|
|
],
|
|
"type": "host-local",
|
|
"dataDir": "%s"
|
|
},
|
|
"isGateway": true,
|
|
"mtu": 1472,
|
|
"name": "cni-flannel",
|
|
"type": "bridge"
|
|
}`, ver, dataDir)
|
|
Expect(netConfBytes).Should(MatchJSON(expected))
|
|
|
|
result, err := current.NewResultFromResult(resI)
|
|
Expect(err).NotTo(HaveOccurred())
|
|
Expect(result.IPs).To(HaveLen(1))
|
|
|
|
By("calling DEL with ipv4 stack")
|
|
err = testutils.CmdDelWithArgs(args, func() error {
|
|
return cmdDel(args)
|
|
})
|
|
Expect(err).NotTo(HaveOccurred())
|
|
|
|
By("check that plugin removes net config from state dir with ipv4 stack")
|
|
Expect(path).ShouldNot(BeAnExistingFile())
|
|
|
|
By("calling DEL again with ipv4 stack")
|
|
err = testutils.CmdDelWithArgs(args, func() error {
|
|
return cmdDel(args)
|
|
})
|
|
By("check that plugin does not fail due to missing net config with ipv4 stack")
|
|
Expect(err).NotTo(HaveOccurred())
|
|
|
|
return nil
|
|
})
|
|
Expect(err).NotTo(HaveOccurred())
|
|
})
|
|
})
|
|
|
|
Context("when using only ipv6 stack", func() {
|
|
It(fmt.Sprintf("[%s] uses dataDir for storing network configuration with ipv6 stack", ver), func() {
|
|
inputIPAM := makeHostLocalIPAM(dataDir)
|
|
args := &skel.CmdArgs{
|
|
ContainerID: "some-container-id-ipv6",
|
|
Netns: targetNS.Path(),
|
|
IfName: IFNAME,
|
|
StdinData: []byte(makeInput(ver, inputIPAM, onlyIpv6SubnetFile)),
|
|
}
|
|
|
|
err := originalNS.Do(func(ns.NetNS) error {
|
|
defer GinkgoRecover()
|
|
|
|
By("calling ADD with ipv6 stack")
|
|
resI, _, err := testutils.CmdAddWithArgs(args, func() error {
|
|
return cmdAdd(args)
|
|
})
|
|
Expect(err).NotTo(HaveOccurred())
|
|
|
|
By("check that plugin writes the net config to dataDir with ipv6 stack")
|
|
path := fmt.Sprintf("%s/%s", dataDir, "some-container-id-ipv6")
|
|
Expect(path).Should(BeAnExistingFile())
|
|
|
|
netConfBytes, err := ioutil.ReadFile(path)
|
|
Expect(err).NotTo(HaveOccurred())
|
|
expected := fmt.Sprintf(`{
|
|
"cniVersion": "%s",
|
|
"ipMasq": false,
|
|
"ipam": {
|
|
"routes": [
|
|
{
|
|
"dst": "fc00::/48"
|
|
}
|
|
],
|
|
"ranges": [
|
|
[{
|
|
"subnet": "fc00::/64"
|
|
}]
|
|
],
|
|
"type": "host-local",
|
|
"dataDir": "%s"
|
|
},
|
|
"isGateway": true,
|
|
"mtu": 1472,
|
|
"name": "cni-flannel",
|
|
"type": "bridge"
|
|
}`, ver, dataDir)
|
|
Expect(netConfBytes).Should(MatchJSON(expected))
|
|
|
|
result, err := current.NewResultFromResult(resI)
|
|
Expect(err).NotTo(HaveOccurred())
|
|
Expect(result.IPs).To(HaveLen(1))
|
|
|
|
By("calling DEL with ipv6 stack")
|
|
err = testutils.CmdDelWithArgs(args, func() error {
|
|
return cmdDel(args)
|
|
})
|
|
Expect(err).NotTo(HaveOccurred())
|
|
|
|
By("check that plugin removes net config from state dir with ipv6 stack")
|
|
Expect(path).ShouldNot(BeAnExistingFile())
|
|
|
|
By("calling DEL again with ipv6 stack")
|
|
err = testutils.CmdDelWithArgs(args, func() error {
|
|
return cmdDel(args)
|
|
})
|
|
By("check that plugin does not fail due to missing net config with ipv6 stack")
|
|
Expect(err).NotTo(HaveOccurred())
|
|
|
|
return nil
|
|
})
|
|
Expect(err).NotTo(HaveOccurred())
|
|
})
|
|
})
|
|
|
|
Context("when using dual stack", func() {
|
|
It(fmt.Sprintf("[%s] uses dataDir for storing network configuration with dual stack", ver), func() {
|
|
inputIPAM := makeHostLocalIPAM(dataDir)
|
|
args := &skel.CmdArgs{
|
|
ContainerID: "some-container-id-dual-stack",
|
|
Netns: targetNS.Path(),
|
|
IfName: IFNAME,
|
|
StdinData: []byte(makeInput(ver, inputIPAM, dualStackSubnetFile)),
|
|
}
|
|
|
|
err := originalNS.Do(func(ns.NetNS) error {
|
|
defer GinkgoRecover()
|
|
|
|
By("calling ADD with dual stack")
|
|
resI, _, err := testutils.CmdAddWithArgs(args, func() error {
|
|
return cmdAdd(args)
|
|
})
|
|
Expect(err).NotTo(HaveOccurred())
|
|
|
|
By("check that plugin writes the net config to dataDir with dual stack")
|
|
path := fmt.Sprintf("%s/%s", dataDir, "some-container-id-dual-stack")
|
|
Expect(path).Should(BeAnExistingFile())
|
|
|
|
netConfBytes, err := ioutil.ReadFile(path)
|
|
Expect(err).NotTo(HaveOccurred())
|
|
expected := fmt.Sprintf(`{
|
|
"cniVersion": "%s",
|
|
"ipMasq": false,
|
|
"ipam": {
|
|
"routes": [
|
|
{
|
|
"dst": "10.1.0.0/16"
|
|
},
|
|
{
|
|
"dst": "fc00::/48"
|
|
}
|
|
],
|
|
"ranges": [
|
|
[{
|
|
"subnet": "10.1.17.0/24"
|
|
}],
|
|
[{
|
|
"subnet": "fc00::/64"
|
|
}]
|
|
],
|
|
"type": "host-local",
|
|
"dataDir": "%s"
|
|
},
|
|
"isGateway": true,
|
|
"mtu": 1472,
|
|
"name": "cni-flannel",
|
|
"type": "bridge"
|
|
}`, ver, dataDir)
|
|
Expect(netConfBytes).Should(MatchJSON(expected))
|
|
|
|
result, err := current.NewResultFromResult(resI)
|
|
Expect(err).NotTo(HaveOccurred())
|
|
Expect(result.IPs).To(HaveLen(2))
|
|
|
|
By("calling DEL with dual stack")
|
|
err = testutils.CmdDelWithArgs(args, func() error {
|
|
return cmdDel(args)
|
|
})
|
|
Expect(err).NotTo(HaveOccurred())
|
|
|
|
By("check that plugin removes net config from state dir with dual stack")
|
|
Expect(path).ShouldNot(BeAnExistingFile())
|
|
|
|
By("calling DEL again with dual stack")
|
|
err = testutils.CmdDelWithArgs(args, func() error {
|
|
return cmdDel(args)
|
|
})
|
|
By("check that plugin does not fail due to missing net config with dual stack")
|
|
Expect(err).NotTo(HaveOccurred())
|
|
|
|
return nil
|
|
})
|
|
Expect(err).NotTo(HaveOccurred())
|
|
})
|
|
})
|
|
}
|
|
})
|
|
|
|
Describe("loadFlannelNetConf", func() {
|
|
var (
|
|
onlyIpv4Input string
|
|
onlyIpv6Input string
|
|
dualStackInput string
|
|
)
|
|
|
|
BeforeEach(func() {
|
|
onlyIpv4Input = makeInput(current.ImplementedSpecVersion, "", onlyIpv4SubnetFile)
|
|
onlyIpv6Input = makeInput(current.ImplementedSpecVersion, "", onlyIpv6SubnetFile)
|
|
dualStackInput = makeInput(current.ImplementedSpecVersion, "", dualStackSubnetFile)
|
|
})
|
|
|
|
Context("when subnetFile and dataDir are specified with ipv4 stack", func() {
|
|
It("loads flannel network config with ipv4 stack", func() {
|
|
conf, err := loadFlannelNetConf([]byte(onlyIpv4Input))
|
|
Expect(err).ShouldNot(HaveOccurred())
|
|
Expect(conf.Name).To(Equal("cni-flannel"))
|
|
Expect(conf.Type).To(Equal("flannel"))
|
|
Expect(conf.SubnetFile).To(Equal(onlyIpv4SubnetFile))
|
|
Expect(conf.DataDir).To(Equal(dataDir))
|
|
})
|
|
})
|
|
|
|
Context("when subnetFile and dataDir are specified with ipv6 stack", func() {
|
|
It("loads flannel network config with ipv6 stack", func() {
|
|
conf, err := loadFlannelNetConf([]byte(onlyIpv6Input))
|
|
Expect(err).ShouldNot(HaveOccurred())
|
|
Expect(conf.Name).To(Equal("cni-flannel"))
|
|
Expect(conf.Type).To(Equal("flannel"))
|
|
Expect(conf.SubnetFile).To(Equal(onlyIpv6SubnetFile))
|
|
Expect(conf.DataDir).To(Equal(dataDir))
|
|
})
|
|
})
|
|
|
|
Context("when subnetFile and dataDir are specified with dual stack", func() {
|
|
It("loads flannel network config with dual stack", func() {
|
|
conf, err := loadFlannelNetConf([]byte(dualStackInput))
|
|
Expect(err).ShouldNot(HaveOccurred())
|
|
Expect(conf.Name).To(Equal("cni-flannel"))
|
|
Expect(conf.Type).To(Equal("flannel"))
|
|
Expect(conf.SubnetFile).To(Equal(dualStackSubnetFile))
|
|
Expect(conf.DataDir).To(Equal(dataDir))
|
|
})
|
|
})
|
|
|
|
Context("when defaulting subnetFile and dataDir with ipv4 stack", func() {
|
|
BeforeEach(func() {
|
|
onlyIpv4Input = `{
|
|
"name": "cni-flannel",
|
|
"type": "flannel"
|
|
}`
|
|
})
|
|
|
|
It("loads flannel network config with defaults with ipv4 stack", func() {
|
|
conf, err := loadFlannelNetConf([]byte(onlyIpv4Input))
|
|
Expect(err).ShouldNot(HaveOccurred())
|
|
Expect(conf.Name).To(Equal("cni-flannel"))
|
|
Expect(conf.Type).To(Equal("flannel"))
|
|
Expect(conf.SubnetFile).To(Equal(defaultSubnetFile))
|
|
Expect(conf.DataDir).To(Equal(defaultDataDir))
|
|
})
|
|
})
|
|
|
|
Context("when defaulting subnetFile and dataDir with ipv6 stack", func() {
|
|
BeforeEach(func() {
|
|
onlyIpv6Input = `{
|
|
"name": "cni-flannel",
|
|
"type": "flannel"
|
|
}`
|
|
})
|
|
|
|
It("loads flannel network config with defaults with ipv6 stack", func() {
|
|
conf, err := loadFlannelNetConf([]byte(onlyIpv6Input))
|
|
Expect(err).ShouldNot(HaveOccurred())
|
|
Expect(conf.Name).To(Equal("cni-flannel"))
|
|
Expect(conf.Type).To(Equal("flannel"))
|
|
Expect(conf.SubnetFile).To(Equal(defaultSubnetFile))
|
|
Expect(conf.DataDir).To(Equal(defaultDataDir))
|
|
})
|
|
})
|
|
|
|
Context("when defaulting subnetFile and dataDir with dual stack", func() {
|
|
BeforeEach(func() {
|
|
dualStackInput = `{
|
|
"name": "cni-flannel",
|
|
"type": "flannel"
|
|
}`
|
|
})
|
|
|
|
It("loads flannel network config with defaults with dual stack", func() {
|
|
conf, err := loadFlannelNetConf([]byte(dualStackInput))
|
|
Expect(err).ShouldNot(HaveOccurred())
|
|
Expect(conf.Name).To(Equal("cni-flannel"))
|
|
Expect(conf.Type).To(Equal("flannel"))
|
|
Expect(conf.SubnetFile).To(Equal(defaultSubnetFile))
|
|
Expect(conf.DataDir).To(Equal(defaultDataDir))
|
|
})
|
|
})
|
|
|
|
Describe("loadFlannelSubnetEnv", func() {
|
|
Context("when flannel subnet env is valid with ipv4 stack", func() {
|
|
It("loads flannel subnet config with ipv4 stack", func() {
|
|
conf, err := loadFlannelSubnetEnv(onlyIpv4SubnetFile)
|
|
Expect(err).ShouldNot(HaveOccurred())
|
|
Expect(conf.nw.String()).To(Equal("10.1.0.0/16"))
|
|
Expect(conf.sn.String()).To(Equal("10.1.17.0/24"))
|
|
var mtu uint = 1472
|
|
Expect(*conf.mtu).To(Equal(mtu))
|
|
Expect(*conf.ipmasq).To(BeTrue())
|
|
})
|
|
})
|
|
|
|
Context("when flannel subnet env is valid with ipv6 stack", func() {
|
|
It("loads flannel subnet config with ipv6 stack", func() {
|
|
conf, err := loadFlannelSubnetEnv(onlyIpv6SubnetFile)
|
|
Expect(err).ShouldNot(HaveOccurred())
|
|
Expect(conf.ip6Nw.String()).To(Equal("fc00::/48"))
|
|
Expect(conf.ip6Sn.String()).To(Equal("fc00::/64"))
|
|
var mtu uint = 1472
|
|
Expect(*conf.mtu).To(Equal(mtu))
|
|
Expect(*conf.ipmasq).To(BeTrue())
|
|
})
|
|
})
|
|
|
|
Context("when flannel subnet env is valid with dual stack", func() {
|
|
It("loads flannel subnet config with dual stack", func() {
|
|
conf, err := loadFlannelSubnetEnv(dualStackSubnetFile)
|
|
Expect(err).ShouldNot(HaveOccurred())
|
|
Expect(conf.nw.String()).To(Equal("10.1.0.0/16"))
|
|
Expect(conf.sn.String()).To(Equal("10.1.17.0/24"))
|
|
Expect(conf.ip6Nw.String()).To(Equal("fc00::/48"))
|
|
Expect(conf.ip6Sn.String()).To(Equal("fc00::/64"))
|
|
var mtu uint = 1472
|
|
Expect(*conf.mtu).To(Equal(mtu))
|
|
Expect(*conf.ipmasq).To(BeTrue())
|
|
})
|
|
})
|
|
|
|
Context("when flannel subnet env is invalid with ipv4 stack", func() {
|
|
BeforeEach(func() {
|
|
onlyIpv4SubnetFile = writeSubnetEnv("foo=bar")
|
|
})
|
|
It("returns an error", func() {
|
|
_, err := loadFlannelSubnetEnv(onlyIpv4SubnetFile)
|
|
Expect(err).To(MatchError(ContainSubstring("missing FLANNEL_NETWORK, FLANNEL_IPV6_NETWORK, FLANNEL_SUBNET, FLANNEL_IPV6_SUBNET, FLANNEL_MTU, FLANNEL_IPMASQ")))
|
|
})
|
|
})
|
|
|
|
Context("when flannel subnet env is invalid with ipv6 stack", func() {
|
|
BeforeEach(func() {
|
|
onlyIpv6SubnetFile = writeSubnetEnv("foo=bar")
|
|
})
|
|
It("returns an error", func() {
|
|
_, err := loadFlannelSubnetEnv(onlyIpv6SubnetFile)
|
|
Expect(err).To(MatchError(ContainSubstring("missing FLANNEL_NETWORK, FLANNEL_IPV6_NETWORK, FLANNEL_SUBNET, FLANNEL_IPV6_SUBNET, FLANNEL_MTU, FLANNEL_IPMASQ")))
|
|
})
|
|
})
|
|
|
|
Context("when flannel subnet env is invalid with dual stack", func() {
|
|
BeforeEach(func() {
|
|
dualStackSubnetFile = writeSubnetEnv("foo=bar")
|
|
})
|
|
It("returns an error", func() {
|
|
_, err := loadFlannelSubnetEnv(dualStackSubnetFile)
|
|
Expect(err).To(MatchError(ContainSubstring("missing FLANNEL_NETWORK, FLANNEL_IPV6_NETWORK, FLANNEL_SUBNET, FLANNEL_IPV6_SUBNET, FLANNEL_MTU, FLANNEL_IPMASQ")))
|
|
})
|
|
})
|
|
})
|
|
})
|
|
|
|
Describe("getDelegateIPAM", func() {
|
|
Context("when input IPAM is provided with ipv4 stack", func() {
|
|
BeforeEach(func() {
|
|
inputIPAM := makeInputIPAM(inputIPAMType, inputIPAMRoutes, "")
|
|
onlyIpv4Input = makeInput(current.ImplementedSpecVersion, inputIPAM, onlyIpv4SubnetFile)
|
|
})
|
|
It("configures Delegate IPAM accordingly with ipv4 stack", func() {
|
|
conf, err := loadFlannelNetConf([]byte(onlyIpv4Input))
|
|
Expect(err).ShouldNot(HaveOccurred())
|
|
fenv, err := loadFlannelSubnetEnv(onlyIpv4SubnetFile)
|
|
Expect(err).ShouldNot(HaveOccurred())
|
|
|
|
ipam, err := getDelegateIPAM(conf, fenv)
|
|
Expect(err).ShouldNot(HaveOccurred())
|
|
|
|
podsRoute := "{ \"dst\": \"10.1.0.0/16\" }\n"
|
|
subnet := "\"ranges\": [[{\"subnet\": \"10.1.17.0/24\"}]]"
|
|
expected := makeInputIPAM(inputIPAMType, inputIPAMRoutes+",\n"+podsRoute, ",\n"+subnet)
|
|
buf, _ := json.Marshal(ipam)
|
|
Expect(buf).Should(MatchJSON(expected))
|
|
})
|
|
})
|
|
|
|
Context("when input IPAM is provided with ipv6 stack", func() {
|
|
BeforeEach(func() {
|
|
inputIPAM := makeInputIPAM(inputIPAMType, inputIPAMRoutes, "")
|
|
onlyIpv6Input = makeInput(current.ImplementedSpecVersion, inputIPAM, onlyIpv6SubnetFile)
|
|
})
|
|
It("configures Delegate IPAM accordingly with ipv6 stack", func() {
|
|
conf, err := loadFlannelNetConf([]byte(onlyIpv6Input))
|
|
Expect(err).ShouldNot(HaveOccurred())
|
|
fenv, err := loadFlannelSubnetEnv(onlyIpv6SubnetFile)
|
|
Expect(err).ShouldNot(HaveOccurred())
|
|
|
|
ipam, err := getDelegateIPAM(conf, fenv)
|
|
Expect(err).ShouldNot(HaveOccurred())
|
|
|
|
podsRoute := "{ \"dst\": \"fc00::/48\" }\n"
|
|
subnet := "\"ranges\": [[{ \"subnet\": \"fc00::/64\" }]]"
|
|
expected := makeInputIPAM(inputIPAMType, inputIPAMRoutes+",\n"+podsRoute, ",\n"+subnet)
|
|
buf, _ := json.Marshal(ipam)
|
|
Expect(buf).Should(MatchJSON(expected))
|
|
})
|
|
})
|
|
|
|
Context("when input IPAM is provided with dual stack", func() {
|
|
BeforeEach(func() {
|
|
inputIPAM := makeInputIPAM(inputIPAMType, inputIPAMRoutes, "")
|
|
dualStackInput = makeInput(current.ImplementedSpecVersion, inputIPAM, dualStackSubnetFile)
|
|
})
|
|
It("configures Delegate IPAM accordingly with dual stack", func() {
|
|
conf, err := loadFlannelNetConf([]byte(dualStackInput))
|
|
Expect(err).ShouldNot(HaveOccurred())
|
|
fenv, err := loadFlannelSubnetEnv(dualStackSubnetFile)
|
|
Expect(err).ShouldNot(HaveOccurred())
|
|
|
|
ipam, err := getDelegateIPAM(conf, fenv)
|
|
Expect(err).ShouldNot(HaveOccurred())
|
|
|
|
podsRoute := "{ \"dst\": \"10.1.0.0/16\" }" + ",\n" + "{ \"dst\": \"fc00::/48\" }\n"
|
|
subnet := "\"ranges\": [[{ \"subnet\": \"10.1.17.0/24\" }],\n[{ \"subnet\": \"fc00::/64\" }]]"
|
|
expected := makeInputIPAM(inputIPAMType, inputIPAMRoutes+",\n"+podsRoute, ",\n"+subnet)
|
|
buf, _ := json.Marshal(ipam)
|
|
Expect(buf).Should(MatchJSON(expected))
|
|
})
|
|
})
|
|
|
|
Context("when input IPAM is provided without 'type' with ipv4 stack", func() {
|
|
BeforeEach(func() {
|
|
inputIPAM := makeInputIPAM("", inputIPAMRoutes, "")
|
|
onlyIpv4Input = makeInput(current.ImplementedSpecVersion, inputIPAM, onlyIpv4SubnetFile)
|
|
})
|
|
It("configures Delegate IPAM with 'host-local' ipam with ipv4 stack", func() {
|
|
conf, err := loadFlannelNetConf([]byte(onlyIpv4Input))
|
|
Expect(err).ShouldNot(HaveOccurred())
|
|
fenv, err := loadFlannelSubnetEnv(onlyIpv4SubnetFile)
|
|
Expect(err).ShouldNot(HaveOccurred())
|
|
ipam, err := getDelegateIPAM(conf, fenv)
|
|
Expect(err).ShouldNot(HaveOccurred())
|
|
|
|
podsRoute := "{ \"dst\": \"10.1.0.0/16\" }\n"
|
|
subnet := "\"ranges\": [[{\"subnet\": \"10.1.17.0/24\"}]]"
|
|
expected := makeInputIPAM("host-local", inputIPAMRoutes+",\n"+podsRoute, ",\n"+subnet)
|
|
buf, _ := json.Marshal(ipam)
|
|
Expect(buf).Should(MatchJSON(expected))
|
|
})
|
|
})
|
|
|
|
Context("when input IPAM is provided without 'type' with ipv6 stack", func() {
|
|
BeforeEach(func() {
|
|
inputIPAM := makeInputIPAM("", inputIPAMRoutes, "")
|
|
onlyIpv6Input = makeInput(current.ImplementedSpecVersion, inputIPAM, onlyIpv6SubnetFile)
|
|
})
|
|
It("configures Delegate IPAM with 'host-local' ipam with ipv6 stack", func() {
|
|
conf, err := loadFlannelNetConf([]byte(onlyIpv6Input))
|
|
Expect(err).ShouldNot(HaveOccurred())
|
|
fenv, err := loadFlannelSubnetEnv(onlyIpv6SubnetFile)
|
|
Expect(err).ShouldNot(HaveOccurred())
|
|
ipam, err := getDelegateIPAM(conf, fenv)
|
|
Expect(err).ShouldNot(HaveOccurred())
|
|
|
|
podsRoute := "{ \"dst\": \"fc00::/48\" }\n"
|
|
subnet := "\"ranges\": [[{ \"subnet\": \"fc00::/64\" }]]"
|
|
expected := makeInputIPAM("host-local", inputIPAMRoutes+",\n"+podsRoute, ",\n"+subnet)
|
|
buf, _ := json.Marshal(ipam)
|
|
Expect(buf).Should(MatchJSON(expected))
|
|
})
|
|
})
|
|
|
|
Context("when input IPAM is provided without 'type' with dual stack", func() {
|
|
BeforeEach(func() {
|
|
inputIPAM := makeInputIPAM("", inputIPAMRoutes, "")
|
|
dualStackInput = makeInput(current.ImplementedSpecVersion, inputIPAM, dualStackSubnetFile)
|
|
})
|
|
It("configures Delegate IPAM with 'host-local' ipam with dual stack", func() {
|
|
conf, err := loadFlannelNetConf([]byte(dualStackInput))
|
|
Expect(err).ShouldNot(HaveOccurred())
|
|
fenv, err := loadFlannelSubnetEnv(dualStackSubnetFile)
|
|
Expect(err).ShouldNot(HaveOccurred())
|
|
ipam, err := getDelegateIPAM(conf, fenv)
|
|
Expect(err).ShouldNot(HaveOccurred())
|
|
|
|
podsRoute := "{ \"dst\": \"10.1.0.0/16\" }" + ",\n" + "{ \"dst\": \"fc00::/48\" }\n"
|
|
subnet := "\"ranges\": [[{ \"subnet\": \"10.1.17.0/24\" }],\n[{ \"subnet\": \"fc00::/64\" }]]"
|
|
expected := makeInputIPAM("host-local", inputIPAMRoutes+",\n"+podsRoute, ",\n"+subnet)
|
|
buf, _ := json.Marshal(ipam)
|
|
Expect(buf).Should(MatchJSON(expected))
|
|
})
|
|
})
|
|
})
|
|
})
|