Add ~/.wsl2hosts feature for adding aliases

Author: shayne

.gitignore

@@ -1 +1,5 @@
-*.exe
+*.exe
+vendor/
+example/
+foo.go
+foo_test.go

cmd/wsl2host/pkg/service/service.go

@@ -5,6 +5,8 @@ import (
 	"regexp"
 	"strings"
 
+	"github.com/shayne/go-wsl2-host/internal/wsl2hosts"
+
 	"github.com/shayne/go-wsl2-host/pkg/hostsapi"
 
 	"github.com/shayne/go-wsl2-host/pkg/wslapi"
@@ -29,13 +31,14 @@ func Run() error {
 		return fmt.Errorf("failed to get infos: %w", err)
 	}
 
-	hapi, err := hostsapi.CreateAPI(tld)
+	hapi, err := hostsapi.CreateAPI("wsl2-host") // filtere only managed host entries
 	if err != nil {
 		return fmt.Errorf("failed to create hosts api: %w", err)
 	}
 
 	updated := false
 	hostentries := hapi.Entries()
+
 	for _, i := range infos {
 		hostname := distroNameToHostname(i.Name)
 		// remove stopped distros
@@ -58,12 +61,64 @@ func Run() error {
 				he.IP = ip
 			}
 		} else {
-			updated = true
 			// add running distros not present
-			hapi.AddEntry(&hostsapi.HostEntry{
+			err := hapi.AddEntry(&hostsapi.HostEntry{
 				Hostname: hostname,
 				IP:       ip,
+				Comment:  wsl2hosts.DefaultComment(),
+			})
+			if err == nil {
+				updated = true
+			}
+		}
+	}
+
+	// process aliases
+	defdistro, _ := wslapi.GetDefaultDistro()
+	if err != nil {
+		return fmt.Errorf("GetDefaultDistro failed: %w", err)
+	}
+	var aliasmap = make(map[string]interface{})
+	defdistroip, _ := wslapi.GetIP(defdistro.Name)
+	if defdistro.Running {
+		aliases, err := wslapi.GetHostAliases()
+		if err == nil {
+			for _, a := range aliases {
+				aliasmap[a] = nil
+			}
+		}
+	}
+	// update entries after distro processing
+	hostentries = hapi.Entries()
+	for _, he := range hostentries {
+		if !wsl2hosts.IsAlias(he.Comment) {
+			continue
+		}
+		// update IP for aliases when running and if it exists in aliasmap
+		if _, ok := aliasmap[he.Hostname]; ok && defdistro.Running {
+			if he.IP != defdistroip {
+				updated = true
+				he.IP = defdistroip
+			}
+		} else { // remove entry when not running or not in aliasmap
+			err := hapi.RemoveEntry(he.Hostname)
+			if err == nil {
+				updated = true
+			}
+		}
+	}
+
+	for hostname := range aliasmap {
+		// add new aliases
+		if _, ok := hostentries[hostname]; !ok && defdistro.Running {
+			err := hapi.AddEntry(&hostsapi.HostEntry{
+				IP:       defdistroip,
+				Hostname: hostname,
+				Comment:  wsl2hosts.DistroComment(defdistro.Name),
 			})
+			if err == nil {
+				updated = true
+			}
 		}
 	}
 

go.mod

@@ -3,6 +3,7 @@ module github.com/shayne/go-wsl2-host
 go 1.12
 
 require (
+	github.com/stretchr/testify v1.4.0
 	golang.org/x/crypto v0.0.0-20190621222207-cc06ce4a13d4
 	golang.org/x/sys v0.0.0-20190626221950-04f50cda93cb
 	golang.org/x/text v0.3.0

go.sum

@@ -1,3 +1,11 @@
+github.com/davecgh/go-spew v1.1.0 h1:ZDRjVQ15GmhC3fiQ8ni8+OwkZQO4DARzQgrnXU1Liz8=
+github.com/davecgh/go-spew v1.1.0/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38=
+github.com/pmezard/go-difflib v1.0.0 h1:4DBwDE0NGyQoBHbLQYPwSUPoCMWR5BEzIk/f1lZbAQM=
+github.com/pmezard/go-difflib v1.0.0/go.mod h1:iKH77koFhYxTK1pcRnkKkqfTogsbg7gZNVY4sRDYZ/4=
+github.com/stretchr/objx v0.1.0 h1:4G4v2dO3VZwixGIRoQ5Lfboy6nUhCyYzaqnIAPPhYs4=
+github.com/stretchr/objx v0.1.0/go.mod h1:HFkY916IF+rwdDfMAkV7OtwuqBVzrE8GR6GFx+wExME=
+github.com/stretchr/testify v1.4.0 h1:2E4SXV/wtOkTonXsotYi4li6zVWxYlZuYNCXe9XRJyk=
+github.com/stretchr/testify v1.4.0/go.mod h1:j7eGeouHqKxXV5pUuKE4zz7dFj8WfuZ+81PSLYec5m4=
 golang.org/x/crypto v0.0.0-20190308221718-c2843e01d9a2/go.mod h1:djNgcEr1/C05ACkg1iLfiJU5Ep61QUkGW8qpdssI0+w=
 golang.org/x/crypto v0.0.0-20190621222207-cc06ce4a13d4 h1:ydJNl0ENAG67pFbB+9tfhiL2pYqLhfoaZFw/cjLhY4A=
 golang.org/x/crypto v0.0.0-20190621222207-cc06ce4a13d4/go.mod h1:yigFU9vqHzYiE8UmvKecakEJjdnWj3jj499lnFckfCI=
@@ -8,3 +16,7 @@ golang.org/x/sys v0.0.0-20190626221950-04f50cda93cb h1:fgwFCsaw9buMuxNd6+DQfAuSF
 golang.org/x/sys v0.0.0-20190626221950-04f50cda93cb/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
 golang.org/x/text v0.3.0 h1:g61tztE5qeGQ89tm6NTjjM9VPIm088od1l6aSorWRWg=
 golang.org/x/text v0.3.0/go.mod h1:NqM8EUOU14njkJ3fqMW+pc6Ldnwhi/IjpwHt7yyuwOQ=
+gopkg.in/check.v1 v0.0.0-20161208181325-20d25e280405 h1:yhCVgyC4o1eVCa2tZl7eS0r+SDo693bJlVdllGtEeKM=
+gopkg.in/check.v1 v0.0.0-20161208181325-20d25e280405/go.mod h1:Co6ibVJAznAaIkqp8huTwlJQCZ016jof/cbN4VW5Yz0=
+gopkg.in/yaml.v2 v2.2.2 h1:ZCJp+EgiOT7lHqUV2J862kp8Qj64Jo6az82+3Td9dZw=
+gopkg.in/yaml.v2 v2.2.2/go.mod h1:hI93XBmqTisBFMUTm0b8Fm+jr3Dg1NNxqwp+5A1VGuI=

internal/wsl2hosts/wsl2hosts.go

@@ -0,0 +1,46 @@
+// Package wsl2hosts provides helpers for managing alias
+// host entries
+package wsl2hosts
+
+import (
+	"fmt"
+	"strings"
+)
+
+const prefix = "alias:"
+const defaultComment = "managed by wsl2-host"
+
+// IsAlias returns true if given string matches alias pattern
+func IsAlias(comment string) bool {
+	return strings.HasPrefix(comment, prefix)
+}
+
+// DistroName returns the name of the WSL distro the host
+// entry is an alias for
+func DistroName(comment string) (string, error) {
+	if !IsAlias(comment) {
+		return "", fmt.Errorf("comment is not alias: %s", comment)
+	}
+
+	var name string
+	for _, c := range comment[len(prefix):] {
+		if c == ';' {
+			break
+		}
+		name += string(c)
+	}
+
+	name = strings.TrimSpace(name)
+	return name, nil
+}
+
+// DistroComment returns hosts file comment alias
+// for given distro name
+func DistroComment(distroname string) string {
+	return fmt.Sprintf("%s %s; %s", prefix, distroname, defaultComment)
+}
+
+// DefaultComment returns basic comment for managed host entires
+func DefaultComment() string {
+	return defaultComment
+}

internal/wsl2hosts/wsl2hosts_test.go

@@ -0,0 +1,36 @@
+package wsl2hosts
+
+import (
+	"testing"
+
+	"github.com/stretchr/testify/assert"
+)
+
+func TestIsAlias(t *testing.T) {
+	assert.True(t, IsAlias("alias: Ubuntu-18.04; managed by wsl2-host"))
+	assert.False(t, IsAlias("managed by wsl2-host"))
+}
+
+func TestDistroName(t *testing.T) {
+	name, err := DistroName("alias: Ubuntu-18.04; managed by wsl2-host")
+	assert.Nil(t, err)
+	assert.Equal(t, "Ubuntu-18.04", name)
+	name, err = DistroName("alias: ClearLinux; managed by wsl2-host")
+	assert.Nil(t, err)
+	assert.Equal(t, "ClearLinux", name)
+	name, err = DistroName("alias: Foo Bar; managed by wsl2-host")
+	assert.Nil(t, err)
+	assert.Equal(t, "Foo Bar", name)
+	name, err = DistroName("managed by wsl2-host")
+	assert.NotNil(t, err)
+	assert.Equal(t, "", name)
+}
+
+func TestDistroComment(t *testing.T) {
+	comment := DistroComment("Ubuntu-18.04")
+	assert.Equal(t, "alias: Ubuntu-18.04; managed by wsl2-host", comment)
+}
+
+func TestDefaultComment(t *testing.T) {
+	assert.Equal(t, "managed by wsl2-host", DefaultComment())
+}

pkg/hostsapi/hostsapi.go

@@ -16,6 +16,7 @@ type HostEntry struct {
 	idx      int
 	IP       string
 	Hostname string
+	Comment  string
 }
 
 // HostsAPI data structure
@@ -35,25 +36,37 @@ func parseHostfileLine(idx int, line string) ([]*HostEntry, error) {
 		return nil, errors.New("comment line")
 	}
 	fields := strings.Fields(line)
-	var validfields []string
-	for _, f := range fields {
-		if len(f) <= 0 {
+	var ip string
+	var hostnames []string
+	var comment string
+	var commentidx int
+	for i, f := range fields {
+		if f == "" {
 			continue
 		}
 		if f[0] == '#' { // inline comment
+			commentidx = i + 1
 			break // don't process any more
 		}
-		validfields = append(validfields, f)
+		if i == 0 {
+			ip = f
+		} else {
+			hostnames = append(hostnames, f)
+		}
+	}
+	if commentidx > 0 {
+		comment = strings.Join(fields[commentidx:], " ")
 	}
-	if len(validfields) <= 1 {
+	if ip == "" || len(hostnames) == 0 {
 		return nil, fmt.Errorf("invalid fields for line: %q", line)
 	}
 	var entries []*HostEntry
-	for _, hostname := range validfields[1:] {
+	for _, hostname := range hostnames {
 		entries = append(entries, &HostEntry{
 			idx:      idx,
-			IP:       validfields[0],
+			IP:       ip,
 			Hostname: hostname,
+			Comment:  comment,
 		})
 	}
 
@@ -72,7 +85,7 @@ func (h *HostsAPI) loadAndParse() error {
 			continue
 		}
 		for _, e := range entries {
-			if h.filter == "" || strings.Contains(e.Hostname, h.filter) {
+			if h.filter == "" || strings.Contains(e.Comment, h.filter) {
 				h.entries[e.Hostname] = e
 				h.remidxs[e.idx] = nil
 			}
@@ -155,10 +168,13 @@ func (h *HostsAPI) Write() error {
 
 	// append entries to file
 	for _, e := range h.entries {
-		outbuf.WriteString(fmt.Sprintf("%s %s    # managed by wsl2-host\r\n", e.IP, e.Hostname))
+		var comment string
+		if e.Comment != "" {
+			comment = fmt.Sprintf("    # %s", e.Comment)
+		}
+		outbuf.WriteString(fmt.Sprintf("%s %s%s\r\n", e.IP, e.Hostname, comment))
 	}
 
-	fmt.Println(string(outbuf.Bytes()))
 	f, err := os.OpenFile(hostspath, os.O_WRONLY|os.O_TRUNC, 0600)
 	if err != nil {
 		return fmt.Errorf("failed to open hosts file for writing: %w", err)

pkg/wslapi/wslapi.go

@@ -62,6 +62,20 @@ func GetAllInfo() ([]*DistroInfo, error) {
 	return infos, nil
 }
 
+// GetDefaultDistro returns the info for the default distro
+func GetDefaultDistro() (*DistroInfo, error) {
+	infos, err := GetAllInfo()
+	if err != nil {
+		return nil, fmt.Errorf("GetAllInfo failed: %w", err)
+	}
+	for _, i := range infos {
+		if i.Default == true {
+			return i, nil
+		}
+	}
+	return nil, errors.New("failed to find default")
+}
+
 // IsRunning returns whether or not a given WSL distro is running
 func IsRunning(name string) (bool, error) {
 	running, err := wslcli.RunningDistros()
@@ -87,3 +101,24 @@ func GetIP(name string) (string, error) {
 	}
 	return "", fmt.Errorf("GetIP failed, distro '%s' is not running", name)
 }
+
+// GetHostAliases returns custom hosts referenced in `~/.wsl2hosts`
+// of default WSL distro
+func GetHostAliases() ([]string, error) {
+	info, err := GetDefaultDistro()
+	if err != nil {
+		return nil, fmt.Errorf("GetDefaultDistro failed: %w", err)
+	}
+	if !info.Running {
+		return nil, errors.New("default distro not running")
+	}
+	out, err := wslcli.RunCommand("cat", "~/.wsl2hosts")
+	if err != nil {
+		return nil, fmt.Errorf("RunCommand failed: %w", err)
+	}
+	out = strings.TrimSpace(out)
+	if out == "" {
+		return nil, fmt.Errorf("no host aliases")
+	}
+	return strings.Split(out, " "), nil
+}

pkg/wslcli/wslcli.go

@@ -59,6 +59,19 @@ func GetIP(name string) (string, error) {
 	return ips[0], nil
 }
 
+// RunCommand runs the given command via `bash -c` under
+// the default WSL distro
+func RunCommand(command string, args ...string) (string, error) {
+	cmdstr := fmt.Sprintf("%s %s", command, strings.Join(args, " "))
+	cmd := exec.Command("wsl.exe", "--", "bash", "-c", cmdstr)
+	out, err := cmd.Output()
+	if err != nil {
+		return "", err
+	}
+	sout := string(out)
+	return sout, nil
+}
+
 // GetHostIP returns the IP address of Hyper-V Switch on the host connected to WSL
 func GetHostIP() (string, error) {
 	cmd := exec.Command("netsh", "interface", "ip", "show", "address", "vEthernet (WSL)") //, "|", "findstr", "IP Address", "|", "%", "{", "$_", "-replace", "IP Address:", "", "}", "|", "%", "{", "$_", "-replace", " ", "", "}")