wip xterminal windows support

cmoog · cmoog · commit 12f601adc1e4 · 2020-07-27T19:31:55.000-05:00
Change-Id: I93f662b3e8383f881dc53df139dc13e4618beeb2
diff --git a/cmd/coder/resize_unix.go b/cmd/coder/resize_unix.go
@@ -13,17 +13,17 @@ import (
 	"go.coder.com/flog"
 )
 
-func resizeEvents(ctx context.Context, termfd int) chan resizeEvent {
+func resizeEvents(ctx context.Context, termfd uintptr) chan resizeEvent {
 	sigs := make(chan os.Signal, 16)
 	signal.Notify(sigs, unix.SIGWINCH)
 
 	events := make(chan resizeEvent)
 
 	go func() {
 		for ctx.Err() == nil {
-			width, height, err := terminal.GetSize(termfd)
+			width, height, err := terminal.GetSize(int(termfd))
 			if err != nil {
-				flog.Error("get term size: %v", err)
+				flog.Error("get unix terminal size: %v", err)
 				break
 			}
 			events <- resizeEvent{
diff --git a/cmd/coder/resize_windows.go b/cmd/coder/resize_windows.go
@@ -7,13 +7,14 @@ import (
 	"time"
 
 	"golang.org/x/crypto/ssh/terminal"
+	"golang.org/x/sys/windows"
 
 	"go.coder.com/flog"
 )
 
 // windows does have a unix.SIGWINCH equivalent, so we poll the terminal size
 // and send resize events when needed
-func resizeEvents(ctx context.Context, termfd int) chan resizeEvent {
+func resizeEvents(ctx context.Context, termfd uintptr) chan resizeEvent {
 	events := make(chan resizeEvent)
 	t := time.Tick(time.Millisecond * 100)
 
@@ -23,12 +24,12 @@ func resizeEvents(ctx context.Context, termfd int) chan resizeEvent {
 		for {
 			select {
 			case <-ctx.Done():
-				break
+				return
 			case <-t:
-				width, height, err := terminal.GetSize(termfd)
+				width, height, err := terminal.GetSize(int(windows.Handle(termfd)))
 				if err != nil {
-					flog.Error("get term size: %v", err)
-					break
+					flog.Error("get terminal size: %v", err)
+					return
 				}
 				event := resizeEvent{
 					height: uint16(height),
diff --git a/cmd/coder/shell.go b/cmd/coder/shell.go
@@ -16,6 +16,7 @@ import (
 	"go.coder.com/flog"
 
 	"cdr.dev/coder-cli/internal/activity"
+	"cdr.dev/coder-cli/internal/xterminal"
 	"cdr.dev/wsep"
 )
 
@@ -30,19 +31,6 @@ func (cmd *shellCmd) Spec() cli.CommandSpec {
 	}
 }
 
-func enableTerminal(fd int) (restore func(), err error) {
-	state, err := terminal.MakeRaw(fd)
-	if err != nil {
-		return restore, xerrors.Errorf("make raw term: %w", err)
-	}
-	return func() {
-		err := terminal.Restore(fd, state)
-		if err != nil {
-			flog.Error("restore term state: %v", err)
-		}
-	}, nil
-}
-
 type resizeEvent struct {
 	height, width uint16
 }
@@ -54,25 +42,6 @@ func (s resizeEvent) equal(s2 *resizeEvent) bool {
 	return s.height == s2.height && s.width == s2.width
 }
 
-func sendResizeEvents(ctx context.Context, termfd int, process wsep.Process) {
-	events := resizeEvents(ctx, termfd)
-
-	// Limit the frequency of resizes to prevent a stuttering effect.
-	resizeLimiter := rate.NewLimiter(rate.Every(time.Millisecond*100), 1)
-	for {
-		select {
-		case newsize := <-events:
-			err := process.Resize(ctx, newsize.height, newsize.width)
-			if err != nil {
-				return
-			}
-			_ = resizeLimiter.Wait(ctx)
-		case <-ctx.Done():
-			return
-		}
-	}
-}
-
 func (cmd *shellCmd) Run(fl *pflag.FlagSet) {
 	if len(fl.Args()) < 1 {
 		exitUsage(fl)
@@ -103,21 +72,45 @@ func (cmd *shellCmd) Run(fl *pflag.FlagSet) {
 	}
 }
 
+func sendResizeEvents(ctx context.Context, termfd uintptr, process wsep.Process) {
+	events := resizeEvents(ctx, termfd)
+
+	// Limit the frequency of resizes to prevent a stuttering effect.
+	resizeLimiter := rate.NewLimiter(rate.Every(time.Millisecond*100), 1)
+	for {
+		select {
+		case newsize := <-events:
+			err := process.Resize(ctx, newsize.height, newsize.width)
+			if err != nil {
+				return
+			}
+			_ = resizeLimiter.Wait(ctx)
+		case <-ctx.Done():
+			return
+		}
+	}
+}
+
 func runCommand(ctx context.Context, envName string, command string, args []string) error {
 	var (
 		entClient = requireAuth()
 		env       = findEnv(entClient, envName)
 	)
 
-	termfd := int(os.Stdin.Fd())
+	termfd := os.Stdin.Fd()
 
-	tty := terminal.IsTerminal(termfd)
+	tty := terminal.IsTerminal(int(termfd))
 	if tty {
-		restore, err := enableTerminal(termfd)
+		state, err := xterminal.MakeRaw(termfd)
 		if err != nil {
 			return err
 		}
-		defer restore()
+		defer func() {
+			err := xterminal.Restore(termfd, state)
+			if err != nil {
+				flog.Error("restore term state: %v", err)
+			}
+		}()
 	}
 
 	ctx, cancel := context.WithCancel(ctx)
diff --git a/internal/xterminal/doc.go b/internal/xterminal/doc.go
@@ -0,0 +1,13 @@
+// Package xterminal provides functions to change termios or console attributes
+// and restore them later on. It supports Unix and Windows.
+//
+// This does the same thing as x/crypto/ssh/terminal on Linux. On Windows, it
+// sets the same console modes as the terminal package but also sets
+// `ENABLE_VIRTUAL_TERMINAL_INPUT` and `ENABLE_VIRTUAL_TERMINAL_PROCESSING` to
+// allow for VT100 sequences in the console. This is important, otherwise Linux
+// apps (with colors or ncurses) that are run through SSH or wsep get
+// garbled in a Windows console.
+//
+// More details can be found out about Windows console modes here:
+// https://docs.microsoft.com/en-us/windows/console/setconsolemode
+package xterminal
diff --git a/internal/xterminal/terminal.go b/internal/xterminal/terminal.go
@@ -0,0 +1,37 @@
+// +build !windows
+
+package xterminal
+
+import (
+	"golang.org/x/crypto/ssh/terminal"
+)
+
+// State differs per-platform.
+type State struct {
+	s *terminal.State
+}
+
+// MakeRaw sets the terminal to raw.
+func MakeRaw(fd uintptr) (*State, error) {
+	s, err := terminal.MakeRaw(int(fd))
+	return &State{s}, err
+}
+
+// MakeOutputRaw does nothing on non-Windows platforms.
+func MakeOutputRaw(fd uintptr) (*State, error) {
+	return nil, nil
+}
+
+// Restore terminal back to original state.
+func Restore(fd uintptr, state *State) error {
+	if state == nil {
+		return nil
+	}
+
+	return terminal.Restore(int(fd), state.s)
+}
+
+// ColorEnabled returns true on Linux if handle is a terminal.
+func ColorEnabled(fd uintptr) (bool, error) {
+	return terminal.IsTerminal(int(fd)), nil
+}
diff --git a/internal/xterminal/terminal_windows.go b/internal/xterminal/terminal_windows.go
@@ -0,0 +1,68 @@
+// +build windows
+
+package xterminal
+
+import (
+	"golang.org/x/sys/windows"
+)
+
+// State differs per-platform.
+type State struct {
+	mode uint32
+}
+
+func makeRaw(handle windows.Handle, input bool) (uint32, error) {
+	var st uint32
+	if err := windows.GetConsoleMode(handle, &st); err != nil {
+		return 0, err
+	}
+
+	var raw uint32
+	if input {
+		raw = st &^ (windows.ENABLE_ECHO_INPUT | windows.ENABLE_PROCESSED_INPUT | windows.ENABLE_LINE_INPUT | windows.ENABLE_PROCESSED_OUTPUT)
+		raw |= windows.ENABLE_VIRTUAL_TERMINAL_INPUT
+	} else {
+		raw = st | windows.ENABLE_VIRTUAL_TERMINAL_PROCESSING
+	}
+
+	if err := windows.SetConsoleMode(handle, raw); err != nil {
+		return 0, err
+	}
+	return st, nil
+}
+
+// MakeRaw sets an input terminal to raw and enables VT100 processing.
+func MakeRaw(handle uintptr) (*State, error) {
+	inSt, err := makeRaw(windows.Handle(handle), true)
+	if err != nil {
+		return nil, err
+	}
+
+	return &State{inSt}, nil
+}
+
+// MakeOutputRaw sets an output terminal to raw and enables VT100 processing.
+func MakeOutputRaw(handle uintptr) (*State, error) {
+	outSt, err := makeRaw(windows.Handle(handle), false)
+	if err != nil {
+		return nil, err
+	}
+
+	return &State{outSt}, nil
+}
+
+// Restore terminal back to original state.
+func Restore(handle uintptr, state *State) error {
+	return windows.SetConsoleMode(windows.Handle(handle), state.mode)
+}
+
+// ColorEnabled returns true if VT100 processing is enabled on the output
+// console.
+func ColorEnabled(handle uintptr) (bool, error) {
+	var st uint32
+	if err := windows.GetConsoleMode(windows.Handle(handle), &st); err != nil {
+		return false, err
+	}
+
+	return st&windows.ENABLE_VIRTUAL_TERMINAL_PROCESSING != 0, nil
+}
