ITQC/containernetworking-plugins
24
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases 34 Wiki Activity

pkg/utils/hwaddr: migrate code from IPAM pkg

Browse Source
This commit is contained in:
Stefan Junker 2016-06-28 12:51:58 -07:00
parent 96867eae05
commit 3a1354cff6
4 changed files with 111 additions and 61 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

50
pkg/ipam/ipam.go
View File

@ -21,17 +21,12 @@ import (
"github.com/containernetworking/cni/pkg/invoke"
"github.com/containernetworking/cni/pkg/ip"
"github.com/containernetworking/cni/pkg/types"
"github.com/containernetworking/cni/pkg/utils/hwaddr"
"github.com/vishvananda/netlink"
"net"
"strconv"
"strings"
)
const (
// private mac prefix safe to use
PrivateMACPrefix = "0a:58"
// veth link dev type
vethLinkType = "veth"
)
@ -58,7 +53,7 @@ func ConfigureIface(ifName string, res *types.Result) error {
// only set hardware address to veth when using ipv4
if link.Type() == vethLinkType && res.IP4 != nil {
hwAddr, err := GenerateHardwareAddr4(res.IP4.IP.IP, PrivateMACPrefix)
hwAddr, err := hwaddr.GenerateHardwareAddr4(res.IP4.IP.IP, hwaddr.PrivateMACPrefix)
if err != nil {
return fmt.Errorf("failed to generate hardware addr: %v", err)
}
@ -88,44 +83,3 @@ func ConfigureIface(ifName string, res *types.Result) error {
return nil
}
type SupportIp4OnlyErr struct{ msg string }
func (e SupportIp4OnlyErr) Error() string { return e.msg }
type MacParseErr struct{ msg string }
func (e MacParseErr) Error() string { return e.msg }
type InvalidPrefixLengthErr struct{ msg string }
func (e InvalidPrefixLengthErr) Error() string { return e.msg }
// GenerateHardwareAddr4 generates 48 bit virtual mac addresses based on the IP4 input.
func GenerateHardwareAddr4(ip net.IP, prefix string) (net.HardwareAddr, error) {
switch {
case ip.To4() == nil:
return nil, SupportIp4OnlyErr{msg: "GenerateHardwareAddr4 only supports valid IPv4 address as input"}
case len(prefix) != len(PrivateMACPrefix):
return nil, InvalidPrefixLengthErr{msg: fmt.Sprintf(
"Prefix has length %d instead of %d", len(prefix), len(PrivateMACPrefix)),
}
}
mac := prefix
sections := strings.Split(ip.String(), ".")
for _, s := range sections {
i, _ := strconv.Atoi(s)
mac = mac + ":" + fmt.Sprintf("%02x", i)
}
hwAddr, err := net.ParseMAC(mac)
if err != nil {
return nil, MacParseErr{msg: fmt.Sprintf(
"Failed to parse mac address %q generated based on IP %q due to: %v", mac, ip, err),
}
}
return hwAddr, nil
}

68
pkg/utils/hwaddr/hwaddr.go Normal file
View File

@ -0,0 +1,68 @@
// Copyright 2016 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 hwaddr
import (
"fmt"
"net"
"strconv"
"strings"
)
const (
// private mac prefix safe to use
PrivateMACPrefix = "0a:58"
)
type SupportIp4OnlyErr struct{ msg string }
func (e SupportIp4OnlyErr) Error() string { return e.msg }
type MacParseErr struct{ msg string }
func (e MacParseErr) Error() string { return e.msg }
type InvalidPrefixLengthErr struct{ msg string }
func (e InvalidPrefixLengthErr) Error() string { return e.msg }
// GenerateHardwareAddr4 generates 48 bit virtual mac addresses based on the IP4 input.
func GenerateHardwareAddr4(ip net.IP, prefix string) (net.HardwareAddr, error) {
switch {
case ip.To4() == nil:
return nil, SupportIp4OnlyErr{msg: "GenerateHardwareAddr4 only supports valid IPv4 address as input"}
case len(prefix) != len(PrivateMACPrefix):
return nil, InvalidPrefixLengthErr{msg: fmt.Sprintf(
"Prefix has length %d instead of %d", len(prefix), len(PrivateMACPrefix)),
}
}
mac := prefix
sections := strings.Split(ip.String(), ".")
for _, s := range sections {
i, _ := strconv.Atoi(s)
mac += fmt.Sprintf(":%02x", i)
}
hwAddr, err := net.ParseMAC(mac)
if err != nil {
return nil, MacParseErr{msg: fmt.Sprintf(
"Failed to parse mac address %q generated based on IP %q due to: %v", mac, ip, err),
}
}
return hwAddr, nil
}

27
pkg/utils/hwaddr/hwaddr_suite_test.go Normal file
View File

@ -0,0 +1,27 @@
// Copyright 2016 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 hwaddr_test
import (
. "github.com/onsi/ginkgo"
. "github.com/onsi/gomega"
"testing"
)
func TestHwaddr(t *testing.T) {
RegisterFailHandler(Fail)
RunSpecs(t, "Hwaddr Suite")
}

27
pkg/ipam/ipam_test.go → pkg/utils/hwaddr/hwaddr_test.go
View File

@ -12,17 +12,18 @@
// See the License for the specific language governing permissions and
// limitations under the License.
package ipam_test
package hwaddr_test
import (
. "github.com/onsi/ginkgo"
. "github.com/onsi/gomega"
"net"
"github.com/containernetworking/cni/pkg/ipam"
"github.com/containernetworking/cni/pkg/utils/hwaddr"
. "github.com/onsi/ginkgo"
. "github.com/onsi/gomega"
)
var _ = Describe("ipam utils", func() {
var _ = Describe("Hwaddr", func() {
Context("Generate Hardware Address", func() {
It("generate hardware address based on ipv4 address", func() {
testCases := []struct {
@ -31,20 +32,20 @@ var _ = Describe("ipam utils", func() {
}{
{
ip: net.ParseIP("10.0.0.2"),
expectedMAC: ipam.PrivateMACPrefix + ":0a:00:00:02",
expectedMAC: hwaddr.PrivateMACPrefix + ":0a:00:00:02",
},
{
ip: net.ParseIP("10.250.0.244"),
expectedMAC: ipam.PrivateMACPrefix + ":0a:fa:00:f4",
expectedMAC: hwaddr.PrivateMACPrefix + ":0a:fa:00:f4",
},
{
ip: net.ParseIP("172.17.0.2"),
expectedMAC: ipam.PrivateMACPrefix + ":ac:11:00:02",
expectedMAC: hwaddr.PrivateMACPrefix + ":ac:11:00:02",
},
}
for _, tc := range testCases {
mac, err := ipam.GenerateHardwareAddr4(tc.ip, ipam.PrivateMACPrefix)
mac, err := hwaddr.GenerateHardwareAddr4(tc.ip, hwaddr.PrivateMACPrefix)
Expect(err).NotTo(HaveOccurred())
Expect(mac.String()).To(Equal(tc.expectedMAC))
}
@ -56,14 +57,14 @@ var _ = Describe("ipam utils", func() {
net.ParseIP("2001:db8:0:1:1:1:1:1"),
}
for _, tc := range testCases {
_, err := ipam.GenerateHardwareAddr4(tc, ipam.PrivateMACPrefix)
Expect(err).To(BeAssignableToTypeOf(ipam.SupportIp4OnlyErr{}))
_, err := hwaddr.GenerateHardwareAddr4(tc, hwaddr.PrivateMACPrefix)
Expect(err).To(BeAssignableToTypeOf(hwaddr.SupportIp4OnlyErr{}))
}
})
It("return error if prefix is invalid", func() {
_, err := ipam.GenerateHardwareAddr4(net.ParseIP("10.0.0.2"), "")
Expect(err).To(BeAssignableToTypeOf(ipam.InvalidPrefixLengthErr{}))
_, err := hwaddr.GenerateHardwareAddr4(net.ParseIP("10.0.0.2"), "")
Expect(err).To(BeAssignableToTypeOf(hwaddr.InvalidPrefixLengthErr{}))
})
})
})