chore(deps): update dependencies, migrate to connectrpc.com/connect v2 (#39854)

Co-authored-by: silverwind <me@silverwind.io>

tests/integration/actions_job_test.go

@@ -27,7 +27,6 @@ import (
 	"gitea.dev/modules/timeutil"
 	actions_service "gitea.dev/services/actions"
 
-	"connectrpc.com/connect"
 	"github.com/stretchr/testify/assert"
 	"github.com/stretchr/testify/require"
 )
@@ -643,33 +642,33 @@ jobs:
 		err = actions_service.CleanupEphemeralRunners(t.Context())
 		assert.NoError(t, err)
 
-		resp, err := runner.client.runnerServiceClient.FetchTask(t.Context(), connect.NewRequest(&runnerv1.FetchTaskRequest{
+		resp, err := runner.client.runnerServiceClient.FetchTask(t.Context(), &runnerv1.FetchTaskRequest{
 			TasksVersion: 0,
-		}))
+		})
 		assert.NoError(t, err)
-		assert.Nil(t, resp.Msg.Task)
+		assert.Nil(t, resp.Task)
 
 		// verify CleanupEphemeralRunners does not remove this runner
 		err = actions_service.CleanupEphemeralRunners(t.Context())
 		assert.NoError(t, err)
 
-		_, err = runner.client.runnerServiceClient.UpdateTask(t.Context(), connect.NewRequest(&runnerv1.UpdateTaskRequest{
+		_, err = runner.client.runnerServiceClient.UpdateTask(t.Context(), &runnerv1.UpdateTaskRequest{
 			State: &runnerv1.TaskState{
 				Id:     actionTask.ID,
 				Result: runnerv1.Result_RESULT_SUCCESS,
 			},
-		}))
+		})
 		assert.NoError(t, err)
 
-		resp, err = runner.client.runnerServiceClient.FetchTask(t.Context(), connect.NewRequest(&runnerv1.FetchTaskRequest{
+		resp, err = runner.client.runnerServiceClient.FetchTask(t.Context(), &runnerv1.FetchTaskRequest{
 			TasksVersion: 0,
-		}))
+		})
 		assert.Error(t, err)
 		assert.Nil(t, resp)
 
-		resp, err = runner.client.runnerServiceClient.FetchTask(t.Context(), connect.NewRequest(&runnerv1.FetchTaskRequest{
+		resp, err = runner.client.runnerServiceClient.FetchTask(t.Context(), &runnerv1.FetchTaskRequest{
 			TasksVersion: 0,
-		}))
+		})
 		assert.Error(t, err)
 		assert.Nil(t, resp)
 

tests/integration/actions_log_finalize_test.go

@@ -19,7 +19,6 @@ import (
 	actions_module "gitea.dev/modules/actions"
 	"gitea.dev/modules/storage"
 
-	"connectrpc.com/connect"
 	"github.com/stretchr/testify/assert"
 	"github.com/stretchr/testify/require"
 )
@@ -56,14 +55,14 @@ jobs:
 
 		task := runner.fetchTask(t)
 
-		resp, err := runner.client.runnerServiceClient.UpdateLog(t.Context(), connect.NewRequest(&runnerv1.UpdateLogRequest{
+		resp, err := runner.client.runnerServiceClient.UpdateLog(t.Context(), &runnerv1.UpdateLogRequest{
 			TaskId: task.Id,
 			Index:  0,
 			Rows:   nil,
 			NoMore: true,
-		}))
+		})
 		require.NoError(t, err)
-		assert.EqualValues(t, 0, resp.Msg.AckIndex)
+		assert.EqualValues(t, 0, resp.AckIndex)
 
 		freshTask := unittest.AssertExistsAndLoadBean(t, &actions_model.ActionTask{ID: task.Id})
 		require.True(t, freshTask.LogInStorage, "log_in_storage must flip after empty NoMore=true")
@@ -78,13 +77,13 @@ jobs:
 		// A sealed log must ack the re-send and still reject new appended rows.
 		t.Run("re-sent finalize is idempotent", func(t *testing.T) {
 			finalize := &runnerv1.UpdateLogRequest{TaskId: task.Id, Index: 0, Rows: nil, NoMore: true}
-			resp, err := runner.client.runnerServiceClient.UpdateLog(t.Context(), connect.NewRequest(finalize))
+			resp, err := runner.client.runnerServiceClient.UpdateLog(t.Context(), finalize)
 			require.NoError(t, err)
-			assert.EqualValues(t, 0, resp.Msg.AckIndex)
+			assert.EqualValues(t, 0, resp.AckIndex)
 
-			_, err = runner.client.runnerServiceClient.UpdateLog(t.Context(), connect.NewRequest(&runnerv1.UpdateLogRequest{
+			_, err = runner.client.runnerServiceClient.UpdateLog(t.Context(), &runnerv1.UpdateLogRequest{
 				TaskId: task.Id, Index: 0, Rows: []*runnerv1.LogRow{{Content: "late"}}, NoMore: true,
-			}))
+			})
 			require.Error(t, err, "appending rows past the seal must be rejected")
 		})
 	})

tests/integration/actions_runner_test.go

@@ -17,7 +17,8 @@ import (
 	auth_model "gitea.dev/models/auth"
 	"gitea.dev/modules/setting"
 
-	"connectrpc.com/connect"
+	"connectrpc.com/connect/v2"
+	"connectrpc.com/connect/v2/connecthttp"
 	"github.com/stretchr/testify/assert"
 	"github.com/stretchr/testify/require"
 	"google.golang.org/protobuf/types/known/timestamppb"
@@ -40,45 +41,44 @@ func newMockRunner() *mockRunner {
 func newMockRunnerClient(uuid, token string) *mockRunnerClient {
 	baseURL := setting.AppURL + "api/actions"
 
-	opt := connect.WithInterceptors(connect.UnaryInterceptorFunc(func(next connect.UnaryFunc) connect.UnaryFunc {
-		return func(ctx context.Context, req connect.AnyRequest) (connect.AnyResponse, error) {
+	client := connect.NewClient(connecthttp.NewTransport(http.DefaultClient, baseURL), func(next connect.ClientFunc) connect.ClientFunc {
+		return func(ctx context.Context, spec connect.Spec) (connect.ClientStream, error) {
+			info, _ := connect.CallInfoForClientContext(ctx)
 			if uuid != "" {
-				req.Header().Set("x-runner-uuid", uuid)
+				info.RequestHeader().Set("x-runner-uuid", uuid)
 			}
 			if token != "" {
-				req.Header().Set("x-runner-token", token)
+				info.RequestHeader().Set("x-runner-token", token)
 			}
-			return next(ctx, req)
+			return next(ctx, spec)
 		}
-	}))
+	})
 
-	client := &mockRunnerClient{
-		pingServiceClient:   pingv1connect.NewPingServiceClient(http.DefaultClient, baseURL, opt),
-		runnerServiceClient: runnerv1connect.NewRunnerServiceClient(http.DefaultClient, baseURL, opt),
+	return &mockRunnerClient{
+		pingServiceClient:   pingv1connect.NewPingServiceClient(client),
+		runnerServiceClient: runnerv1connect.NewRunnerServiceClient(client),
 	}
-
-	return client
 }
 
 func (r *mockRunner) doPing(t *testing.T) {
-	resp, err := r.client.pingServiceClient.Ping(t.Context(), connect.NewRequest(&pingv1.PingRequest{
+	resp, err := r.client.pingServiceClient.Ping(t.Context(), &pingv1.PingRequest{
 		Data: "mock-runner",
-	}))
+	})
 	assert.NoError(t, err)
-	assert.Equal(t, "Hello, mock-runner!", resp.Msg.Data)
+	assert.Equal(t, "Hello, mock-runner!", resp.Data)
 }
 
 func (r *mockRunner) doRegister(t *testing.T, name, token string, labels []string, ephemeral bool) {
 	r.doPing(t)
-	resp, err := r.client.runnerServiceClient.Register(t.Context(), connect.NewRequest(&runnerv1.RegisterRequest{
+	resp, err := r.client.runnerServiceClient.Register(t.Context(), &runnerv1.RegisterRequest{
 		Name:      name,
 		Token:     token,
 		Version:   "mock-runner-version",
 		Labels:    labels,
 		Ephemeral: ephemeral,
-	}))
+	})
 	assert.NoError(t, err)
-	r.client = newMockRunnerClient(resp.Msg.Runner.Uuid, resp.Msg.Runner.Token)
+	r.client = newMockRunnerClient(resp.Runner.Uuid, resp.Runner.Token)
 }
 
 func (r *mockRunner) registerAsRepoRunner(t *testing.T, ownerName, repoName, runnerName string, labels []string, ephemeral bool) {
@@ -127,11 +127,11 @@ func (r *mockRunner) tryFetchTask(t *testing.T, timeout ...time.Duration) *runne
 // and returns the task (if any) and the TasksVersion from the response.
 // Used to verify the production path where the runner sends the current version.
 func (r *mockRunner) fetchTaskOnce(t *testing.T, tasksVersion int64) (*runnerv1.Task, int64) {
-	resp, err := r.client.runnerServiceClient.FetchTask(t.Context(), connect.NewRequest(&runnerv1.FetchTaskRequest{
+	resp, err := r.client.runnerServiceClient.FetchTask(t.Context(), &runnerv1.FetchTaskRequest{
 		TasksVersion: tasksVersion,
-	}))
+	})
 	require.NoError(t, err)
-	return resp.Msg.Task, resp.Msg.TasksVersion
+	return resp.Task, resp.TasksVersion
 }
 
 type mockTaskOutcome struct {
@@ -142,35 +142,35 @@ type mockTaskOutcome struct {
 
 func (r *mockRunner) execTask(t *testing.T, task *runnerv1.Task, outcome *mockTaskOutcome) {
 	for idx, lr := range outcome.logRows {
-		resp, err := r.client.runnerServiceClient.UpdateLog(t.Context(), connect.NewRequest(&runnerv1.UpdateLogRequest{
+		resp, err := r.client.runnerServiceClient.UpdateLog(t.Context(), &runnerv1.UpdateLogRequest{
 			TaskId: task.Id,
 			Index:  int64(idx),
 			Rows:   []*runnerv1.LogRow{lr},
 			NoMore: idx == len(outcome.logRows)-1,
-		}))
+		})
 		assert.NoError(t, err)
-		assert.EqualValues(t, idx+1, resp.Msg.AckIndex)
+		assert.EqualValues(t, idx+1, resp.AckIndex)
 	}
 	sentOutputKeys := make([]string, 0, len(outcome.outputs))
 	for outputKey, outputValue := range outcome.outputs {
-		resp, err := r.client.runnerServiceClient.UpdateTask(t.Context(), connect.NewRequest(&runnerv1.UpdateTaskRequest{
+		resp, err := r.client.runnerServiceClient.UpdateTask(t.Context(), &runnerv1.UpdateTaskRequest{
 			State: &runnerv1.TaskState{
 				Id:     task.Id,
 				Result: runnerv1.Result_RESULT_UNSPECIFIED,
 			},
 			Outputs: map[string]string{outputKey: outputValue},
-		}))
+		})
 		assert.NoError(t, err)
 		sentOutputKeys = append(sentOutputKeys, outputKey)
-		assert.ElementsMatch(t, sentOutputKeys, resp.Msg.SentOutputs)
+		assert.ElementsMatch(t, sentOutputKeys, resp.SentOutputs)
 	}
-	resp, err := r.client.runnerServiceClient.UpdateTask(t.Context(), connect.NewRequest(&runnerv1.UpdateTaskRequest{
+	resp, err := r.client.runnerServiceClient.UpdateTask(t.Context(), &runnerv1.UpdateTaskRequest{
 		State: &runnerv1.TaskState{
 			Id:        task.Id,
 			Result:    outcome.result,
 			StoppedAt: timestamppb.Now(),
 		},
-	}))
+	})
 	assert.NoError(t, err)
-	assert.Equal(t, outcome.result, resp.Msg.State.Result)
+	assert.Equal(t, outcome.result, resp.State.Result)
 }