Support for running within WSL2

Author: camjjack

builder/hyperv/common/driver_ps_4.go

@@ -13,22 +13,21 @@ import (
 
 	"github.com/hashicorp/packer-plugin-hyperv/builder/hyperv/common/powershell"
 	"github.com/hashicorp/packer-plugin-hyperv/builder/hyperv/common/powershell/hyperv"
+	"github.com/hashicorp/packer-plugin-hyperv/builder/hyperv/common/wsl"
 )
 
 type HypervPS4Driver struct {
 }
 
 func NewHypervPS4Driver() (Driver, error) {
-	appliesTo := "Applies to Windows 8.1, Windows PowerShell 4.0, Windows Server 2012 R2 only"
+	appliesTo := "Applies to Windows 8.1+, Windows PowerShell 4.0, Windows Server 2012 R2+, WSL2 only"
 
-	// Check this is Windows
-	if runtime.GOOS != "windows" {
+	if !wsl.IsWSL() && runtime.GOOS != "windows" {
 		err := fmt.Errorf("%s", appliesTo)
 		return nil, err
 	}
 
 	ps4Driver := &HypervPS4Driver{}
-
 	if err := ps4Driver.Verify(); err != nil {
 		return nil, err
 	}

builder/hyperv/common/powershell/powershell.go

@@ -7,12 +7,14 @@ import (
 	"bytes"
 	"fmt"
 	"io"
+	"io/ioutil"
 	"log"
 	"os"
 	"os/exec"
 	"strconv"
 	"strings"
 
+	"github.com/hashicorp/packer-plugin-hyperv/builder/hyperv/common/wsl"
 	"github.com/hashicorp/packer-plugin-sdk/tmp"
 )
 
@@ -57,6 +59,12 @@ func (ps *PowerShellCmd) Output(fileContents string, params ...string) (string,
 	if !debug {
 		defer os.Remove(filename)
 	}
+	if wsl.IsWSL() {
+		filename, err = wsl.ConvertWSlPathToWindowsPath(filename)
+		if err != nil {
+			return "", err
+		}
+	}
 
 	args := createArgs(filename, params...)
 
@@ -105,7 +113,7 @@ func (ps *PowerShellCmd) Output(fileContents string, params ...string) (string,
 }
 
 func IsPowershellAvailable() (bool, string, error) {
-	path, err := exec.LookPath("powershell")
+	path, err := exec.LookPath("powershell.exe")
 	if err != nil {
 		return false, "", err
 	} else {
@@ -127,7 +135,25 @@ func (ps *PowerShellCmd) getPowerShellPath() (string, error) {
 }
 
 func saveScript(fileContents string) (string, error) {
-	file, err := tmp.File("powershell")
+
+	file, err := tmp.File("Powershell")
+	// If under WSL2 then we need a file on the windows drive
+	if wsl.IsWSL() {
+		tmpDir, err := wsl.GetWSlTemp()
+		if err != nil {
+			return "", err
+		}
+
+		wslTempDir, err := wsl.ConvertWindowsPathToWSlPath(tmpDir)
+		if err != nil {
+			return "", err
+		}
+		file, err = ioutil.TempFile(wslTempDir, "powershell")
+		if err != nil {
+			return "", err
+		}
+	}
+
 	if err != nil {
 		return "", err
 	}

builder/hyperv/common/step_mount_dvddrive.go

@@ -10,6 +10,7 @@ import (
 	"path/filepath"
 	"strings"
 
+	"github.com/hashicorp/packer-plugin-hyperv/builder/hyperv/common/wsl"
 	"github.com/hashicorp/packer-plugin-sdk/multistep"
 	packersdk "github.com/hashicorp/packer-plugin-sdk/packer"
 )
@@ -35,6 +36,16 @@ func (s *StepMountDvdDrive) Run(ctx context.Context, state multistep.StateBag) m
 		return multistep.ActionContinue
 	}
 
+	if wsl.IsWSL() {
+		var err error
+		isoPath, err = wsl.ConvertWSlPathToWindowsPath(isoPath)
+		if err != nil {
+			state.Put("error", err)
+			ui.Error(err.Error())
+			return multistep.ActionHalt
+		}
+	}
+
 	// Determine if its a virtual hdd to mount
 	if strings.ToLower(filepath.Ext(isoPath)) == ".vhd" || strings.ToLower(filepath.Ext(isoPath)) == ".vhdx" {
 		log.Println("Its a hard disk, not attaching.")

builder/hyperv/common/step_run.go

@@ -7,7 +7,9 @@ import (
 	"context"
 	"fmt"
 	"log"
+	"net"
 
+	"github.com/hashicorp/packer-plugin-hyperv/builder/hyperv/common/wsl"
 	"github.com/hashicorp/packer-plugin-sdk/multistep"
 	packersdk "github.com/hashicorp/packer-plugin-sdk/packer"
 )
@@ -33,6 +35,22 @@ func (s *StepRun) Run(ctx context.Context, state multistep.StateBag) multistep.S
 		return multistep.ActionHalt
 	}
 
+	// If running in WSL and the user has specified the WSL switch, then they
+	// almost certainly want the WSL distribution IP as the host IP as this is
+	// what our http server will be listening on.
+	if wsl.IsWSL() {
+		switchNet := net.IPNet{IP: net.ParseIP(hostIp), Mask: net.IPv4Mask(255, 255, 240, 0)}
+		addrs, err := net.InterfaceAddrs()
+		if err == nil {
+			for _, address := range addrs {
+				if ipnet, ok := address.(*net.IPNet); ok && switchNet.Contains(ipnet.IP) {
+					hostIp = ipnet.IP.String()
+					break
+				}
+			}
+		}
+	}
+
 	ui.Say(fmt.Sprintf("Host IP for the HyperV machine: %s", hostIp))
 	state.Put("http_ip", hostIp)
 

builder/hyperv/common/wsl/wsl.go

@@ -0,0 +1,112 @@
+package wsl
+
+import (
+	"bytes"
+	"fmt"
+	"io/ioutil"
+	"os/exec"
+	"runtime"
+	"strings"
+)
+
+func IsWSL() bool {
+	var isWSL bool
+	isWSL = false
+	if runtime.GOOS == "linux" {
+		content, err := ioutil.ReadFile("/proc/version")
+		if err == nil {
+			s := string(content)
+			if strings.Contains(s, "WSL2") {
+				isWSL = true
+			}
+		}
+	}
+	return isWSL
+}
+
+func GetWSlTemp() (string, error) {
+
+	var stdout, stderr bytes.Buffer
+	args := make([]string, 3)
+	args[0] = "/c"
+	args[1] = "echo"
+
+	args[2] = "%TEMP%"
+	command := exec.Command("cmd.exe", args...)
+	command.Stdout = &stdout
+	command.Stderr = &stderr
+
+	err := command.Run()
+
+	stderrString := strings.TrimSpace(stderr.String())
+
+	if _, ok := err.(*exec.ExitError); ok {
+		err = fmt.Errorf("Error getting wsl TEMP dir: %s", stderrString)
+		return "", err
+	}
+
+	if len(stderrString) > 0 {
+		err = fmt.Errorf("Error getting wsl TEMP dir: %s", stderrString)
+		return "", err
+	}
+
+	return strings.TrimSpace(stdout.String()), err
+}
+
+func ConvertWindowsPathToWSlPath(winPath string) (string, error) {
+
+	var stdout, stderr bytes.Buffer
+	args := make([]string, 3)
+	args[0] = "-a"
+	args[1] = "-u"
+
+	args[2] = winPath
+	command := exec.Command("wslpath", args...)
+	command.Stdout = &stdout
+	command.Stderr = &stderr
+
+	err := command.Run()
+
+	stderrString := strings.TrimSpace(stderr.String())
+
+	if _, ok := err.(*exec.ExitError); ok {
+		err = fmt.Errorf("wslpath error: %s", stderrString)
+		return "", err
+	}
+
+	if len(stderrString) > 0 {
+		err = fmt.Errorf("wslpath error: %s", stderrString)
+		return "", err
+	}
+
+	return strings.TrimSpace(stdout.String()), err
+}
+
+func ConvertWSlPathToWindowsPath(wslPath string) (string, error) {
+
+	var stdout, stderr bytes.Buffer
+	args := make([]string, 3)
+	args[0] = "-a"
+	args[1] = "-w"
+
+	args[2] = wslPath
+	command := exec.Command("wslpath", args...)
+	command.Stdout = &stdout
+	command.Stderr = &stderr
+
+	err := command.Run()
+
+	stderrString := strings.TrimSpace(stderr.String())
+
+	if _, ok := err.(*exec.ExitError); ok {
+		err = fmt.Errorf("wslpath error: %s", stderrString)
+		return "", err
+	}
+
+	if len(stderrString) > 0 {
+		err = fmt.Errorf("wslpath error: %s", stderrString)
+		return "", err
+	}
+
+	return strings.TrimSpace(stdout.String()), err
+}

builder/hyperv/common/wsl/wsl_test.go

@@ -0,0 +1,55 @@
+package wsl
+
+import (
+	"os"
+	"testing"
+)
+
+func TestGetWSlTemp(t *testing.T) {
+
+	if !IsWSL() {
+		t.Skipf("not running in WSL")
+		return
+	}
+	tempDir, err := GetWSlTemp()
+	if err != nil {
+		t.Fatalf("should not have error: %s", err)
+	}
+	if tempDir == "" {
+		t.Fatalf("tempDir is not polulated correctly")
+	}
+}
+
+func TestConvertWindowsPathToWSlPath(t *testing.T) {
+
+	if !IsWSL() {
+		t.Skipf("not running in WSL")
+		return
+	}
+	wslPath, err := ConvertWindowsPathToWSlPath("C:\\Users\\User\\path with spaces")
+	if err != nil {
+		t.Fatalf("should not have error: %s", err)
+	}
+	if wslPath == "" {
+		t.Fatalf("wslPath is not polulated correctly")
+	}
+}
+
+func TestConvertWSlPathToWindowsPath(t *testing.T) {
+
+	if !IsWSL() {
+		t.Skipf("not running in WSL")
+		return
+	}
+	curDir, err := os.Getwd()
+	if err != nil {
+		t.Fatalf("Getwd should not have error: %s", err)
+	}
+	winPath, err := ConvertWSlPathToWindowsPath(curDir)
+	if err != nil {
+		t.Fatalf("ConvertWSlPathToWindowsPath should not have error: %s", err)
+	}
+	if winPath == "" {
+		t.Fatalf("wslPath is not polulated correctly")
+	}
+}