wcow: enable custom frontend bridge communication via named pipe

Signed-off-by: Billy Owire <[email protected]>

Author: billywr

executor/containerdexecutor/executor_windows.go

@@ -12,6 +12,7 @@ import (
 	"github.com/moby/buildkit/executor/oci"
 	"github.com/moby/buildkit/snapshot"
 	"github.com/moby/buildkit/solver/pb"
+	"github.com/moby/buildkit/util/appdefaults"
 	"github.com/moby/buildkit/util/network"
 	"github.com/moby/sys/user"
 	"github.com/opencontainers/runtime-spec/specs-go"
@@ -88,6 +89,27 @@ func (w *containerdExecutor) createOCISpec(ctx context.Context, id, _, _ string,
 		return nil, nil, err
 	}
 	releasers = append(releasers, cleanup)
+
+	if v, ok := ctx.Value(appdefaults.ContextKeyCustomFrontend).(bool); ok && v {
+		sid := func() string {
+			for _, e := range meta.Env {
+				if strings.HasPrefix(e, "BUILDKIT_SESSION_ID=") {
+					return strings.TrimPrefix(e, "BUILDKIT_SESSION_ID=")
+				}
+			}
+			return ""
+		}()
+
+		frontendGrpcBridge := appdefaults.FrontendGRPCPipe + sid
+		spec.Mounts = append(spec.Mounts, specs.Mount{
+			Source:      frontendGrpcBridge,
+			Destination: frontendGrpcBridge,
+			Type:        "",
+		})
+		spec.Process.Env = append(spec.Process.Env,
+			"FrontendGRPCPipe="+frontendGrpcBridge,
+		)
+	}
 	return spec, releaseAll, nil
 }
 

frontend/dockerfile/builder/build.go

@@ -2,6 +2,7 @@ package builder
 
 import (
 	"context"
+	"runtime"
 	"strings"
 	"sync"
 
@@ -22,6 +23,7 @@ import (
 	"github.com/moby/buildkit/solver/errdefs"
 	"github.com/moby/buildkit/solver/pb"
 	"github.com/moby/buildkit/solver/result"
+	"github.com/moby/buildkit/util/appdefaults"
 	dockerspec "github.com/moby/docker-image-spec/specs-go/v1"
 	ocispecs "github.com/opencontainers/image-spec/specs-go/v1"
 	"github.com/pkg/errors"
@@ -59,6 +61,9 @@ func Build(ctx context.Context, c client.Client) (_ *client.Result, err error) {
 			}
 			return res, err
 		} else if ref, cmdline, loc, ok := parser.DetectSyntax(src.Data); ok {
+			if runtime.GOOS == "windows" {
+				ctx = context.WithValue(ctx, appdefaults.ContextKeyCustomFrontend, true)
+			}
 			res, err := forwardGateway(ctx, c, ref, cmdline)
 			if err != nil && len(errdefs.Sources(err)) == 0 {
 				return nil, wrapSource(err, src.SourceMap, loc)

frontend/gateway/gateway.go

@@ -9,6 +9,7 @@ import (
 	"net"
 	"os"
 	"path/filepath"
+	"runtime"
 	"slices"
 	"strconv"
 	"strings"
@@ -501,6 +502,8 @@ func newBridgeForwarder(ctx context.Context, llbBridge frontend.FrontendLLBBridg
 }
 
 func serveLLBBridgeForwarder(ctx context.Context, llbBridge frontend.FrontendLLBBridge, exec executor.Executor, workers worker.Infos, inputs map[string]*opspb.Definition, sid string, sm *session.Manager) (*llbBridgeForwarder, context.Context) {
+	var listener net.Listener
+	isWindowsPlatform := runtime.GOOS == "windows"
 	ctx, cancel := context.WithCancelCause(ctx)
 	lbf := newBridgeForwarder(ctx, llbBridge, exec, workers, inputs, sid, sm)
 	serverOpt := []grpc.ServerOption{
@@ -514,11 +517,20 @@ func serveLLBBridgeForwarder(ctx context.Context, llbBridge frontend.FrontendLLB
 	pb.RegisterLLBBridgeServer(server, lbf)
 
 	go func() {
+		if isWindowsPlatform {
+			listener = createNPipeListener(sid)
+			if err := handleWindowsPipeConn(ctx, listener, lbf, cancel); err != nil {
+				return
+			}
+		}
 		serve(ctx, server, lbf.conn)
 		select {
 		case <-ctx.Done():
 		default:
 			lbf.isErrServerClosed = true
+			if isWindowsPlatform && listener != nil {
+				_ = listener.Close()
+			}
 		}
 		cancel(errors.WithStack(context.Canceled))
 	}()

frontend/gateway/gateway_unix.go

@@ -0,0 +1,16 @@
+//go:build !windows
+
+package gateway
+
+import (
+	"context"
+	"net"
+)
+
+func createNPipeListener(_ string) net.Listener {
+	return nil
+}
+
+func handleWindowsPipeConn(_ context.Context, _ net.Listener, _ *llbBridgeForwarder, _ context.CancelCauseFunc) error {
+	return nil
+}

frontend/gateway/gateway_windows.go

@@ -0,0 +1,62 @@
+//go:build windows
+
+package gateway
+
+import (
+	"context"
+	"net"
+
+	"github.com/Microsoft/go-winio"
+	"github.com/moby/buildkit/util/appdefaults"
+	"github.com/moby/buildkit/util/bklog"
+	"github.com/pkg/errors"
+)
+
+func createNPipeListener(sid string) net.Listener {
+	pipeCfg := &winio.PipeConfig{
+		SecurityDescriptor: "D:P(A;;GA;;;AU)",
+		MessageMode:        false,
+		InputBufferSize:    4096,
+		OutputBufferSize:   4096,
+	}
+	listener, err := winio.ListenPipe(appdefaults.FrontendGRPCPipe+sid, pipeCfg)
+	if err != nil {
+		bklog.L.Errorf("Failed to initialize named pipe listener: %s", err)
+		return nil
+	}
+	return listener
+}
+
+// handleWindowsPipeConn waits for a client to connect to the named pipe.
+// It assigns the connection to lbf.conn or cancels the context on error or timeout.
+func handleWindowsPipeConn(ctx context.Context, listener net.Listener, lbf *llbBridgeForwarder, cancel context.CancelCauseFunc) error {
+	connCh := make(chan net.Conn, 1)
+	errCh := make(chan error, 1)
+
+	go func() {
+		defer func() {
+			if r := recover(); r != nil {
+				errCh <- errors.Errorf("panic in Accept: %v", r)
+			}
+		}()
+		conn, err := listener.Accept()
+		if err != nil {
+			errCh <- err
+			return
+		}
+		connCh <- conn
+	}()
+
+	select {
+	case <-ctx.Done():
+		_ = listener.Close()
+		return context.Cause(ctx)
+	case err := <-errCh:
+		lbf.isErrServerClosed = true
+		cancel(errors.WithStack(err))
+		return err
+	case conn := <-connCh:
+		lbf.conn = conn
+		return nil
+	}
+}

frontend/gateway/grpcclient/client.go

@@ -7,6 +7,7 @@ import (
 	"io"
 	"net"
 	"os"
+	"runtime"
 	"strings"
 	"sync"
 	"syscall"
@@ -1235,10 +1236,17 @@ func (r *reference) StatFile(ctx context.Context, req client.StatRequest) (*fsty
 }
 
 func grpcClientConn(ctx context.Context) (context.Context, *grpc.ClientConn, error) {
+	addr := "localhost"
+	dialer := grpc.WithContextDialer(func(ctx context.Context, addr string) (net.Conn, error) {
+		return stdioConn(), nil
+	})
+
+	if runtime.GOOS == "windows" {
+		addr, dialer = nPipeDialer()
+	}
+
 	dialOpts := []grpc.DialOption{
-		grpc.WithContextDialer(func(ctx context.Context, addr string) (net.Conn, error) {
-			return stdioConn(), nil
-		}),
+		dialer,
 		grpc.WithTransportCredentials(insecure.NewCredentials()),
 		grpc.WithUnaryInterceptor(grpcerrors.UnaryClientInterceptor),
 		grpc.WithStreamInterceptor(grpcerrors.StreamClientInterceptor),
@@ -1247,7 +1255,7 @@ func grpcClientConn(ctx context.Context) (context.Context, *grpc.ClientConn, err
 	}
 
 	//nolint:staticcheck // ignore SA1019 NewClient has different behavior and needs to be tested
-	cc, err := grpc.DialContext(ctx, "localhost", dialOpts...)
+	cc, err := grpc.DialContext(ctx, addr, dialOpts...)
 	if err != nil {
 		return ctx, nil, errors.Wrap(err, "failed to create grpc client")
 	}

frontend/gateway/grpcclient/client_unix.go

@@ -0,0 +1,9 @@
+//go:build !windows
+
+package grpcclient
+
+import "google.golang.org/grpc"
+
+func nPipeDialer() (string, grpc.DialOption) {
+	return "", nil
+}

frontend/gateway/grpcclient/client_windows.go

@@ -0,0 +1,25 @@
+//go:build windows
+
+package grpcclient
+
+import (
+	"context"
+	"net"
+	"os"
+
+	"github.com/Microsoft/go-winio"
+	"github.com/pkg/errors"
+	"google.golang.org/grpc"
+)
+
+func nPipeDialer() (string, grpc.DialOption) {
+	addr := os.Getenv("FrontendGRPCPipe")
+	dialFn := func(ctx context.Context, _ string) (net.Conn, error) {
+		conn, err := winio.DialPipe(addr, nil)
+		if err != nil {
+			return nil, errors.Wrap(err, "Failed to connect to gRPC server")
+		}
+		return conn, nil
+	}
+	return addr, grpc.WithContextDialer(dialFn)
+}

util/appdefaults/appdefaults.go

@@ -1,6 +1,9 @@
 package appdefaults
 
+type contextKey string
+
 const (
-	BridgeName   = "buildkit0"
-	BridgeSubnet = "10.10.0.0/16"
+	BridgeName               = "buildkit0"
+	BridgeSubnet             = "10.10.0.0/16"
+	ContextKeyCustomFrontend = contextKey("custom.frontend.context.flag")
 )

util/appdefaults/appdefaults_windows.go

@@ -6,7 +6,8 @@ import (
 )
 
 const (
-	Address = "npipe:////./pipe/buildkitd"
+	Address          = "npipe:////./pipe/buildkitd"
+	FrontendGRPCPipe = `\\.\pipe\buildkitd-frontend-`
 )
 
 var (