cmd/utils: Add an asynchronous cancellable version of askForConfirmation

A subsequent commit will use this to ensure that the user can still
interact with the image download prompt while 'skopeo inspect' fetches
the image size from the remote registry.  Initially, the prompt will be
shown without the image size.  Once the size has been fetched, the older
prompt will be cancelled and a new one will be shown that includes the
size.

#752
#1263

Author: debarshiray

src/cmd/utils.go

@@ -18,14 +18,25 @@ package cmd
 
 import (
 	"bufio"
+	"context"
+	"encoding/binary"
 	"errors"
 	"fmt"
+	"io"
 	"os"
 	"os/exec"
 	"strings"
 	"syscall"
 
 	"github.com/containers/toolbox/pkg/utils"
+	"github.com/sirupsen/logrus"
+	"golang.org/x/sys/unix"
+)
+
+var (
+	errClosed = errors.New("closed")
+
+	errHUP = errors.New("HUP")
 )
 
 // askForConfirmation prints prompt to stdout and waits for response from the
@@ -67,6 +78,158 @@ func askForConfirmation(prompt string) bool {
 	return retVal
 }
 
+func askForConfirmationAsyncScan(doneFD int32) (string, error) {
+	fileFD := int32(os.Stdin.Fd())
+
+	pollFDs := []unix.PollFd{
+		{
+			Fd:      doneFD,
+			Events:  unix.POLLIN,
+			Revents: 0,
+		},
+		{
+			Fd:      fileFD,
+			Events:  unix.POLLIN,
+			Revents: 0,
+		},
+	}
+
+	for {
+		if _, err := unix.Poll(pollFDs, -1); err != nil {
+			if errors.Is(err, unix.EINTR) {
+				logrus.Debugf("Failed to poll(2): %s: ignoring", err)
+				continue
+			}
+
+			return "", fmt.Errorf("poll(2) failed: %w", err)
+		}
+
+		logrus.Debugf("Returned events from poll(2): 0x%x, 0x%x\n", pollFDs[0].Revents, pollFDs[1].Revents)
+
+		if pollFDs[0].Revents&unix.POLLIN != 0 {
+			logrus.Debug("Returned from eventfd: POLLIN")
+
+			for {
+				buffer := make([]byte, 8)
+				if n, err := unix.Read(int(doneFD), buffer); n != len(buffer) || err != nil {
+					break
+				}
+			}
+
+			return "", context.Canceled
+		}
+
+		if pollFDs[0].Revents&unix.POLLNVAL != 0 {
+			logrus.Debug("Returned from eventfd: POLLNVAL")
+			return "", context.Canceled
+		}
+
+		if pollFDs[1].Revents&unix.POLLIN != 0 {
+			logrus.Debug("Returned from /dev/stdin: POLLIN")
+
+			scanner := bufio.NewScanner(os.Stdin)
+			scanner.Split(bufio.ScanLines)
+
+			if !scanner.Scan() {
+				if err := scanner.Err(); err != nil {
+					return "", err
+				} else {
+					return "", io.EOF
+				}
+			}
+
+			response := scanner.Text()
+			return response, nil
+		}
+
+		if pollFDs[1].Revents&unix.POLLHUP != 0 {
+			logrus.Debug("Returned from /dev/stdin: POLLHUP")
+			return "", errHUP
+		}
+
+		if pollFDs[1].Revents&unix.POLLNVAL != 0 {
+			logrus.Debug("Returned from /dev/stdin: POLLNVAL")
+			return "", errClosed
+		}
+	}
+}
+
+func askForConfirmationAsync(ctx context.Context, prompt string, restoreCursor bool) (<-chan bool, <-chan error) {
+	retValCh := make(chan bool)
+	errCh := make(chan error)
+
+	done := ctx.Done()
+	doneFD := -1
+	if done != nil {
+		eventfd, err := unix.Eventfd(0, unix.EFD_CLOEXEC|unix.EFD_NONBLOCK)
+		if err != nil {
+			errCh <- fmt.Errorf("eventfd(2) failed: %w", err)
+			return retValCh, errCh
+		}
+
+		doneFD = eventfd
+	}
+
+	go func() {
+		for {
+			fmt.Printf("%s ", prompt)
+			if restoreCursor {
+				fmt.Printf("\033[u")
+				restoreCursor = false
+			}
+
+			response, err := askForConfirmationAsyncScan(int32(doneFD))
+			if err != nil {
+				errCh <- err
+				break
+			}
+
+			if response == "" {
+				response = "n"
+			} else {
+				response = strings.ToLower(response)
+			}
+
+			if response == "no" || response == "n" {
+				retValCh <- false
+				break
+			} else if response == "yes" || response == "y" {
+				retValCh <- true
+				break
+			}
+		}
+	}()
+
+	go func() {
+		if done == nil {
+			return
+		}
+
+		defer unix.Close(doneFD)
+
+		select {
+		case <-done:
+			// A varint-encoded uint64 takes a maximum of 10 bytes,
+			// as defined by binary.MaxVarintLen64.  However, 1
+			// byte is enough to encode the number 1.  See:
+			// https://protobuf.dev/programming-guides/encoding/
+			//
+			// An eventfd(2) file descriptor expects a uint64 to be
+			// given to write(2).  Luckily, a varint-encoded number
+			// 1 happens to work.
+			buffer := make([]byte, 8)
+			binary.PutUvarint(buffer, 1)
+
+			if _, err := unix.Write(doneFD, buffer); err != nil {
+				panicMsg := fmt.Sprintf("write(2) to eventfd failed: %s", err)
+				panic(panicMsg)
+			}
+		}
+	}()
+
+	return retValCh, errCh
+}
+
 func createErrorContainerNotFound(container string) error {
 	var builder strings.Builder
 	fmt.Fprintf(&builder, "container %s not found\n", container)