diff --git a/docs/oauth-login.md b/docs/oauth-login.md index b2016580bb..a6128974fd 100644 --- a/docs/oauth-login.md +++ b/docs/oauth-login.md @@ -57,7 +57,9 @@ published callback port — the server falls back to the [device-code flow](#headless-and-device-code-fallback). GitHub App tokens that expire are refreshed transparently using the refresh -token, so long-running sessions keep working without re-authorizing. +token, so long-running sessions keep working without re-authorizing. Concurrent +requests share a refresh. Canceling a request stops its wait while the refresh +can finish and save the rotated token for the session. ## Quick start diff --git a/internal/ghmcp/oauth.go b/internal/ghmcp/oauth.go index c363da2e50..f99ace5a7a 100644 --- a/internal/ghmcp/oauth.go +++ b/internal/ghmcp/oauth.go @@ -92,7 +92,7 @@ func (p *sessionPrompter) PromptForm(ctx context.Context, prompt oauth.Prompt) e // middleware be exercised with a deterministic fake, since driving the real // manager to its branches would require standing up live GitHub flows. type oauthAuthenticator interface { - HasToken() bool + HasTokenContext(ctx context.Context) (bool, error) Authenticate(ctx context.Context, prompter oauth.Prompter) (*oauth.Outcome, error) AwaitToken(ctx context.Context, flowID string) (*oauth.Outcome, error) Cancel(flowID string) bool @@ -137,7 +137,11 @@ func createOAuthToolMiddleware(mgr oauthAuthenticator, logger *slog.Logger) inve } } - if mgr.HasToken() { + hasToken, err := mgr.HasTokenContext(ctx) + if err != nil { + return nil, err + } + if hasToken { return next(ctx, req) } if serverMayInitiateElicitation(req.Session) { diff --git a/internal/ghmcp/oauth_refresh_transport_test.go b/internal/ghmcp/oauth_refresh_transport_test.go new file mode 100644 index 0000000000..91d3a62fb1 --- /dev/null +++ b/internal/ghmcp/oauth_refresh_transport_test.go @@ -0,0 +1,153 @@ +package ghmcp + +import ( + "context" + "io" + "net/http" + "net/http/httptest" + "strings" + "sync/atomic" + "testing" + "time" + + "github.com/github/github-mcp-server/v2/pkg/github" + "github.com/github/github-mcp-server/v2/pkg/http/headers" + "github.com/stretchr/testify/assert" + "github.com/stretchr/testify/require" +) + +func TestStdioGitHubClientsUseOAuthRequestContext(t *testing.T) { + t.Parallel() + + for _, tt := range []struct { + name string + response string + call func(context.Context, *githubClients) error + }{ + { + name: "REST", response: `{"login":"octocat"}`, + call: func(ctx context.Context, clients *githubClients) error { + _, _, err := clients.rest.Users.Get(ctx, "") + return err + }, + }, + { + name: "GraphQL", response: `{"data":{"viewer":{"login":"octocat"}}}`, + call: func(ctx context.Context, clients *githubClients) error { + var query struct{ Viewer struct{ Login string } } + return clients.gql.Query(ctx, &query, nil) + }, + }, + { + name: "raw", response: "file contents", + call: func(ctx context.Context, clients *githubClients) error { + resp, err := clients.raw.GetRawContent(ctx, "owner", "repo", "file", nil) + if err != nil { + return err + } + return resp.Body.Close() + }, + }, + } { + t.Run(tt.name, func(t *testing.T) { + var requestCount atomic.Int32 + api := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, req *http.Request) { + requestCount.Add(1) + assert.Equal(t, "Bearer refreshed-token", req.Header.Get(headers.AuthorizationHeader)) + w.Header().Set(headers.ContentTypeHeader, headers.ContentTypeJSON) + _, _ = io.WriteString(w, tt.response) + })) + defer api.Close() + + type waitForCancellationKey struct{} + entered := make(chan struct{}, 1) + provider := func(ctx context.Context) (string, error) { + if ctx.Value(waitForCancellationKey{}) == true { + entered <- struct{}{} + <-ctx.Done() + return "", ctx.Err() + } + return "refreshed-token", nil + } + clients, err := createGitHubClients(github.MCPServerConfig{Version: "test"}, newStaticAPIHostResolver(t, api.URL), provider) + require.NoError(t, err) + + ctx, stop := context.WithTimeout(t.Context(), 5*time.Second) + defer stop() + blockedCtx, cancel := context.WithCancel(context.WithValue(ctx, waitForCancellationKey{}, true)) + defer cancel() + finished := make(chan error, 1) + go func() { finished <- tt.call(blockedCtx, clients) }() + select { + case <-entered: + case err := <-finished: + t.Fatalf("request returned before the OAuth provider saw its context: %v", err) + case <-ctx.Done(): + t.Fatal("OAuth provider did not see the request context") + } + + require.NoError(t, tt.call(ctx, clients), "the peer should succeed while the first request waits for a token") + cancel() + select { + case err := <-finished: + require.ErrorIs(t, err, context.Canceled) + case <-ctx.Done(): + t.Fatal("canceling the request did not stop its token wait") + } + assert.EqualValues(t, 1, requestCount.Load(), "only the healthy peer should reach GitHub") + }) + } +} + +func TestStdioOAuthTransportClosesRequestBodyOnProviderError(t *testing.T) { + t.Parallel() + ctx, cancel := context.WithCancel(t.Context()) + cancel() + body := &oauthRequestBody{Reader: strings.NewReader("graphql query")} + req := httptest.NewRequestWithContext(ctx, http.MethodPost, "https://github.example/graphql", body) + base := oauthRoundTripFunc(func(*http.Request) (*http.Response, error) { + t.Fatal("the request reached the underlying transport") + return nil, nil + }) + transport := stdioBearerTransport(github.MCPServerConfig{}, base, []string{req.URL.Host}, func(ctx context.Context) (string, error) { + return "", ctx.Err() + }) + resp, err := transport.RoundTrip(req) + if resp != nil && resp.Body != nil { + defer resp.Body.Close() + } + require.ErrorIs(t, err, context.Canceled) + assert.Nil(t, resp) + assert.True(t, body.closed) +} + +func TestStdioOAuthTransportStripsAuthorizationForUnlistedHost(t *testing.T) { + t.Parallel() + req := httptest.NewRequestWithContext(t.Context(), http.MethodGet, "https://other.example/file", nil) + req.Header.Set(headers.AuthorizationHeader, "Bearer forwarded-token") + base := oauthRoundTripFunc(func(outgoing *http.Request) (*http.Response, error) { + assert.Empty(t, outgoing.Header.Get(headers.AuthorizationHeader)) + return &http.Response{StatusCode: http.StatusOK, Body: http.NoBody}, nil + }) + transport := stdioBearerTransport(github.MCPServerConfig{}, base, []string{"github.example"}, func(context.Context) (string, error) { + return "refreshed-token", nil + }) + resp, err := transport.RoundTrip(req) + require.NoError(t, err) + require.NoError(t, resp.Body.Close()) + assert.Equal(t, "Bearer forwarded-token", req.Header.Get(headers.AuthorizationHeader), "transport must not modify the caller's request") +} + +type oauthRequestBody struct { + io.Reader + closed bool +} + +func (b *oauthRequestBody) Close() error { + b.closed = true + return nil +} + +type oauthRoundTripFunc func(*http.Request) (*http.Response, error) + +func (f oauthRoundTripFunc) RoundTrip(req *http.Request) (*http.Response, error) { return f(req) } diff --git a/internal/ghmcp/oauth_test.go b/internal/ghmcp/oauth_test.go index fc6b37b17f..027fe72711 100644 --- a/internal/ghmcp/oauth_test.go +++ b/internal/ghmcp/oauth_test.go @@ -63,7 +63,7 @@ func TestCreateGitHubClientsScopesRESTAndRawTokens(t *testing.T) { for _, tt := range tests { t.Run(tt.name, func(t *testing.T) { apiHost := newStaticAPIHostResolver(t, source.URL) - clients, err := createGitHubClients(tt.cfg, apiHost) + clients, err := createGitHubClients(tt.cfg, apiHost, nil) require.NoError(t, err) sourceAuth = "" @@ -356,7 +356,9 @@ type fakeAuthenticator struct { lastCancelFlowID string } -func (f *fakeAuthenticator) HasToken() bool { return f.hasToken } +func (f *fakeAuthenticator) HasTokenContext(ctx context.Context) (bool, error) { + return f.hasToken, ctx.Err() +} func (f *fakeAuthenticator) Authenticate(_ context.Context, prompter oauth.Prompter) (*oauth.Outcome, error) { f.authCalls++ @@ -401,6 +403,21 @@ func TestCreateOAuthToolMiddleware(t *testing.T) { assert.Zero(t, fake.authCalls, "authentication must be skipped when a token already exists") }) + t.Run("canceled token check skips authentication and handler", func(t *testing.T) { + t.Parallel() + ctx, cancel := context.WithCancel(t.Context()) + cancel() + + fake := &fakeAuthenticator{} + var called bool + mw := createOAuthToolMiddleware(fake, discardLogger()) + res, err := mw(newNext(&called))(ctx, &mcp.CallToolRequest{}) + assert.ErrorIs(t, err, context.Canceled) + assert.Nil(t, res) + assert.Zero(t, fake.authCalls, "cancellation must not start authentication") + assert.False(t, called, "cancellation must not run the tool") + }) + t.Run("successful authentication proceeds to handler", func(t *testing.T) { t.Parallel() fake := &fakeAuthenticator{hasToken: false, outcome: nil, err: nil} @@ -690,7 +707,7 @@ func TestCreateGitHubClientsTokenProvider(t *testing.T) { clients, err := createGitHubClients(github.MCPServerConfig{ Version: "test", TokenProvider: func() string { return current }, - }, apiHost) + }, apiHost, nil) require.NoError(t, err) do := func() { diff --git a/internal/ghmcp/server.go b/internal/ghmcp/server.go index ac7a90b57d..f4c8201856 100644 --- a/internal/ghmcp/server.go +++ b/internal/ghmcp/server.go @@ -40,8 +40,41 @@ type githubClients struct { repoAccess *lockdown.RepoAccessCache } +type oauthTokenProvider func(context.Context) (string, error) + +type oauthBearerTransport struct { + bearer transport.BearerAuthTransport + token oauthTokenProvider +} + +func (t *oauthBearerTransport) RoundTrip(req *http.Request) (*http.Response, error) { + token, err := t.token(req.Context()) + if err != nil { + if req.Body != nil { + _ = req.Body.Close() + } + return nil, err + } + bearer := t.bearer + bearer.Token = token + return bearer.RoundTrip(req) +} + +func stdioBearerTransport(cfg github.MCPServerConfig, base http.RoundTripper, allowedHosts []string, oauthToken oauthTokenProvider) http.RoundTripper { + bearer := transport.BearerAuthTransport{ + Transport: base, + Token: cfg.Token, + TokenProvider: cfg.TokenProvider, + AllowedHosts: allowedHosts, + } + if oauthToken == nil { + return &bearer + } + return &oauthBearerTransport{bearer: bearer, token: oauthToken} +} + // createGitHubClients creates all the GitHub API clients needed by the server. -func createGitHubClients(cfg github.MCPServerConfig, apiHost utils.APIHostResolver) (*githubClients, error) { +func createGitHubClients(cfg github.MCPServerConfig, apiHost utils.APIHostResolver, oauthToken oauthTokenProvider) (*githubClients, error) { restURL, err := apiHost.BaseRESTURL(context.Background()) if err != nil { return nil, fmt.Errorf("failed to get base REST URL: %w", err) @@ -91,7 +124,7 @@ func createGitHubClients(cfg github.MCPServerConfig, apiHost utils.APIHostResolv Transport: &transport.ETagTransport{Transport: http.DefaultTransport}, Agent: stdioUserAgent(cfg, nil), } - restClient, err := newRESTClient(cfg, restUATransport, restURL.String(), uploadURL.String(), allowedHosts) + restClient, err := newRESTClient(cfg, restUATransport, restURL.String(), uploadURL.String(), allowedHosts, oauthToken) if err != nil { return nil, fmt.Errorf("failed to create REST client: %w", err) } @@ -99,17 +132,12 @@ func createGitHubClients(cfg github.MCPServerConfig, apiHost utils.APIHostResolv // Construct GraphQL client // We use NewEnterpriseClient unconditionally since we already parsed the API host gqlHTTPClient := &http.Client{ - Transport: &transport.BearerAuthTransport{ - Transport: &transport.GraphQLFeaturesTransport{ - Transport: &transport.UserAgentTransport{ - Transport: http.DefaultTransport, - Agent: stdioUserAgent(cfg, nil), - }, + Transport: stdioBearerTransport(cfg, &transport.GraphQLFeaturesTransport{ + Transport: &transport.UserAgentTransport{ + Transport: http.DefaultTransport, + Agent: stdioUserAgent(cfg, nil), }, - Token: cfg.Token, - TokenProvider: cfg.TokenProvider, - AllowedHosts: allowedHosts, - }, + }, allowedHosts, oauthToken), } gqlClient := githubv4.NewEnterpriseClient(graphQLURL.String(), gqlHTTPClient) @@ -121,7 +149,7 @@ func createGitHubClients(cfg github.MCPServerConfig, apiHost utils.APIHostResolv Transport: http.DefaultTransport, Agent: stdioUserAgent(cfg, nil), } - rawRESTClient, err := newRESTClient(cfg, rawUATransport, restURL.String(), uploadURL.String(), allowedHosts) + rawRESTClient, err := newRESTClient(cfg, rawUATransport, restURL.String(), uploadURL.String(), allowedHosts, oauthToken) if err != nil { return nil, fmt.Errorf("failed to create raw REST client: %w", err) } @@ -154,19 +182,18 @@ func createGitHubClients(cfg github.MCPServerConfig, apiHost utils.APIHostResolv // supplied user-agent transport. Authentication uses BearerAuthTransport for // both static and provider-backed tokens, and allowedHosts scopes the token to // the configured GitHub hosts so it is never leaked to off-host redirects. -func newRESTClient(cfg github.MCPServerConfig, uaTransport *transport.UserAgentTransport, restURL, uploadURL string, allowedHosts []string) (*gogithub.Client, error) { +func newRESTClient(cfg github.MCPServerConfig, uaTransport *transport.UserAgentTransport, restURL, uploadURL string, allowedHosts []string, oauthToken oauthTokenProvider) (*gogithub.Client, error) { return gogithub.NewClient( - gogithub.WithHTTPClient(&http.Client{Transport: &transport.BearerAuthTransport{ - Transport: uaTransport, - Token: cfg.Token, - TokenProvider: cfg.TokenProvider, - AllowedHosts: allowedHosts, - }}), + gogithub.WithHTTPClient(&http.Client{Transport: stdioBearerTransport(cfg, uaTransport, allowedHosts, oauthToken)}), gogithub.WithEnterpriseURLs(restURL, uploadURL), ) } func NewStdioMCPServer(ctx context.Context, cfg github.MCPServerConfig) (*mcp.Server, error) { + return newStdioMCPServer(ctx, cfg, nil) +} + +func newStdioMCPServer(ctx context.Context, cfg github.MCPServerConfig, oauthToken oauthTokenProvider) (*mcp.Server, error) { apiHost, err := utils.NewAPIHost(cfg.Host) if err != nil { return nil, fmt.Errorf("failed to parse API host: %w", err) @@ -177,7 +204,7 @@ func NewStdioMCPServer(ctx context.Context, cfg github.MCPServerConfig) (*mcp.Se return nil, fmt.Errorf("failed to classify API host: %w", err) } - clients, err := createGitHubClients(cfg, apiHost) + clients, err := createGitHubClients(cfg, apiHost, oauthToken) if err != nil { return nil, fmt.Errorf("failed to create GitHub clients: %w", err) } @@ -362,14 +389,14 @@ func RunStdioServer(cfg StdioServerConfig) error { logger.Debug("skipping scope filtering for non-PAT token") } - tokenProvider := cfg.TokenProvider + var oauthToken oauthTokenProvider var toolHandlerMiddleware []inventory.ToolHandlerMiddleware if cfg.OAuthManager != nil { - tokenProvider = cfg.OAuthManager.AccessToken + oauthToken = cfg.OAuthManager.AccessTokenContext toolHandlerMiddleware = append(toolHandlerMiddleware, createOAuthToolMiddleware(cfg.OAuthManager, logger)) } - ghServer, err := NewStdioMCPServer(ctx, github.MCPServerConfig{ + ghServer, err := newStdioMCPServer(ctx, github.MCPServerConfig{ Version: cfg.Version, Host: cfg.Host, Token: cfg.Token, @@ -385,9 +412,9 @@ func RunStdioServer(cfg StdioServerConfig) error { Logger: logger, RepoAccessTTL: cfg.RepoAccessCacheTTL, TokenScopes: tokenScopes, - TokenProvider: tokenProvider, + TokenProvider: cfg.TokenProvider, ToolHandlerMiddleware: toolHandlerMiddleware, - }) + }, oauthToken) if err != nil { return fmt.Errorf("failed to create MCP server: %w", err) } diff --git a/internal/ghmcp/server_test.go b/internal/ghmcp/server_test.go index 1d6f844c41..c7e315e64d 100644 --- a/internal/ghmcp/server_test.go +++ b/internal/ghmcp/server_test.go @@ -31,7 +31,7 @@ func TestCreateGitHubClientsGraphQLUserAgent(t *testing.T) { })) defer api.Close() cfg := github.MCPServerConfig{Version: "v1.2.3", Token: "fixture-token", InsidersMode: insiders} - clients, err := createGitHubClients(cfg, newStaticAPIHostResolver(t, api.URL)) + clients, err := createGitHubClients(cfg, newStaticAPIHostResolver(t, api.URL), nil) require.NoError(t, err) var query struct { Viewer struct{ Login string } @@ -143,7 +143,7 @@ func TestStdioGraphQLUserAgent(t *testing.T) { Version: tt.version, Token: "fixture-token", InsidersMode: tt.insiders, Translator: translations.NullTranslationHelper, Logger: discardLogger(), } - clients, err := createGitHubClients(cfg, newStaticAPIHostResolver(t, api.URL)) + clients, err := createGitHubClients(cfg, newStaticAPIHostResolver(t, api.URL), nil) require.NoError(t, err) obs, err := observability.NewExporters(cfg.Logger, metrics.NewNoopMetrics()) require.NoError(t, err) diff --git a/internal/oauth/manager.go b/internal/oauth/manager.go index 8c16729f5b..893edb379c 100644 --- a/internal/oauth/manager.go +++ b/internal/oauth/manager.go @@ -17,8 +17,7 @@ import ( // the user to complete the browser or device flow. const DefaultAuthTimeout = 5 * time.Minute -// tokenRefreshTimeout bounds each background refresh of an expiring token so a -// stalled GitHub token endpoint cannot block a tool call indefinitely. +// tokenRefreshTimeout bounds HTTP calls made by the shared token source. const tokenRefreshTimeout = 30 * time.Second // ErrStaleAuthorizationFlow indicates that a prompt response belongs to an @@ -61,6 +60,11 @@ type UserAction struct { UserCode string } +type tokenRefresh struct { + done chan struct{} + accessToken string +} + // Manager owns the OAuth login flows and the resulting (refreshing) token for a // single stdio session. It is safe for concurrent use; only one authorization // flow runs at a time. @@ -75,7 +79,9 @@ type Manager struct { mu sync.Mutex source oauth2.TokenSource // refreshing source, set once authorized - tokenGeneration uint64 // increments whenever source is replaced + token *oauth2.Token + refresh *tokenRefresh + tokenGeneration uint64 // increments whenever source is replaced status flowStatus flowID string pending *UserAction @@ -106,43 +112,87 @@ func NewManager(cfg Config, logger *slog.Logger) *Manager { // re-authorization is required). It is cheap to call repeatedly: the underlying // token source caches and only refreshes when the token has expired. func (m *Manager) AccessToken() string { - token, _ := m.accessToken() + token, _ := m.AccessTokenContext(context.Background()) return token } +// AccessTokenContext allows callers to stop waiting for a shared token refresh. +func (m *Manager) AccessTokenContext(ctx context.Context) (string, error) { + token, _, err := m.accessToken(ctx) + return token, err +} + // accessToken returns the token together with the generation of the source it // checked. Authenticate uses the generation to detect a source installed while // token validation was in progress, without repeating a potentially blocking // refresh request. -func (m *Manager) accessToken() (string, uint64) { - m.mu.Lock() - src := m.source - generation := m.tokenGeneration - m.mu.Unlock() - if src == nil { - return "", generation +func (m *Manager) accessToken(ctx context.Context) (string, uint64, error) { + for { + if err := ctx.Err(); err != nil { + return "", 0, err + } + m.mu.Lock() + generation := m.tokenGeneration + if m.source == nil { + m.mu.Unlock() + return "", generation, nil + } + if m.token.Valid() { + token := m.token.AccessToken + m.mu.Unlock() + return token, generation, nil + } + if m.refresh == nil { + m.refresh = &tokenRefresh{done: make(chan struct{})} + go m.refreshToken(m.source, generation, m.refresh) + } + refresh := m.refresh + m.mu.Unlock() + + select { + case <-ctx.Done(): + return "", 0, ctx.Err() + case <-refresh.done: + } + if err := ctx.Err(); err != nil { + return "", 0, err + } + m.mu.Lock() + current := m.tokenGeneration == generation + m.mu.Unlock() + if current { + return refresh.accessToken, generation, nil + } } - // Refresh (if needed) happens here, off the lock, because ReuseTokenSource may - // make a blocking network call and holding m.mu would serialize every tool call. +} + +// refreshToken runs the token source outside the manager lock. Its bounded +// exchange owns refresh-token rotation even if every waiting caller cancels. +func (m *Manager) refreshToken(src oauth2.TokenSource, generation uint64, refresh *tokenRefresh) { tok, err := src.Token() + m.mu.Lock() + defer m.mu.Unlock() + if m.tokenGeneration != generation { + return + } + m.refresh = nil + defer close(refresh.done) if err != nil { // A refresh failure (expired GitHub App refresh token, revoked grant, or a // network blip) leaves the session unauthorized and forces a re-login. // Surface it once, otherwise it only manifests as a surprise re-authorization // prompt. The oauth2 error carries the token endpoint's response, not the // access or refresh token. - m.mu.Lock() - if m.tokenGeneration == generation && !m.refreshErrLogged { + if !m.refreshErrLogged { m.refreshErrLogged = true m.logger.Warn("OAuth token refresh failed; re-authorization required", "error", err) } - m.mu.Unlock() - return "", generation + return } - if !tok.Valid() { - return "", generation + m.token = tok + if tok.Valid() { + refresh.accessToken = tok.AccessToken } - return tok.AccessToken, generation } // HasToken reports whether a valid token is currently available. @@ -150,6 +200,12 @@ func (m *Manager) HasToken() bool { return m.AccessToken() != "" } +// HasTokenContext checks for an active session while respecting caller cancellation. +func (m *Manager) HasTokenContext(ctx context.Context) (bool, error) { + token, err := m.AccessTokenContext(ctx) + return token != "", err +} + // Authenticate ensures the session is authorized. // // It returns (nil, nil) once a token is available, so the caller may proceed. @@ -163,7 +219,10 @@ func (m *Manager) Authenticate(ctx context.Context, prompter Prompter) (*Outcome var flowID string var done chan struct{} for { - token, checkedTokenGeneration := m.accessToken() + token, checkedTokenGeneration, err := m.accessToken(ctx) + if err != nil { + return nil, err + } if token != "" { return nil, nil } @@ -251,16 +310,26 @@ func (m *Manager) AwaitToken(ctx context.Context, flowID string) (*Outcome, erro } done := m.done m.mu.Unlock() - if m.AccessToken() != "" { + token, err := m.AccessTokenContext(ctx) + if err != nil { + return nil, err + } + m.mu.Lock() + current := m.flowID == flowID + m.mu.Unlock() + if !current { + return nil, ErrStaleAuthorizationFlow + } + if token != "" { return nil, nil } if done == nil { // No flow is in flight; report whatever terminal state it left behind. - return m.outcomeAfterFlow(flowID) + return m.outcomeAfterFlow(ctx, flowID) } select { case <-done: - return m.outcomeAfterFlow(flowID) + return m.outcomeAfterFlow(ctx, flowID) case <-ctx.Done(): return nil, ctx.Err() } @@ -367,10 +436,15 @@ func (m *Manager) complete(flowID string, tok *oauth2.Token, err error) { m.lastErr = nil // Config.TokenSource returns a ReuseTokenSource that refreshes expired // tokens using the refresh token — this is what makes GitHub App - // (expiring) tokens work transparently. The refresh uses a bounded HTTP - // client so a stalled token endpoint can't block a tool call forever. + // (expiring) tokens work transparently. Keep the shared exchange bounded + // independently of any individual request's context. refreshCtx := context.WithValue(context.Background(), oauth2.HTTPClient, &http.Client{Timeout: tokenRefreshTimeout}) + if m.refresh != nil { + close(m.refresh.done) + m.refresh = nil + } m.source = m.refreshConfig.TokenSource(refreshCtx, tok) + m.token = tok m.tokenGeneration++ m.refreshErrLogged = false m.logger.Info("github authorization complete") @@ -387,7 +461,7 @@ func (m *Manager) complete(flowID string, tok *oauth2.Token, err error) { func (m *Manager) joinWait(ctx context.Context, done chan struct{}, flowID string) (*Outcome, error) { select { case <-done: - return m.outcomeAfterFlow(flowID) + return m.outcomeAfterFlow(ctx, flowID) case <-ctx.Done(): return nil, ctx.Err() } @@ -396,23 +470,30 @@ func (m *Manager) joinWait(ctx context.Context, done chan struct{}, flowID strin // outcomeAfterFlow reports the result once the flow's done channel has closed // (or when there is no flow in flight): a token to proceed (nil, nil), a pending // user action to surface, or the flow's error. -func (m *Manager) outcomeAfterFlow(flowID string) (*Outcome, error) { +func (m *Manager) outcomeAfterFlow(ctx context.Context, flowID string) (*Outcome, error) { m.mu.Lock() if flowID == "" || flowID != m.flowID { m.mu.Unlock() return nil, ErrStaleAuthorizationFlow } - pending := m.pending - err := m.lastErr m.mu.Unlock() - if m.AccessToken() != "" { + token, err := m.AccessTokenContext(ctx) + if err != nil { + return nil, err + } + m.mu.Lock() + defer m.mu.Unlock() + if flowID != m.flowID { + return nil, ErrStaleAuthorizationFlow + } + if token != "" { return nil, nil } - if pending != nil { - return &Outcome{UserAction: pending, FlowID: flowID}, nil + if m.pending != nil { + return &Outcome{UserAction: m.pending, FlowID: flowID}, nil } - if err != nil { - return nil, err + if m.lastErr != nil { + return nil, m.lastErr } return nil, errors.New("authorization did not complete") } diff --git a/internal/oauth/refresh_cancellation_test.go b/internal/oauth/refresh_cancellation_test.go new file mode 100644 index 0000000000..c165ceeb86 --- /dev/null +++ b/internal/oauth/refresh_cancellation_test.go @@ -0,0 +1,115 @@ +package oauth + +import ( + "context" + "sync/atomic" + "testing" + "testing/synctest" + "time" + + "github.com/stretchr/testify/assert" + "github.com/stretchr/testify/require" + "golang.org/x/oauth2" +) + +type gatedRefreshSource struct { + started chan struct{} + release chan struct{} + calls atomic.Int32 +} + +func (s *gatedRefreshSource) Token() (*oauth2.Token, error) { + if s.calls.Add(1) == 1 { + close(s.started) + } + <-s.release + return &oauth2.Token{AccessToken: "refreshed-token", Expiry: time.Now().Add(time.Hour)}, nil +} + +func TestCanceledAuthorizationDoesNotWaitForTokenRefresh(t *testing.T) { + const flowID = "authorized-flow" + for _, tc := range []struct { + name string + wait func(context.Context, *Manager) (*Outcome, error) + }{ + {name: "authenticate", wait: func(ctx context.Context, m *Manager) (*Outcome, error) { return m.Authenticate(ctx, nil) }}, + {name: "await token", wait: func(ctx context.Context, m *Manager) (*Outcome, error) { return m.AwaitToken(ctx, flowID) }}, + } { + t.Run(tc.name, func(t *testing.T) { + synctest.Test(t, func(t *testing.T) { + source := &gatedRefreshSource{started: make(chan struct{}), release: make(chan struct{})} + m := NewManager(Config{}, testLogger()) + m.flowID, m.source = flowID, source + ctx, cancel := context.WithCancel(t.Context()) + defer cancel() + canceled := make(chan error, 1) + go func() { + _, err := tc.wait(ctx, m) + canceled <- err + }() + <-source.started + active := make(chan string, 1) + go func() { active <- m.AccessToken() }() + synctest.Wait() + + cancel() + synctest.Wait() + select { + case err := <-canceled: + assert.ErrorIs(t, err, context.Canceled) + default: + t.Error("canceled authorization still waits for the token source") + } + assert.Zero(t, len(active), "the active caller still needs the token") + assert.EqualValues(t, 1, source.calls.Load(), "both callers share one refresh") + + close(source.release) + assert.Equal(t, "refreshed-token", <-active) + }) + }) + } +} + +func TestAlreadyCanceledAuthorizationDoesNotStartTokenRefresh(t *testing.T) { + source := &gatedRefreshSource{started: make(chan struct{}), release: make(chan struct{})} + close(source.release) + m := NewManager(Config{}, testLogger()) + m.source = source + ctx, cancel := context.WithCancel(t.Context()) + cancel() + + _, err := m.Authenticate(ctx, nil) + require.ErrorIs(t, err, context.Canceled) + assert.Zero(t, source.calls.Load()) +} + +func TestNewAuthorizationSupersedesPendingTokenRefresh(t *testing.T) { + synctest.Test(t, func(t *testing.T) { + const flowID = "new-authorization" + const installedToken = "installed-token" + source := &gatedRefreshSource{started: make(chan struct{}), release: make(chan struct{})} + m := NewManager(Config{}, testLogger()) + m.flowID, m.source = flowID, source + waiters := make(chan string, 2) + go func() { waiters <- m.AccessToken() }() + <-source.started + go func() { waiters <- m.AccessToken() }() + synctest.Wait() + assert.EqualValues(t, 1, source.calls.Load(), "both callers share the old refresh") + + m.complete(flowID, &oauth2.Token{AccessToken: installedToken, Expiry: time.Now().Add(time.Hour)}, nil) + synctest.Wait() + for range 2 { + select { + case got := <-waiters: + assert.Equal(t, installedToken, got) + default: + t.Error("installed token did not wake a caller waiting on the old refresh") + } + } + + close(source.release) + synctest.Wait() + assert.Equal(t, installedToken, m.AccessToken(), "the old refresh cannot replace the installed token") + }) +}