Skip to content
Open
Show file tree
Hide file tree
Changes from all commits
Commits
File filter

Filter by extension

Filter by extension

Conversations
Failed to load comments.
Loading
Jump to
Jump to file
Failed to load files.
Loading
Diff view
Diff view
114 changes: 114 additions & 0 deletions session/auth/auth_test.go
Original file line number Diff line number Diff line change
@@ -0,0 +1,114 @@
package auth

import (
"context"
"testing"
"time"

"github.com/moby/buildkit/session"
"github.com/moby/buildkit/session/testutil"
"github.com/moby/buildkit/util/grpcerrors"
"github.com/pkg/errors"
"github.com/stretchr/testify/require"
"google.golang.org/grpc"
"google.golang.org/grpc/codes"
"google.golang.org/grpc/status"
)

func TestSessionAuthTimeout(t *testing.T) {
original := SessionAuthTimeout
SessionAuthTimeout = 100 * time.Millisecond
t.Cleanup(func() { SessionAuthTimeout = original })

sm, err := session.NewManager()
require.NoError(t, err)

s, err := session.NewSession(t.Context(), "")
require.NoError(t, err)

s.Allow(blockingAuthServer{})
done := make(chan error, 1)
go func() { done <- s.Run(t.Context(), session.Dialer(testutil.TestStream(sm.HandleConn))) }()
t.Cleanup(func() { require.NoError(t, s.Close()); require.NoError(t, <-done) })

ctx, cancel := context.WithTimeoutCause(t.Context(), 10*time.Second, errors.New("waiting for auth session"))
defer cancel()

_, err = sm.Get(ctx, s.ID(), false)
require.NoError(t, err)

g := session.NewGroup(s.ID())
for _, tc := range []struct {
name string
call func(context.Context) error
}{
{
name: "resolving credentials from session",
call: func(ctx context.Context) error {
_, _, _, err := CredentialsFunc(ctx, sm, g)("registry.example.com")
return err
},
},
{
name: "fetching auth token from session",
call: func(ctx context.Context) error { _, err := FetchToken(ctx, &FetchTokenRequest{}, sm, g); return err },
},
{
name: "getting token authority from session",
call: func(ctx context.Context) error {
_, _, err := GetTokenAuthority(ctx, "registry.example.com", sm, g)
return err
},
},
{
name: "verifying token authority from session",
call: func(ctx context.Context) error {
_, _, err := VerifyTokenAuthority(ctx, "registry.example.com", new([32]byte), sm, g)
return err
},
},
} {
t.Run(tc.name, func(t *testing.T) {
err := tc.call(t.Context())
require.ErrorIs(t, err, context.DeadlineExceeded)
require.EqualError(t, err, tc.name+": context deadline exceeded")
encoded := grpcerrors.ToGRPC(t.Context(), err)
require.Equal(t, codes.DeadlineExceeded, status.Code(encoded))
require.Equal(t, err.Error(), status.Convert(encoded).Message())

parent, cancel := context.WithCancelCause(t.Context())
cause := errors.Wrap(context.Canceled, "build canceled")
cancel(cause)
err = tc.call(parent)
require.ErrorIs(t, err, cause)
require.Equal(t, codes.Canceled, grpcerrors.Code(err))
require.NotContains(t, err.Error(), tc.name)
})
}
}

type blockingAuthServer struct{ UnimplementedAuthServer }

func (s blockingAuthServer) Register(server *grpc.Server) {
RegisterAuthServer(server, s)
}

func (blockingAuthServer) Credentials(ctx context.Context, _ *CredentialsRequest) (*CredentialsResponse, error) {
<-ctx.Done()
return nil, context.Cause(ctx)
}

func (blockingAuthServer) FetchToken(ctx context.Context, _ *FetchTokenRequest) (*FetchTokenResponse, error) {
<-ctx.Done()
return nil, context.Cause(ctx)
}

func (blockingAuthServer) GetTokenAuthority(ctx context.Context, _ *GetTokenAuthorityRequest) (*GetTokenAuthorityResponse, error) {
<-ctx.Done()
return nil, context.Cause(ctx)
}

func (blockingAuthServer) VerifyTokenAuthority(ctx context.Context, _ *VerifyTokenAuthorityRequest) (*VerifyTokenAuthorityResponse, error) {
<-ctx.Done()
return nil, context.Cause(ctx)
}
13 changes: 12 additions & 1 deletion util/grpcerrors/intercept.go
Original file line number Diff line number Diff line change
Expand Up @@ -8,6 +8,7 @@ import (
"github.com/moby/buildkit/util/stack"
"github.com/pkg/errors"
"google.golang.org/grpc"
"google.golang.org/grpc/status"
)

func UnaryServerInterceptor(ctx context.Context, req any, info *grpc.UnaryServerInfo, handler grpc.UnaryHandler) (resp any, err error) {
Expand Down Expand Up @@ -38,7 +39,17 @@ func StreamServerInterceptor(srv any, ss grpc.ServerStream, info *grpc.StreamSer
}

func UnaryClientInterceptor(ctx context.Context, method string, req, reply any, cc *grpc.ClientConn, invoker grpc.UnaryInvoker, opts ...grpc.CallOption) error {
err := FromGRPC(invoker(ctx, method, req, reply, cc, opts...))
err := invoker(ctx, method, req, reply, cc, opts...)
if err != nil {
ctxErr := ctx.Err() //nolint:forbidigo // Match gRPC's status before restoring a custom cancellation cause.
if ctxErr != nil {
st, ok := status.FromError(err)
if ok && st.Code() == Code(ctxErr) && st.Message() == ctxErr.Error() && len(st.Details()) == 0 {
return errors.WithStack(WrapCode(context.Cause(ctx), st.Code()))
}
}
}
err = FromGRPC(err)
if err != nil {
stack.Helper()
}
Expand Down
126 changes: 126 additions & 0 deletions util/grpcerrors/intercept_test.go
Original file line number Diff line number Diff line change
@@ -0,0 +1,126 @@
package grpcerrors_test

import (
"context"
"net"
"testing"
"time"

"github.com/moby/buildkit/util/grpcerrors"
"github.com/pkg/errors"
"github.com/stretchr/testify/require"
"google.golang.org/grpc"
"google.golang.org/grpc/codes"
"google.golang.org/grpc/credentials/insecure"
health "google.golang.org/grpc/health/grpc_health_v1"
"google.golang.org/grpc/status"
)

func TestUnaryClientCancellationCause(t *testing.T) {
t.Parallel()
listener, err := (&net.ListenConfig{}).Listen(t.Context(), "tcp", "127.0.0.1:0")
require.NoError(t, err)
server := grpc.NewServer()
started := make(chan struct{})
health.RegisterHealthServer(server, &blockingHealthServer{started: started})
go func() { _ = server.Serve(listener) }()
t.Cleanup(server.Stop)
conn, err := grpc.NewClient("passthrough:///test",
grpc.WithTransportCredentials(insecure.NewCredentials()),
grpc.WithContextDialer(func(ctx context.Context, _ string) (net.Conn, error) {
return (&net.Dialer{}).DialContext(ctx, "tcp", listener.Addr().String())
}),
grpc.WithUnaryInterceptor(grpcerrors.UnaryClientInterceptor),
)
require.NoError(t, err)
t.Cleanup(func() { require.NoError(t, conn.Close()) })

// Only the derived RPC context is canceled, as with session health failures.
parent := t.Context()
ctx, cancel := context.WithCancelCause(parent)
defer cancel(context.Canceled)
cause := errors.New("session healthcheck failed fatally")
result := make(chan error, 1)
go func() { _, err := health.NewHealthClient(conn).Check(ctx, &health.HealthCheckRequest{}); result <- err }()
select {
case <-started:
case <-time.After(10 * time.Second):
t.Fatal("RPC did not start")
}
cancel(cause)
select {
case err := <-result:
require.ErrorIs(t, err, cause)
require.Equal(t, codes.Canceled, grpcerrors.Code(err))
encoded := grpcerrors.ToGRPC(parent, err)
require.Equal(t, codes.Canceled, status.Code(encoded))
require.Contains(t, status.Convert(encoded).Message(), cause.Error())
require.NoError(t, context.Cause(parent))
case <-time.After(10 * time.Second):
t.Fatal("RPC did not stop")
}
}

type blockingHealthServer struct {
health.UnimplementedHealthServer
started chan struct{}
}

func (s *blockingHealthServer) Check(ctx context.Context, _ *health.HealthCheckRequest) (*health.HealthCheckResponse, error) {
close(s.started)
<-ctx.Done()
return nil, context.Cause(ctx)
}

func TestUnaryClientPreservesRPCError(t *testing.T) {
t.Parallel()
ctx, cancel := context.WithCancelCause(t.Context())
cancel(errors.New("local cancellation"))
for _, tc := range []struct {
name string
err error
}{
{
name: "success",
},
{
name: "unrelated status",
err: status.Error(codes.PermissionDenied, "denied"),
},
{
name: "remote cancellation",
err: status.Error(codes.Canceled, "remote operation canceled"),
},
} {
t.Run(tc.name, func(t *testing.T) {
err := grpcerrors.UnaryClientInterceptor(ctx, "/test", nil, nil, nil, func(context.Context, string, any, any, *grpc.ClientConn, ...grpc.CallOption) error { return tc.err })
if tc.err == nil {
require.NoError(t, err)
return
}
require.Equal(t, status.Code(tc.err), grpcerrors.Code(err))
require.Contains(t, err.Error(), status.Convert(tc.err).Message())
})
}
}

func TestUnaryClientDeadlineCause(t *testing.T) {
t.Parallel()
cause := errors.New("frontend startup timed out")
ctx, cancel := context.WithTimeoutCause(t.Context(), -time.Second, cause)
defer cancel()
rpcErr := status.Error(codes.DeadlineExceeded, "context deadline exceeded")
invoke := func(context.Context, string, any, any, *grpc.ClientConn, ...grpc.CallOption) error { return rpcErr }
err := grpcerrors.UnaryClientInterceptor(ctx, "/test", nil, nil, nil, invoke)
require.ErrorIs(t, err, cause)
require.Equal(t, codes.DeadlineExceeded, grpcerrors.Code(err))
encoded := grpcerrors.ToGRPC(t.Context(), err)
require.Equal(t, codes.DeadlineExceeded, status.Code(encoded))
require.Equal(t, cause.Error(), status.Convert(encoded).Message())

// A remote deadline must remain intact while the local context is live.
err = grpcerrors.UnaryClientInterceptor(t.Context(), "/test", nil, nil, nil, invoke)
require.Equal(t, codes.DeadlineExceeded, grpcerrors.Code(err))
require.NotErrorIs(t, err, cause)
require.Contains(t, err.Error(), "context deadline exceeded")
}