add windows support. (#60)

Add support for windows, which mostly consists of correctly handling path names, path lookups and signals.

.circleci/config.yml

@@ -1,36 +1,48 @@
 version: 2.1
 orbs:
-  go: circleci/go@1.7.0
+  win: circleci/windows@2.4.1
 
 jobs:
   test-linux:
     parameters:
       go:
         type: string
+    docker:
+      - image: cimg/go:<< parameters.go >>
+    steps:
+      - checkout:
+          path: github.com/vanadium/go.lib
+      - run:
+          name: test
+          command: |
+            cd github.com/vanadium/go.lib
+            go test -race --covermode=atomic ./...
+
+  test-windows:
     executor:
-      name: go/default
-      tag: << parameters.go >>
+      name: win/default
     steps:
-      - checkout
-      - go/load-cache
-      - go/mod-download
-      - go/save-cache
-      - go/test:
-          covermode: atomic
-          failfast: true
-          race: true
+      - run: git config --global core.autocrlf false
+      - checkout:
+          path: github.com/vanadium/go.lib
+      - run:
+          name: install mingw
+          command: |
+            choco install mingw
+      - run:
+          name: test
+          command: |
+            cd github.com/vanadium/go.lib
+            go test -race --covermode=atomic ./...
 
   lint:
     parameters:
       go:
         type: string
-    executor:
-      name: go/default
-      tag: << parameters.go >>
+    docker:
+      - image: cimg/go:<< parameters.go >>
     steps:
       - checkout
-      - go/load-cache
-      - go/mod-download
       - run:
           name: downloads
           command: |
@@ -42,7 +54,6 @@ jobs:
           command: |
             golangci-lint run ./...
             validjson ./...
-      - go/save-cache
 
 workflows:
   circleci:
@@ -51,7 +62,8 @@ workflows:
           matrix:
             parameters:
               go: ["1.13", "1.17"]
+      - test-windows
       - lint:
           matrix:
             parameters:
-              go: ["1.16"]
+              go: ["1.17"]

cmd/flagvar/expandenv_unix.go

@@ -0,0 +1,22 @@
+// Copyright 2021 cloudeng llc. All rights reserved.
+// Use of this source code is governed by the Apache-2.0
+// license that can be found in the LICENSE file.
+
+//go:build !windows
+// +build !windows
+
+package flagvar
+
+import (
+	"os"
+)
+
+// ExpandEnv is like os.ExpandEnv but supports 'pseudo' environment
+// variables that have OS specific handling as follows:
+//
+// On Windows $HOME and $PATH are replaced by and $HOMEDRIVE:\\$HOMEPATH
+// and $Path respectively.
+// On Windows /'s are replaced with \'s.
+func ExpandEnv(e string) string {
+	return os.ExpandEnv(e)
+}

cmd/flagvar/expandenv_windows.go

@@ -0,0 +1,24 @@
+// Copyright 2021 cloudeng llc. All rights reserved.
+// Use of this source code is governed by the Apache-2.0
+// license that can be found in the LICENSE file.
+
+//go:build windows
+// +build windows
+
+package flagvar
+
+import (
+	"os"
+	"strings"
+)
+
+// ExpandEnv is like os.ExpandEnv but supports 'pseudo' environment
+// variables that have OS specific handling as follows:
+//
+// On Windows $HOME and $PATH are replaced by and $HOMEDRIVE:\\$HOMEPATH
+// and $Path respectively.
+// On Windows /'s are replaced with \'s.
+func ExpandEnv(e string) string {
+	e = strings.ReplaceAll(e, "$HOME", `$HOMEDRIVE$HOMEPATH`)
+	return strings.ReplaceAll(os.ExpandEnv(e), `/`, `\`)
+}

cmd/flagvar/flagvar.go

@@ -17,7 +17,6 @@ package flagvar
 import (
 	"flag"
 	"fmt"
-	"os"
 	"reflect"
 	"strconv"
 	"time"
@@ -107,7 +106,7 @@ func parseField(t, field string, allowEmpty, expectMore bool) (value, remaining
 // be supplied. All fields can be quoted (with ') if they need to contain
 // a comma.
 //
-// Default values may contain shell variables as per os.ExpandEnv.
+// Default values may contain shell variables as per flagvar.ExpandEnv.
 // So $HOME/.configdir may be used for example.
 func ParseFlagTag(t string) (name, value, usage string, err error) {
 	if len(t) == 0 {
@@ -158,7 +157,7 @@ func literalDefault(typeName, literal string, initialValue interface{}) (value i
 		value = defaultLiteralValue(typeName)
 		return
 	}
-	if tmp := os.ExpandEnv(literal); tmp != literal {
+	if tmp := ExpandEnv(literal); tmp != literal {
 		usageDefault = literal
 		literal = tmp
 	}

cmd/flagvar/flagvar_test.go

@@ -39,7 +39,7 @@ func ExampleRegisterFlagsInStruct() {
 	flagSet.Parse([]string{"--int-flag=42"})
 	fmt.Println(eg.A)
 	fmt.Println(eg.B)
-	if got, want := eg.H, filepath.Join(os.Getenv("HOME"), "config"); got != want {
+	if got, want := eg.H, filepath.Join(flagvar.ExpandEnv("$HOME"), "config"); got != want {
 		fmt.Printf("got %v, want %v", got, want)
 	}
 	// Output:

cmdline/cmdline_test.go

@@ -20,6 +20,7 @@ import (
 	"testing"
 
 	"v.io/x/lib/envvar"
+	"v.io/x/lib/lookpath"
 )
 
 var (
@@ -2505,7 +2506,7 @@ func TestExternalSubcommand(t *testing.T) {
 
 	// Build the external subcommands.
 	for _, subCmd := range []string{"exitcode", "flags", "flat", "foreign", "nested", "repeated"} {
-		cmd := exec.Command("go", "build", "-o", filepath.Join(tmpDir, "unlikely-"+subCmd), filepath.Join(".", "testdata", subCmd+".go"))
+		cmd := exec.Command("go", "build", "-o", lookpath.ExecutableFilename(filepath.Join(tmpDir, "unlikely-"+subCmd)), filepath.Join(".", "testdata", subCmd+".go"))
 		if out, err := cmd.CombinedOutput(); err != nil {
 			t.Fatalf("%v, %v", string(out), err)
 		}
@@ -2971,6 +2972,7 @@ The global flags are:
 			Stdout: `global1="A B" shared="C D" local="E F" ["x" "y" "z"]` + "\n",
 		},
 	}
+	tests = tests[:1]
 	runTestCases(t, cmd, tests)
 }
 

go.mod

@@ -6,4 +6,5 @@ require (
 	github.com/spf13/pflag v1.0.5
 	golang.org/x/crypto v0.0.0-20210220033148-5ea612d1eb83
 	golang.org/x/net v0.0.0-20210226172049-e18ecbb05110
+	golang.org/x/sys v0.0.0-20201119102817-f84b799fce68 // indirect
 )

gosh/cmd.go

@@ -506,12 +506,11 @@ func isClosedPipeError(err error) bool {
 	if err == io.ErrClosedPipe {
 		return true
 	}
-	// Closed pipe on os.Pipe; mirrors logic in os/exec/exec_posix.go.
-	if pe, ok := err.(*os.PathError); ok {
-		if pe.Op == "write" && pe.Path == "|1" && pe.Err == syscall.EPIPE {
-			return true
-		}
+
+	if isSysClosedPipeError(err) {
+		return true
 	}
+
 	// Process exited due to a SIGPIPE signal.
 	if ee, ok := err.(*exec.ExitError); ok {
 		if ws, ok := ee.ProcessState.Sys().(syscall.WaitStatus); ok {
@@ -672,7 +671,8 @@ func (c *Cmd) signal(sig os.Signal) error {
 	if !c.isRunning() {
 		return nil
 	}
-	if err := c.c.Process.Signal(sig); err != nil && err.Error() != errFinished {
+	if err := c.c.Process.Signal(TranslateSignal(sig)); err != nil && err.Error() != errFinished {
+		fmt.Printf("cmd signal: %v -> %v: %v\n", sig, TranslateSignal(sig), err)
 		return err
 	}
 	return nil

gosh/pipeline_test.go

@@ -184,7 +184,7 @@ func TestPipelineSignal(t *testing.T) {
 			time.Sleep(100 * time.Millisecond)
 			p.Signal(s)
 			switch {
-			case s == os.Interrupt:
+			case gosh.TranslateSignal(s) == os.Interrupt:
 				// Wait should succeed as long as the exit code was 0, regardless of
 				// whether the signal arrived or the processes had already exited.
 				p.Wait()

gosh/shell.go

@@ -598,6 +598,7 @@ func buildGoPkg(sh *Shell, binDir, pkg string, flags ...string) (string, error)
 	default:
 		binPath = filepath.Join(binDir, outputFlag)
 	}
+	binPath = ExecutableFilename(binPath)
 	// If the binary already exists at the target location, don't rebuild it.
 	if _, err := os.Stat(binPath); err == nil {
 		return binPath, nil

gosh/shell_test.go

@@ -26,12 +26,12 @@ import (
 	"runtime/debug"
 	"strconv"
 	"strings"
-	"syscall"
 	"testing"
 	"time"
 
 	"v.io/x/lib/gosh"
 	lib "v.io/x/lib/gosh/internal/gosh_example_lib"
+	"v.io/x/lib/lookpath"
 )
 
 var errFake = errors.New("fake error")
@@ -506,7 +506,7 @@ func TestLookPath(t *testing.T) {
 	defer sh.Cleanup()
 
 	binDir := sh.MakeTempDir()
-	sh.Vars["PATH"] = binDir + ":" + sh.Vars["PATH"]
+	sh.Vars["PATH"] = binDir + string(filepath.ListSeparator) + sh.Vars[lookpath.PathEnvVar]
 	relName := "hw"
 	absName := filepath.Join(binDir, relName)
 	gosh.BuildGoPkg(sh, "", helloWorldPkg, "-o", absName)
@@ -863,7 +863,7 @@ func TestSignal(t *testing.T) {
 			time.Sleep(100 * time.Millisecond)
 			c.Signal(s)
 			switch {
-			case s == os.Interrupt:
+			case gosh.TranslateSignal(s) == os.Interrupt:
 				// Wait should succeed as long as the exit code was 0, regardless of
 				// whether the signal arrived or the process had already exited.
 				c.Wait()
@@ -892,25 +892,6 @@ var processGroup = gosh.RegisterFunc("processGroup", func(n int) {
 	time.Sleep(time.Minute)
 })
 
-func TestCleanupProcessGroup(t *testing.T) {
-	sh := gosh.NewShell(t)
-	defer sh.Cleanup()
-
-	c := sh.FuncCmd(processGroup, 5)
-	c.Start()
-	pids := c.AwaitVars("pids")["pids"]
-	c.Signal(os.Interrupt)
-
-	// Wait for all processes in the child's process group to exit.
-	for syscall.Kill(-c.Pid(), 0) != syscall.ESRCH {
-		time.Sleep(100 * time.Millisecond)
-	}
-	for _, pid := range strings.Split(pids, ",") {
-		p, _ := strconv.Atoi(pid)
-		eq(t, syscall.Kill(p, 0), syscall.ESRCH)
-	}
-}
-
 func TestTerminate(t *testing.T) {
 	sh := gosh.NewShell(t)
 	defer sh.Cleanup()
@@ -1104,21 +1085,21 @@ func TestBuildGoPkg(t *testing.T) {
 	// Set -o to an absolute name.
 	relName := "hw"
 	absName := filepath.Join(sh.MakeTempDir(), relName)
-	eq(t, gosh.BuildGoPkg(sh, "", helloWorldPkg, "-o", absName), absName)
+	eq(t, gosh.BuildGoPkg(sh, "", helloWorldPkg, "-o", absName), gosh.ExecutableFilename(absName))
 	c := sh.Cmd(absName)
 	eq(t, c.Stdout(), helloWorldStr)
 
 	// Set -o to a relative name with no path separators.
 	binDir := sh.MakeTempDir()
 	absName = filepath.Join(binDir, relName)
-	eq(t, gosh.BuildGoPkg(sh, binDir, helloWorldPkg, "-o", relName), absName)
+	eq(t, gosh.BuildGoPkg(sh, binDir, helloWorldPkg, "-o", relName), gosh.ExecutableFilename(absName))
 	c = sh.Cmd(absName)
 	eq(t, c.Stdout(), helloWorldStr)
 
 	// Set -o to a relative name that contains a path separator.
 	relNameWithSlash := filepath.Join("subdir", relName)
 	absName = filepath.Join(binDir, relNameWithSlash)
-	eq(t, gosh.BuildGoPkg(sh, binDir, helloWorldPkg, "-o", relNameWithSlash), absName)
+	eq(t, gosh.BuildGoPkg(sh, binDir, helloWorldPkg, "-o", relNameWithSlash), gosh.ExecutableFilename(absName))
 	c = sh.Cmd(absName)
 	eq(t, c.Stdout(), helloWorldStr)
 
@@ -1133,7 +1114,7 @@ func TestBuildGoPkg(t *testing.T) {
 
 	// Use --o instead of -o.
 	absName = filepath.Join(sh.MakeTempDir(), relName)
-	gosh.BuildGoPkg(sh, "", helloWorldPkg, "--o", absName)
+	gosh.BuildGoPkg(sh, "", helloWorldPkg, "--o", gosh.ExecutableFilename(absName))
 	c = sh.Cmd(absName)
 	eq(t, c.Stdout(), helloWorldStr)
 }

gosh/shell_unix_test.go

@@ -0,0 +1,38 @@
+// Copyright 2015 The Vanadium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+//go:build !windows
+// +build !windows
+
+package gosh_test
+
+import (
+	"os"
+	"strconv"
+	"strings"
+	"syscall"
+	"testing"
+	"time"
+
+	"v.io/x/lib/gosh"
+)
+
+func TestCleanupProcessGroup(t *testing.T) {
+	sh := gosh.NewShell(t)
+	defer sh.Cleanup()
+
+	c := sh.FuncCmd(processGroup, 5)
+	c.Start()
+	pids := c.AwaitVars("pids")["pids"]
+	c.Signal(os.Interrupt)
+
+	// Wait for all processes in the child's process group to exit.
+	for syscall.Kill(-c.Pid(), 0) != syscall.ESRCH {
+		time.Sleep(100 * time.Millisecond)
+	}
+	for _, pid := range strings.Split(pids, ",") {
+		p, _ := strconv.Atoi(pid)
+		eq(t, syscall.Kill(p, 0), syscall.ESRCH)
+	}
+}