Merge pull request #4421 from aws/platform-config

Adds config parameter to shared netlib platform

Author: JoseVillalta

ecs-agent/netlib/network_builder.go

@@ -48,13 +48,13 @@ type networkBuilder struct {
 }
 
 func NewNetworkBuilder(
-	platformString string,
+	platformConfig platform.Config,
 	metricsFactory metrics.EntryFactory,
 	volumeAccessor volume.TaskVolumeAccessor,
 	networkDao data.NetworkDataClient,
 	stateDBDir string) (NetworkBuilder, error) {
 	pAPI, err := platform.NewPlatform(
-		platformString,
+		platformConfig,
 		volumeAccessor,
 		stateDBDir,
 		netwrapper.NewNet(),

ecs-agent/netlib/network_builder_linux_test.go

@@ -32,7 +32,7 @@ import (
 	"github.com/aws/amazon-ecs-agent/ecs-agent/netlib/model/serviceconnect"
 	"github.com/aws/amazon-ecs-agent/ecs-agent/netlib/model/status"
 	"github.com/aws/amazon-ecs-agent/ecs-agent/netlib/model/tasknetworkconfig"
-	"github.com/aws/amazon-ecs-agent/ecs-agent/netlib/platform"
+	platform "github.com/aws/amazon-ecs-agent/ecs-agent/netlib/platform"
 	mock_platform "github.com/aws/amazon-ecs-agent/ecs-agent/netlib/platform/mocks"
 	mock_netwrapper "github.com/aws/amazon-ecs-agent/ecs-agent/utils/netwrapper/mocks"
 
@@ -42,12 +42,12 @@ import (
 )
 
 func TestNewNetworkBuilder(t *testing.T) {
-	nbi, err := NewNetworkBuilder(platform.WarmpoolPlatform, nil, nil, nil, "")
+	nbi, err := NewNetworkBuilder(platform.Config{Name: platform.WarmpoolPlatform}, nil, nil, nil, "")
 	nb := nbi.(*networkBuilder)
 	require.NoError(t, err)
 	require.NotNil(t, nb.platformAPI)
 
-	nbi, err = NewNetworkBuilder("invalid-platform", nil, nil, nil, "")
+	nbi, err = NewNetworkBuilder(platform.Config{Name: "invalid-platform"}, nil, nil, nil, "")
 	require.Error(t, err)
 	require.Nil(t, nbi)
 }
@@ -88,7 +88,8 @@ func getTestFunc(
 
 		// Create a networkBuilder for the warmpool platform.
 		mockNet := mock_netwrapper.NewMockNet(ctrl)
-		platformAPI, err := platform.NewPlatform(plt, nil, "", mockNet)
+		platformConfig := platform.Config{Name: plt}
+		platformAPI, err := platform.NewPlatform(platformConfig, nil, "", mockNet)
 		require.NoError(t, err)
 		netBuilder := &networkBuilder{
 			platformAPI: platformAPI,

ecs-agent/netlib/network_builder_windows_test.go

@@ -49,7 +49,8 @@ func getTestFunc(
 
 		// Create a networkBuilder for the warmpool platform.
 		mockNet := mock_netwrapper.NewMockNet(ctrl)
-		platformAPI, err := platform.NewPlatform(plt, nil, "", mockNet)
+		config := platform.Config{Name: plt}
+		platformAPI, err := platform.NewPlatform(config, nil, "", mockNet)
 		require.NoError(t, err)
 		netBuilder := &networkBuilder{
 			platformAPI: platformAPI,

ecs-agent/netlib/platform/api.go

@@ -79,3 +79,12 @@ type API interface {
 		scConfig *serviceconnect.ServiceConnectConfig,
 	) error
 }
+
+// Config contains platform-specific data.
+type Config struct {
+	// Name specifies which platform to use (Linux, Windows, ec2-debug, etc).
+	Name string
+	// ResolvConfPath specifies path to resolv.conf file for DNS config.
+	// Different platforms may have different paths for this file.
+	ResolvConfPath string
+}

ecs-agent/netlib/platform/common_linux.go

@@ -82,12 +82,13 @@ type common struct {
 	stateDBDir        string
 	cniClient         ecscni.CNI
 	net               netwrapper.Net
+	resolvConfPath    string
 }
 
 // NewPlatform creates an implementation of the platform API depending on the
 // platform type where the agent is executing.
 func NewPlatform(
-	platformString string,
+	platformConfig Config,
 	volumeAccessor volume.TaskVolumeAccessor,
 	stateDBDirectory string,
 	netWrapper netwrapper.Net,
@@ -101,10 +102,10 @@ func NewPlatform(
 		stateDBDir:        stateDBDirectory,
 		cniClient:         ecscni.NewCNIClient([]string{CNIPluginPathDefault}),
 		net:               netWrapper,
+		resolvConfPath:    platformConfig.ResolvConfPath,
 	}
 
-	// TODO: implement remaining platforms - windows.
-	switch platformString {
+	switch platformConfig.Name {
 	case WarmpoolPlatform:
 		return &containerd{
 			common: commonPlatform,
@@ -134,7 +135,7 @@ func NewPlatform(
 			client: ec2Client,
 		}, nil
 	}
-	return nil, errors.New("invalid platform: " + platformString)
+	return nil, errors.New("invalid platform: " + platformConfig.Name)
 }
 
 // BuildTaskNetworkConfiguration translates network data in task payload sent by ACS
@@ -533,10 +534,14 @@ func (c *common) generateNetworkConfigFilesForDebugPlatforms(
 		return errors.Wrap(err, "unable to create hostname file for netns")
 	}
 
-	err = c.copyFile(filepath.Join(netNSDir, ResolveConfFileName), "/etc/resolv.conf", taskDNSConfigFileMode)
+	// Copy Host's resolv.conf file.
+	err = c.copyFile(filepath.Join(netNSDir, ResolveConfFileName),
+		filepath.Join(c.resolvConfPath, ResolveConfFileName),
+		taskDNSConfigFileMode)
 	if err != nil {
 		return err
 	}
+
 	err = c.copyFile(filepath.Join(netNSDir, HostsFileName), "/etc/hosts", taskDNSConfigFileMode)
 	if err != nil {
 		return err

ecs-agent/netlib/platform/common_linux_test.go

@@ -47,10 +47,10 @@ import (
 )
 
 func TestNewPlatform(t *testing.T) {
-	_, err := NewPlatform(WarmpoolPlatform, nil, "", nil)
+	_, err := NewPlatform(Config{Name: WarmpoolPlatform}, nil, "", nil)
 	assert.NoError(t, err)
 
-	_, err = NewPlatform("invalid-platform", nil, "", nil)
+	_, err = NewPlatform(Config{Name: "invalid-platform"}, nil, "", nil)
 	assert.Error(t, err)
 }
 
@@ -170,6 +170,77 @@ func TestCommon_CreateDNSFiles(t *testing.T) {
 	require.NoError(t, err)
 }
 
+func TestCommon_CreateDNSFilesForDebug(t *testing.T) {
+	ctrl := gomock.NewController(t)
+	defer ctrl.Finish()
+
+	for _, testCase := range []struct {
+		name           string
+		resolvConfPath string
+	}{
+		{name: "al", resolvConfPath: "/etc"},
+		{name: "br", resolvConfPath: "/run/netdog"},
+	} {
+		t.Run(testCase.name, func(t *testing.T) {
+			netNSName := "netns-name"
+			netNSPath := "/etc/netns/" + netNSName
+			iface := getTestInterface()
+
+			netns := &tasknetworkconfig.NetworkNamespace{
+				Name:              netNSName,
+				Path:              netNSPath,
+				NetworkInterfaces: []*networkinterface.NetworkInterface{iface},
+			}
+
+			ioutil := mock_ioutilwrapper.NewMockIOUtil(ctrl)
+			nsUtil := mock_ecscni.NewMockNetNSUtil(ctrl)
+			osWrapper := mock_oswrapper.NewMockOS(ctrl)
+			mockFile := mock_oswrapper.NewMockFile(ctrl)
+			volumeAccessor := mock_volume.NewMockTaskVolumeAccessor(ctrl)
+			commonPlatform := &common{
+				ioutil:            ioutil,
+				nsUtil:            nsUtil,
+				os:                osWrapper,
+				dnsVolumeAccessor: volumeAccessor,
+				resolvConfPath:    testCase.resolvConfPath,
+			}
+
+			hostnameData := fmt.Sprintf("%s\n", iface.GetHostname())
+
+			taskID := "taskID"
+			gomock.InOrder(
+				// Read hostname file.
+				osWrapper.EXPECT().OpenFile("/etc/hostname", os.O_RDONLY|os.O_CREATE, fs.FileMode(0644)).Return(mockFile, nil).Times(1),
+				mockFile.EXPECT().Close().Times(1),
+
+				// Creation of netns path.
+				osWrapper.EXPECT().Stat(netNSPath).Return(nil, os.ErrNotExist).Times(1),
+				osWrapper.EXPECT().IsNotExist(os.ErrNotExist).Return(true).Times(1),
+				osWrapper.EXPECT().MkdirAll(netNSPath, fs.FileMode(0644)),
+
+				// Write hostname file.
+				ioutil.EXPECT().WriteFile(netNSPath+"/hostname", []byte(hostnameData), fs.FileMode(0644)),
+
+				// Copy resolv.conf file.
+				ioutil.EXPECT().ReadFile(testCase.resolvConfPath+"/resolv.conf"),
+				ioutil.EXPECT().WriteFile(netNSPath+"/resolv.conf", gomock.Any(), gomock.Any()),
+
+				// Creation of hosts file.
+				ioutil.EXPECT().ReadFile("/etc/hosts"),
+				ioutil.EXPECT().WriteFile(netNSPath+"/hosts", gomock.Any(), gomock.Any()),
+
+				// CopyToVolume created files into task volume.
+				volumeAccessor.EXPECT().CopyToVolume(taskID, netNSPath+"/hosts", "hosts", fs.FileMode(0644)).Return(nil).Times(1),
+				volumeAccessor.EXPECT().CopyToVolume(taskID, netNSPath+"/resolv.conf", "resolv.conf", fs.FileMode(0644)).Return(nil).Times(1),
+				volumeAccessor.EXPECT().CopyToVolume(taskID, netNSPath+"/hostname", "hostname", fs.FileMode(0644)).Return(nil).Times(1),
+			)
+			err := commonPlatform.createDNSConfig(taskID, true, netns)
+			require.NoError(t, err)
+		})
+	}
+
+}
+
 func TestCommon_ConfigureInterface(t *testing.T) {
 	t.Run("regular-eni", testRegularENIConfiguration)
 	t.Run("branch-eni", testBranchENIConfiguration)

ecs-agent/netlib/platform/containerd_windows.go

@@ -56,7 +56,7 @@ type containerdDebug struct {
 
 // NewPlatform returns a platform instance with windows specific implementations of the API interface.
 func NewPlatform(
-	platformString string,
+	config Config,
 	_ volume.TaskVolumeAccessor,
 	_ string,
 	net netwrapper.Net) (API, error) {
@@ -68,15 +68,15 @@ func NewPlatform(
 			net:       net,
 		},
 	}
-	switch platformString {
+	switch config.Name {
 	case WarmpoolPlatform:
 		return &c, nil
 	case WarmpoolDebugPlatform:
 		return &containerdDebug{
 			containerd: c,
 		}, nil
 	default:
-		return nil, errors.New("invalid platform string: " + platformString)
+		return nil, errors.New("invalid platform string: " + config.Name)
 	}
 	return nil, nil
 }