mirror of
https://github.com/go-gitea/gitea.git
synced 2026-10-12 06:02:15 +09:00
silverwindandGitHub
08c123299a
Reverts the backport https://github.com/go-gitea/gitea/pull/39585 before v28.0.1 ships. The change stays on main for v29. gitea-runner v4.1.0 recognizes a rejected registration only by the old `Unknown`-coded `rpc error: code = Unauthenticated desc = unregistered runner` error. With the new `Unauthenticated` reply, an ephemeral runner keeps its spent registration file and fails on every restart instead of registering again. The runner fix is in https://gitea.com/gitea/runner/pulls/1287, so a patch release shouldn't change runner behavior before that fix has shipped. Written by Claude Code.
94 lines
2.8 KiB
Go
94 lines
2.8 KiB
Go
// Copyright 2022 The Gitea Authors. All rights reserved.
|
|
// SPDX-License-Identifier: MIT
|
|
|
|
package runner
|
|
|
|
import (
|
|
"context"
|
|
"errors"
|
|
"strings"
|
|
"time"
|
|
|
|
"gitea.dev/actionslib/pkg/protocol"
|
|
actions_model "gitea.dev/models/actions"
|
|
auth_model "gitea.dev/models/auth"
|
|
"gitea.dev/modules/log"
|
|
"gitea.dev/modules/timeutil"
|
|
"gitea.dev/modules/util"
|
|
|
|
"connectrpc.com/connect"
|
|
"google.golang.org/grpc/codes"
|
|
"google.golang.org/grpc/status"
|
|
)
|
|
|
|
const (
|
|
uuidHeaderKey = protocol.UUIDHeader
|
|
tokenHeaderKey = protocol.TokenHeader
|
|
)
|
|
|
|
var withRunner = connect.WithInterceptors(connect.UnaryInterceptorFunc(func(unaryFunc connect.UnaryFunc) connect.UnaryFunc {
|
|
return func(ctx context.Context, request connect.AnyRequest) (connect.AnyResponse, error) {
|
|
methodName := getMethodName(request)
|
|
if methodName == "Register" {
|
|
return unaryFunc(ctx, request)
|
|
}
|
|
uuid := request.Header().Get(uuidHeaderKey)
|
|
token := request.Header().Get(tokenHeaderKey)
|
|
|
|
runner, err := actions_model.GetRunnerByUUID(ctx, uuid)
|
|
if err != nil {
|
|
if errors.Is(err, util.ErrNotExist) {
|
|
return nil, status.Error(codes.Unauthenticated, "unregistered runner")
|
|
}
|
|
return nil, status.Error(codes.Internal, err.Error())
|
|
}
|
|
if !util.CryptoConstTimeEqual(runner.TokenHash, auth_model.HashToken(token, runner.TokenSalt)) {
|
|
return nil, status.Error(codes.Unauthenticated, "unregistered runner")
|
|
}
|
|
|
|
now := time.Now()
|
|
cols := make([]string, 0, 2)
|
|
// Debounce last_active too: while a runner streams logs, UpdateLog fires
|
|
// many times per second and writing on each is a major source of DB load.
|
|
// Persist only when stale enough to affect the active/idle status.
|
|
if (methodName == "UpdateTask" || methodName == "UpdateLog") &&
|
|
actions_model.ShouldPersistLastActive(runner.LastActive, now) {
|
|
runner.LastActive = timeutil.TimeStamp(now.Unix())
|
|
cols = append(cols, "last_active")
|
|
}
|
|
// Debounce last_online: writing on every poll is a major source of DB load
|
|
// with many runners. Persist only when stale enough to affect offline status.
|
|
if actions_model.ShouldPersistLastOnline(runner.LastOnline, now) {
|
|
runner.LastOnline = timeutil.TimeStamp(now.Unix())
|
|
cols = append(cols, "last_online")
|
|
}
|
|
if len(cols) > 0 {
|
|
if err := actions_model.UpdateRunner(ctx, runner, cols...); err != nil {
|
|
log.Error("can't update runner status: %v", err)
|
|
}
|
|
}
|
|
|
|
ctx = context.WithValue(ctx, runnerCtxKey{}, runner)
|
|
return unaryFunc(ctx, request)
|
|
}
|
|
}))
|
|
|
|
func getMethodName(req connect.AnyRequest) string {
|
|
splits := strings.Split(req.Spec().Procedure, "/")
|
|
if len(splits) > 0 {
|
|
return splits[len(splits)-1]
|
|
}
|
|
return ""
|
|
}
|
|
|
|
type runnerCtxKey struct{}
|
|
|
|
func GetRunner(ctx context.Context) *actions_model.ActionRunner {
|
|
if v := ctx.Value(runnerCtxKey{}); v != nil {
|
|
if r, ok := v.(*actions_model.ActionRunner); ok {
|
|
return r
|
|
}
|
|
}
|
|
return nil
|
|
}
|