User/maksiman/add binary logging support

.gitignore

@@ -1 +1,2 @@
 *.exe
+.idea

cmd/containerd-shim-runhcs-v1/log.go

@@ -0,0 +1,52 @@
+/*
+Example logger, which writes to 2 different files
+*/
+
+package main
+
+import (
+	"context"
+	"io"
+	"os"
+	"sync"
+
+	"github.com/Microsoft/hcsshim/cmd/logging"
+)
+
+func _main() {
+	logging.Run(logger)
+}
+
+func logger(_ context.Context, config *logging.Config, ready func() error) error {
+	var wg sync.WaitGroup
+	wg.Add(2)
+
+	fileOut, err := os.Create("C:/Users/Administrator/LCOW/container-stdout.txt")
+	defer fileOut.Close()
+	if err != nil {
+		return err
+	}
+
+	fileErr, err := os.Create("C:/Users/Administrator/LCOW/container-stderr.txt")
+	defer fileErr.Close()
+	if err != nil {
+		return err
+	}
+
+	go func() {
+		defer wg.Done()
+		io.Copy(fileOut, config.Stdout)
+	}()
+
+	go func() {
+		defer wg.Done()
+		io.Copy(fileErr, config.Stderr)
+	}()
+
+	if err := ready(); err != nil {
+		return err
+	}
+
+	wg.Wait()
+	return nil
+}

cmd/containerd-shim-runhcs-v1/task_hcs.go

@@ -3,6 +3,7 @@ package main
 import (
 	"context"
 	"fmt"
+	"net/url"
 	"os"
 	"path/filepath"
 	"sync"
@@ -124,7 +125,18 @@ func newHcsTask(
 
 	owner := filepath.Base(os.Args[0])
 
-	io, err := cmd.NewNpipeIO(ctx, req.Stdin, req.Stdout, req.Stderr, req.Terminal)
+	var (
+		io cmd.UpstreamIO
+	)
+
+	u, err := url.Parse(req.Stdout)
+
+	if u.Scheme != "binary" || err != nil {
+		io, err = cmd.NewNpipeIO(ctx, req.Stdin, req.Stdout, req.Stderr, req.Terminal)
+	} else {
+		io, err = cmd.NewBinaryIO(ctx, req.ID, u)
+	}
+
 	if err != nil {
 		return nil, err
 	}
@@ -177,7 +189,8 @@ func newHcsTask(
 		req.Bundle,
 		ht.isWCOW,
 		s.Process,
-		io)
+		io,
+	)
 
 	if parent != nil {
 		// We have a parent UVM. Listen for its exit and forcibly close this
@@ -284,11 +297,35 @@ func (ht *hcsTask) CreateExec(ctx context.Context, req *task.ExecProcessRequest,
 		return errors.Wrapf(errdefs.ErrFailedPrecondition, "exec: '' in task: '%s' must be running to create additional execs", ht.id)
 	}
 
-	io, err := cmd.NewNpipeIO(ctx, req.Stdin, req.Stdout, req.Stderr, req.Terminal)
+	var (
+		io  cmd.UpstreamIO
+		err error
+	)
+
+	u, err := url.Parse(req.Stdout)
+
+	if err != nil || u.Scheme != "binary" {
+		io, err = cmd.NewNpipeIO(ctx, req.Stdin, req.Stdout, req.Stderr, req.Terminal)
+	} else {
+		io, err = cmd.NewBinaryIO(ctx, req.ID, u)
+	}
+
 	if err != nil {
 		return err
 	}
-	he := newHcsExec(ctx, ht.events, ht.id, ht.host, ht.c, req.ExecID, ht.init.Status().Bundle, ht.isWCOW, spec, io)
+	he := newHcsExec(
+		ctx,
+		ht.events,
+		ht.id,
+		ht.host,
+		ht.c,
+		req.ExecID,
+		ht.init.Status().Bundle,
+		ht.isWCOW,
+		spec,
+		io,
+	)
+
 	ht.execs.Store(req.ExecID, he)
 
 	// Publish the created event

cmd/logging/logging.go

@@ -0,0 +1,87 @@
+package logging
+
+import (
+	"bufio"
+	"context"
+	"fmt"
+	"io"
+	"os"
+	"time"
+
+	"github.com/Microsoft/go-winio"
+)
+
+// Config is passed to the binary logging function
+type Config struct {
+	ID        string
+	Namespace string
+	Stdout    io.Reader
+	Stderr    io.Reader
+}
+
+// LoggerFunc is a binary logging function signature
+type LoggerFunc func(context.Context, *Config, func() error) error
+
+// Run runs LoggerFunc
+func Run(fn LoggerFunc) {
+	ctx, cancel := context.WithCancel(context.Background())
+	defer cancel()
+
+	var errCh = make(chan error, 0)
+
+	sout, _ := winio.DialPipeContext(ctx, os.Getenv("CONTAINER_STDOUT"))
+	serr, _ := winio.DialPipeContext(ctx, os.Getenv("CONTAINER_STDERR"))
+	wait, _ := winio.DialPipeContext(ctx, os.Getenv("CONTAINER_WAIT"))
+
+	config := &Config{
+		ID:        os.Getenv("CONTAINER_ID"),
+		Namespace: os.Getenv("CONTAINER_NAMESPACE"),
+		Stdout:    sout,
+		Stderr:    serr,
+	}
+
+	// Write to wait pipe
+	ready := func() error {
+		wait.Write([]byte("#"))
+		return wait.Close()
+	}
+
+	f, _ := os.Create("C:/Users/Administrator/LCOW/binary-results.txt")
+	defer f.Close()
+
+	w := bufio.NewWriter(f)
+	w.WriteString("Starting logging goroutine\n")
+	w.Flush()
+
+	go func() {
+		if err := fn(ctx, config, ready); err != nil {
+			w.WriteString("Binary exited with error. sending error via channel\n")
+			w.Flush()
+			errCh <- err
+			return
+		}
+		w.WriteString("Binary exited normally.\n")
+		w.Flush()
+		errCh <- nil
+	}()
+
+	w.WriteString("Started logging goroutine\n")
+	w.Flush()
+
+	for {
+		select {
+		case err := <-errCh:
+			w.WriteString(fmt.Sprintf("Received from error channel: %s\n", err))
+			w.Flush()
+			if err != nil {
+				fmt.Fprintln(os.Stderr, err)
+				os.Exit(1)
+			}
+			os.Exit(0)
+		default:
+			w.WriteString("Nothing received, sleeping for 500ms\n")
+			w.Flush()
+			time.Sleep(500 * time.Millisecond)
+		}
+	}
+}