Set dns server on azure bridge for ubuntu version >= 17 (#345)

* configure dns server on azure bridge for ubuntu versions > 18. Moved hns related apis from platform package to hsnclient package

* read dns server from interface instead of file and fixed few issues

* renturn error on fail to configure dns

* added unitest and fixed an issue in ReadFileByLines method

* added a UT

* addressed comments and added few tests to get code coverage

* confiure dns for ubuntu17 also

* corrected typo error of filename

Author: tamilmani1989

cns/hnsclient/hnsclient_linux.go

@@ -0,0 +1,32 @@
+package hnsclient
+
+import (
+	"fmt"
+
+	"github.com/Azure/azure-container-networking/cns"
+)
+
+// CreateDefaultExtNetwork creates the default ext network (if it doesn't exist already)
+// to create external switch on windows platform.
+// This is windows platform specific.
+func CreateDefaultExtNetwork(networkType string) error {
+	return fmt.Errorf("CreateDefaultExtNetwork shouldn't be called for linux platform")
+}
+
+// DeleteDefaultExtNetwork deletes the default HNS network.
+// This is windows platform specific.
+func DeleteDefaultExtNetwork() error {
+	return fmt.Errorf("DeleteDefaultExtNetwork shouldn't be called for linux platform")
+}
+
+// CreateHnsNetwork creates the HNS network with the provided configuration
+// This is windows platform specific.
+func CreateHnsNetwork(nwConfig cns.CreateHnsNetworkRequest) error {
+	return fmt.Errorf("CreateHnsNetwork shouldn't be called for linux platform")
+}
+
+// DeleteHnsNetwork deletes the HNS network with the provided name.
+// This is windows platform specific.
+func DeleteHnsNetwork(networkName string) error {
+	return fmt.Errorf("DeleteHnsNetwork shouldn't be called for linux platform")
+}

cns/hnsclient/hnsclient_windows.go

@@ -0,0 +1,140 @@
+package hnsclient
+
+import (
+	"encoding/json"
+	"fmt"
+	"log"
+	"strings"
+
+	"github.com/Azure/azure-container-networking/cns"
+	"github.com/Microsoft/hcsshim"
+)
+
+// CreateHnsNetwork creates the HNS network with the provided configuration
+func CreateHnsNetwork(nwConfig cns.CreateHnsNetworkRequest) error {
+	log.Printf("[Azure CNS] CreateHnsNetwork")
+	// Initialize HNS network.
+	hnsNetwork := &hcsshim.HNSNetwork{
+		Name:                 nwConfig.NetworkName,
+		Type:                 nwConfig.NetworkType,
+		NetworkAdapterName:   nwConfig.NetworkAdapterName,
+		SourceMac:            nwConfig.SourceMac,
+		DNSSuffix:            nwConfig.DNSSuffix,
+		DNSServerList:        nwConfig.DNSServerList,
+		DNSServerCompartment: nwConfig.DNSServerCompartment,
+		ManagementIP:         nwConfig.ManagementIP,
+		AutomaticDNS:         nwConfig.AutomaticDNS,
+	}
+
+	for _, policy := range nwConfig.Policies {
+		hnsNetwork.Policies = append(hnsNetwork.Policies, policy)
+	}
+
+	for _, subnet := range nwConfig.Subnets {
+		hnsSubnet := hcsshim.Subnet{
+			AddressPrefix:  subnet.AddressPrefix,
+			GatewayAddress: subnet.GatewayAddress,
+		}
+
+		hnsNetwork.Subnets = append(hnsNetwork.Subnets, hnsSubnet)
+	}
+
+	for _, macPool := range nwConfig.MacPools {
+		hnsMacPool := hcsshim.MacPool{
+			StartMacAddress: macPool.StartMacAddress,
+			EndMacAddress:   macPool.EndMacAddress,
+		}
+		hnsNetwork.MacPools = append(hnsNetwork.MacPools, hnsMacPool)
+	}
+
+	return createHnsNetwork(hnsNetwork)
+}
+
+// DeleteHnsNetwork deletes the HNS network with the provided name
+func DeleteHnsNetwork(networkName string) error {
+	log.Printf("[Azure CNS] DeleteHnsNetwork")
+
+	return deleteHnsNetwork(networkName)
+}
+
+// CreateDefaultExtNetwork creates default HNS network named ext (if it doesn't exist already)
+// to create external switch on windows platform.
+// This allows orchestrators to start CNS which pre-provisions the network so that the
+// VM network blip / disconnect is avoided when calling cni add for the very first time.
+func CreateDefaultExtNetwork(networkType string) error {
+	networkType = strings.ToLower(strings.TrimSpace(networkType))
+	if len(networkType) == 0 {
+		return nil
+	}
+
+	if networkType != hnsL2Bridge && networkType != hnsL2Tunnel {
+		return fmt.Errorf("Invalid hns network type %s", networkType)
+	}
+
+	log.Printf("[Azure CNS] CreateDefaultExtNetwork")
+	extHnsNetwork, _ := hcsshim.GetHNSNetworkByName(ExtHnsNetworkName)
+
+	if extHnsNetwork != nil {
+		log.Printf("[Azure CNS] Found existing DefaultExtNetwork with type: %s", extHnsNetwork.Type)
+		if !strings.EqualFold(networkType, extHnsNetwork.Type) {
+			return fmt.Errorf("Network type mismatch with existing network: %s", extHnsNetwork.Type)
+		}
+
+		return nil
+	}
+
+	// create new hns network
+	log.Printf("[Azure CNS] Creating DefaultExtNetwork with type %s", networkType)
+
+	hnsNetwork := &hcsshim.HNSNetwork{
+		Name: ExtHnsNetworkName,
+		Type: networkType,
+	}
+
+	hnsSubnet := hcsshim.Subnet{
+		AddressPrefix:  ExtHnsNetworkAddressPrefix,
+		GatewayAddress: ExtHnsNetworkGwAddress,
+	}
+
+	hnsNetwork.Subnets = append(hnsNetwork.Subnets, hnsSubnet)
+
+	return createHnsNetwork(hnsNetwork)
+}
+
+// DeleteDefaultExtNetwork deletes the default HNS network
+func DeleteDefaultExtNetwork() error {
+	log.Printf("[Azure CNS] DeleteDefaultExtNetwork")
+
+	return deleteHnsNetwork(ExtHnsNetworkName)
+}
+
+// createHnsNetwork calls the hcshim to create the hns network
+func createHnsNetwork(hnsNetwork *hcsshim.HNSNetwork) error {
+	// Marshal the request.
+	buffer, err := json.Marshal(hnsNetwork)
+	if err != nil {
+		return err
+	}
+	hnsRequest := string(buffer)
+
+	// Create the HNS network.
+	log.Printf("[Azure CNS] HNSNetworkRequest POST request:%+v", hnsRequest)
+	hnsResponse, err := hcsshim.HNSNetworkRequest("POST", "", hnsRequest)
+	log.Printf("[Azure CNS] HNSNetworkRequest POST response:%+v err:%v.", hnsResponse, err)
+
+	return err
+}
+
+// deleteHnsNetwork calls HNS to delete the network with the provided name
+func deleteHnsNetwork(networkName string) error {
+	hnsNetwork, err := hcsshim.GetHNSNetworkByName(networkName)
+	if err == nil {
+		// Delete the HNS network.
+		var hnsResponse *hcsshim.HNSNetwork
+		log.Printf("[Azure CNS] HNSNetworkRequest DELETE id:%v", hnsNetwork.Id)
+		hnsResponse, err = hcsshim.HNSNetworkRequest("DELETE", hnsNetwork.Id, "")
+		log.Printf("[Azure CNS] HNSNetworkRequest DELETE response:%+v err:%v.", hnsResponse, err)
+	}
+
+	return err
+}

cns/restserver/restserver.go

@@ -14,6 +14,7 @@ import (
 	"github.com/Azure/azure-container-networking/cns"
 	"github.com/Azure/azure-container-networking/cns/common"
 	"github.com/Azure/azure-container-networking/cns/dockerclient"
+	"github.com/Azure/azure-container-networking/cns/hnsclient"
 	"github.com/Azure/azure-container-networking/cns/imdsclient"
 	"github.com/Azure/azure-container-networking/cns/ipamclient"
 	"github.com/Azure/azure-container-networking/cns/networkcontainers"
@@ -428,7 +429,7 @@ func (service *HTTPRestService) createHnsNetwork(w http.ResponseWriter, r *http.
 	} else {
 		switch r.Method {
 		case "POST":
-			if err := platform.CreateHnsNetwork(req); err == nil {
+			if err := hnsclient.CreateHnsNetwork(req); err == nil {
 				// Save the newly created HnsNetwork name. CNS deleteHnsNetwork API
 				// will only allow deleting these networks.
 				networkInfo := &networkInfo{
@@ -480,7 +481,7 @@ func (service *HTTPRestService) deleteHnsNetwork(w http.ResponseWriter, r *http.
 		case "POST":
 			networkInfo, found := service.getNetworkInfo(req.NetworkName)
 			if found && networkInfo.NetworkName == req.NetworkName {
-				if err = platform.DeleteHnsNetwork(req.NetworkName); err == nil {
+				if err = hnsclient.DeleteHnsNetwork(req.NetworkName); err == nil {
 					returnMessage = fmt.Sprintf("[Azure CNS] Successfully deleted HNS network: %s", req.NetworkName)
 				} else {
 					returnMessage = fmt.Sprintf("[Azure CNS] DeleteHnsNetwork failed with error %v", err.Error())

cns/service/main.go

@@ -13,6 +13,7 @@ import (
 	"github.com/Azure/azure-container-networking/cnm/ipam"
 	"github.com/Azure/azure-container-networking/cnm/network"
 	"github.com/Azure/azure-container-networking/cns/common"
+	"github.com/Azure/azure-container-networking/cns/hnsclient"
 	"github.com/Azure/azure-container-networking/cns/restserver"
 	acn "github.com/Azure/azure-container-networking/common"
 	"github.com/Azure/azure-container-networking/log"
@@ -243,7 +244,7 @@ func main() {
 
 	// Create default ext network if commandline option is set
 	if len(strings.TrimSpace(createDefaultExtNetworkType)) > 0 {
-		if err := platform.CreateDefaultExtNetwork(createDefaultExtNetworkType); err == nil {
+		if err := hnsclient.CreateDefaultExtNetwork(createDefaultExtNetworkType); err == nil {
 			log.Printf("[Azure CNS] Successfully created default ext network")
 		} else {
 			log.Printf("[Azure CNS] Failed to create default ext network due to error: %v", err)
@@ -329,7 +330,7 @@ func main() {
 	}
 
 	if len(strings.TrimSpace(createDefaultExtNetworkType)) > 0 {
-		if err := platform.DeleteDefaultExtNetwork(); err == nil {
+		if err := hnsclient.DeleteDefaultExtNetwork(); err == nil {
 			log.Printf("[Azure CNS] Successfully deleted default ext network")
 		} else {
 			log.Printf("[Azure CNS] Failed to delete default ext network due to error: %v", err)

common/testfiles/test1

@@ -0,0 +1,2 @@
+hello
+azure-container-networking

common/testfiles/test2

@@ -0,0 +1 @@
+single

common/testfiles/test3

@@ -0,0 +1 @@
+singlewith\n

common/utils.go

@@ -4,8 +4,11 @@
 package common
 
 import (
+	"bufio"
 	"encoding/binary"
 	"encoding/xml"
+	"fmt"
+	"io"
 	"net"
 	"os"
 
@@ -123,3 +126,35 @@ func StartProcess(path string, args []string) error {
 
 	return err
 }
+
+// ReadFileByLines reads file line by line and return array of lines.
+func ReadFileByLines(filename string) ([]string, error) {
+	var (
+		lineStrArr []string
+	)
+
+	f, err := os.Open(filename)
+	if err != nil {
+		return nil, fmt.Errorf("Error opening %s file error %v", filename, err)
+	}
+
+	defer f.Close()
+
+	r := bufio.NewReader(f)
+
+	for {
+		lineStr, err := r.ReadString('\n')
+		if err != nil {
+			if err != io.EOF {
+				return nil, fmt.Errorf("Error reading %s file error %v", filename, err)
+			}
+
+			lineStrArr = append(lineStrArr, lineStr)
+			break
+		}
+
+		lineStrArr = append(lineStrArr, lineStr)
+	}
+
+	return lineStrArr, nil
+}

common/utils_test.go

@@ -0,0 +1,60 @@
+package common
+
+import (
+	"os"
+	"testing"
+)
+
+func TestMain(m *testing.M) {
+	exitCode := m.Run()
+	os.Exit(exitCode)
+}
+
+func TestReadFileByLines(t *testing.T) {
+	lines, err := ReadFileByLines("testfiles/test1")
+	if err != nil {
+		t.Errorf("ReadFileByLines failed: %v", err)
+	}
+
+	if len(lines) != 2 {
+		t.Errorf("Line count %d didn't match expected count", len(lines))
+	}
+
+	lines = nil
+
+	lines, err = ReadFileByLines("testfiles/test2")
+	if err != nil {
+		t.Errorf("ReadFileByLines failed: %v", err)
+	}
+
+	if len(lines) != 1 {
+		t.Errorf("Line count %d didn't match expected count", len(lines))
+	}
+
+	lines = nil
+
+	lines, err = ReadFileByLines("testfiles/test3")
+	if err != nil {
+		t.Errorf("ReadFileByLines failed: %v", err)
+	}
+
+	if len(lines) != 2 {
+		t.Errorf("Line count %d didn't match expected count", len(lines))
+	}
+
+	if lines[1] != "" {
+		t.Errorf("Expected empty line but got %s", lines[1])
+	}
+}
+
+func TestFileExists(t *testing.T) {
+	isExist, err := CheckIfFileExists("testfiles/test1")
+	if err != nil || !isExist {
+		t.Errorf("Returned file not found %v", err)
+	}
+
+	isExist, err = CheckIfFileExists("testfiles/filenotfound")
+	if err != nil || isExist {
+		t.Errorf("Returned file found")
+	}
+}

network/network.go

@@ -26,6 +26,7 @@ type externalInterface struct {
 	Networks    map[string]*network
 	Subnets     []string
 	BridgeName  string
+	DNSServerIP string
 	MacAddress  net.HardwareAddr
 	IPAddresses []*net.IPNet
 	Routes      []*route