pkg/utils/hwaddr: migrate code from IPAM pkg

diff --git a/pkg/ipam/ipam.go b/pkg/ipam/ipam.go
index 74f937d..62bf15d 100644 (file)
--- a/pkg/ipam/ipam.go
+++ b/pkg/ipam/ipam.go
@@ -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
-}

diff --git a/pkg/utils/hwaddr/hwaddr.go b/pkg/utils/hwaddr/hwaddr.go
new file mode 100644 (file)
index 0000000..f03b7ac
--- /dev/null
+++ b/pkg/utils/hwaddr/hwaddr.go
@@ -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
+}

diff --git a/pkg/utils/hwaddr/hwaddr_suite_test.go b/pkg/utils/hwaddr/hwaddr_suite_test.go
new file mode 100644 (file)
index 0000000..e3bbfe9
--- /dev/null
+++ b/pkg/utils/hwaddr/hwaddr_suite_test.go
@@ -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")
+}

diff --git a/pkg/ipam/ipam_test.go b/pkg/utils/hwaddr/hwaddr_test.go
similarity index 68%
rename from pkg/ipam/ipam_test.go
rename to pkg/utils/hwaddr/hwaddr_test.go
index 1390cce..8a201a2 100644 (file)
--- a/pkg/ipam/ipam_test.go
+++ b/pkg/utils/hwaddr/hwaddr_test.go
@@ -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{}))
                })
        })
 })