Merge pull request #274 from open-amt-cloud-toolkit/localwifienable

feat: add local wifi enable and profile sync

.vscode/launch.json

@@ -53,14 +53,27 @@
             "program": "${workspaceFolder}/cmd/main.go",
             "args": [
                 "maintenance",
-                "syncclock",
+                "deviceinfo",
                 "-u",
                 "wss://[server]/activate",
                 "-n",
                 "-v"
             ],
             "console": "integratedTerminal"
         },
+        {
+            "name": "Configuration Task ",
+            "type": "go",
+            "asRoot": true,
+            "request": "launch",
+            "program": "${workspaceFolder}/cmd/main.go",
+            "args": [
+                "configure",
+                "enablewifiport",
+                "-h"
+            ],
+            "console": "integratedTerminal"
+        },
         {
             "name": "Version Info",
             "type": "go",

internal/flags/configure.go

@@ -21,6 +21,8 @@ func (f *Flags) printConfigurationUsage() string {
 	usage = usage + "Supported Configuration Commands:\n"
 	usage = usage + "  addwifisettings Add or modify WiFi settings in AMT. AMT password is required. A config.yml or command line flags must be provided for all settings. This command runs without cloud interaction.\n"
 	usage = usage + "                 Example: " + executable + " configure addwifisettings -password YourAMTPassword -config wificonfig.yaml\n"
+	usage = usage + "  enablewifiport  Enables WiFi port and local profile synchronization settings in AMT. AMT password is required.\n"
+	usage = usage + "                 Example: " + executable + " configure enablewifiport -password YourAMTPassword\n"
 	usage = usage + "\nRun '" + executable + " configure COMMAND -h' for more information on a command.\n"
 	fmt.Println(usage)
 	return usage
@@ -38,11 +40,11 @@ func (f *Flags) handleConfigureCommand() utils.ReturnCode {
 	switch f.SubCommand {
 	case "addwifisettings":
 		rc = f.handleAddWifiSettings()
-		break
+	case "enablewifiport":
+		rc = f.handleEnableWifiPort()
 	default:
 		f.printConfigurationUsage()
 		rc = utils.IncorrectCommandLineParameters
-		break
 	}
 	if rc != utils.Success {
 		return rc
@@ -69,6 +71,25 @@ func (f *Flags) handleConfigureCommand() utils.ReturnCode {
 	return utils.Success
 }
 
+func (f *Flags) handleEnableWifiPort() utils.ReturnCode {
+	var err error
+	// var rc utils.ReturnCode
+	if len(f.commandLineArgs) > 5 {
+		f.printConfigurationUsage()
+		return utils.IncorrectCommandLineParameters
+	}
+	f.flagSetEnableWifiPort.BoolVar(&f.Verbose, "v", false, "Verbose output")
+	f.flagSetEnableWifiPort.StringVar(&f.LogLevel, "l", "info", "Log level (panic,fatal,error,warn,info,debug,trace)")
+	f.flagSetEnableWifiPort.BoolVar(&f.JsonOutput, "json", false, "JSON output")
+	f.flagSetEnableWifiPort.StringVar(&f.Password, "password", f.lookupEnvOrString("AMT_PASSWORD", ""), "AMT password")
+
+	if err = f.flagSetEnableWifiPort.Parse(f.commandLineArgs[3:]); err != nil {
+		f.printConfigurationUsage()
+		return utils.IncorrectCommandLineParameters
+	}
+	return utils.Success
+}
+
 func (f *Flags) handleAddWifiSettings() utils.ReturnCode {
 	var err error
 	var rc utils.ReturnCode

internal/flags/configure_test.go

@@ -124,6 +124,46 @@ func TestCmdLine(t *testing.T) {
 		gotResult := f.ParseFlags()
 		assert.Equal(t, utils.MissingOrIncorrectPassword, gotResult)
 	})
+	t.Run("enablewifiport: expect Success", func(t *testing.T) {
+		cmdLine := []string{
+			`rpc`, `configure`, `enablewifiport`,
+			`-password`, `cliP@ss0rd!`,
+		}
+		f := NewFlags(cmdLine)
+		gotResult := f.ParseFlags()
+		assert.Equal(t, utils.Success, gotResult)
+		assert.Equal(t, true, f.Local)
+		assert.Equal(t, f.Password, f.LocalConfig.Password)
+	})
+	t.Run("enablewifiport: expect MissingOrIncorrectPassword", func(t *testing.T) {
+		f := NewFlags([]string{
+			`rpc`, `configure`, `enablewifiport`, `-password`,
+		})
+		gotResult := f.ParseFlags()
+		assert.Equal(t, utils.IncorrectCommandLineParameters, gotResult)
+	})
+	t.Run("enablewifiport: expect Success on password prompt", func(t *testing.T) {
+		defer userInput(t, "userP@ssw0rd!")()
+		f := NewFlags([]string{
+			`rpc`, `configure`, `enablewifiport`,
+		})
+		gotResult := f.ParseFlags()
+		assert.Equal(t, utils.Success, gotResult)
+	})
+	t.Run("enablewifiport: expect IncorrectCommandLineParameters", func(t *testing.T) {
+		f := NewFlags([]string{
+			`rpc`, `configure`, `enablewifiport`, `-password`, `testpw`, `toomany`,
+		})
+		gotResult := f.ParseFlags()
+		assert.Equal(t, utils.IncorrectCommandLineParameters, gotResult)
+	})
+	t.Run("enablewifiport: ssexpect IncorrectCommandLineParameters", func(t *testing.T) {
+		f := NewFlags([]string{
+			`rpc`, `configure`, `enablewifiport`, `-bogus`, `testpw`,
+		})
+		gotResult := f.ParseFlags()
+		assert.Equal(t, utils.IncorrectCommandLineParameters, gotResult)
+	})
 }
 
 func TestConfigJson(t *testing.T) {

internal/flags/flags.go

@@ -78,6 +78,7 @@ type Flags struct {
 	amtMaintenanceSyncDeviceInfoCommand *flag.FlagSet
 	versionCommand                      *flag.FlagSet
 	flagSetAddWifiSettings              *flag.FlagSet
+	flagSetEnableWifiPort               *flag.FlagSet
 	amtCommand                          amt.AMTCommand
 	netEnumerator                       NetEnumerator
 	IpConfiguration                     IPConfiguration
@@ -106,6 +107,7 @@ func NewFlags(args []string) *Flags {
 	flags.versionCommand.BoolVar(&flags.JsonOutput, "json", false, "json output")
 
 	flags.flagSetAddWifiSettings = flag.NewFlagSet(utils.SubCommandAddWifiSettings, flag.ContinueOnError)
+	flags.flagSetEnableWifiPort = flag.NewFlagSet(utils.SubCommandEnableWifiPort, flag.ContinueOnError)
 
 	flags.amtCommand = amt.NewAMTCommand()
 	flags.netEnumerator = NetEnumerator{}

internal/local/configure.go

@@ -18,13 +18,26 @@ import (
 
 func (service *ProvisioningService) Configure() utils.ReturnCode {
 	service.setupWsmanClient("admin", service.flags.Password)
-
-	if service.flags.SubCommand == utils.SubCommandAddWifiSettings {
+	switch service.flags.SubCommand {
+	case utils.SubCommandAddWifiSettings:
 		return service.AddWifiSettings()
+	case utils.SubCommandEnableWifiPort:
+		return service.EnableWifiPort()
+	default:
 	}
 	return utils.IncorrectCommandLineParameters
 }
 
+func (service *ProvisioningService) EnableWifiPort() utils.ReturnCode {
+	rc := service.EnableWifi()
+	if rc != utils.Success {
+		log.Error("Failed to enable wifi port and local profile synchronization.")
+	} else {
+		log.Info("Successfully enabled wifi port and local profile synchronization.")
+	}
+	return rc
+}
+
 func (service *ProvisioningService) AddWifiSettings() utils.ReturnCode {
 	// start with fresh map
 	service.handlesWithCerts = make(map[string]string)

internal/local/configure_test.go

@@ -120,6 +120,13 @@ func TestConfigure(t *testing.T) {
 		rc := lps.Configure()
 		assert.Equal(t, utils.WSMANMessageError, rc)
 	})
+	t.Run("expect error for SubCommandAddWifiSettings", func(t *testing.T) {
+		f.SubCommand = utils.SubCommandEnableWifiPort
+		rfa := ResponseFuncArray{respondServerErrFunc()}
+		lps := setupWsmanResponses(t, f, rfa)
+		rc := lps.Configure()
+		assert.Equal(t, utils.WSMANMessageError, rc)
+	})
 }
 
 func TestAddWifiSettings(t *testing.T) {
@@ -665,3 +672,26 @@ func TestCheckReturnValue(t *testing.T) {
 		})
 	}
 }
+func TestEnableWifiPort(t *testing.T) {
+	f := &flags.Flags{}
+	pcsRsp := wifiportconfiguration.Response{}
+	pcsRsp.Body.WiFiPortConfigurationService.LocalProfileSynchronizationEnabled = 1
+	pcsRsp.Body.WiFiPortConfigurationService.EnabledState = 1
+	t.Run("enablewifiport: expect Success on happy path", func(t *testing.T) {
+		rfa := ResponseFuncArray{
+			respondMsgFunc(t, common.EnumerationResponse{}),
+			respondMsgFunc(t, wifi.PullResponseEnvelope{}),
+			respondMsgFunc(t, pcsRsp),
+			respondMsgFunc(t, wifi.RequestStateChangeResponse{}),
+		}
+		lps := setupWsmanResponses(t, f, rfa)
+		rc := lps.EnableWifiPort()
+		assert.Equal(t, utils.Success, rc)
+	})
+	t.Run("enablewifiport: expect WSMANMessageError ", func(t *testing.T) {
+		rfa := ResponseFuncArray{respondServerErrFunc()}
+		lps := setupWsmanResponses(t, f, rfa)
+		rc := lps.EnableWifiPort()
+		assert.Equal(t, utils.WSMANMessageError, rc)
+	})
+}

pkg/utils/constants.go

@@ -31,6 +31,7 @@ const (
 	CommandConfigure   = "configure"
 
 	SubCommandAddWifiSettings = "addwifisettings"
+	SubCommandEnableWifiPort  = "enablewifiport"
 	SubCommandChangePassword  = "changepassword"
 	SubCommandSyncDeviceInfo  = "syncdeviceinfo"
 	SubCommandSyncClock       = "syncclock"