fix issues from test

Author: noel2004

coordinator/internal/controller/proxy/auth.go

@@ -128,8 +128,10 @@ func (a *AuthController) IdentityHandler(c *gin.Context) interface{} {
 	if loginParam.PublicKey != "" {
 
 		c.Set(LoginParamCache, loginParam)
+		fmt.Println("identify", loginParam)
 		return loginParam.PublicKey
 	}
 
+	fmt.Println("identify empty")
 	return nil
 }

coordinator/internal/controller/proxy/get_task.go

@@ -54,6 +54,7 @@ func (ptc *GetTaskController) incGetTaskAccessCounter(ctx *gin.Context) error {
 
 // GetTasks get assigned chunk/batch task
 func (ptc *GetTaskController) GetTasks(ctx *gin.Context) {
+	fmt.Println("start get task")
 	var getTaskParameter coordinatorType.GetTaskParameter
 	if err := ctx.ShouldBind(&getTaskParameter); err != nil {
 		nerr := fmt.Errorf("prover task parameter invalid, err:%w", err)
@@ -70,6 +71,7 @@ func (ptc *GetTaskController) GetTasks(ctx *gin.Context) {
 
 	getTask := func(upStream string, cli Client) (tryNext bool) {
 		resp, err := session.GetTask(ctx, &getTaskParameter, cli, upStream)
+		fmt.Println("upstream get task", resp)
 		if err != nil {
 			types.RenderFailure(ctx, types.ErrCoordinatorGetTaskFailure, err)
 			return

coordinator/internal/controller/proxy/prover_session.go

@@ -118,7 +118,7 @@ func (c *proverSession) maintainLogin(ctx context.Context, cliMgr Client, up str
 		return nil, fmt.Errorf("upstream fail: %d (%s)", resp.ErrCode, resp.ErrMsg)
 	}
 
-	var loginResult types.LoginSchema
+	var loginResult loginSchema
 	if err := resp.DecodeData(&loginResult); err != nil {
 		return nil, err
 	}
@@ -127,12 +127,14 @@ func (c *proverSession) maintainLogin(ctx context.Context, cliMgr Client, up str
 	defer c.Unlock()
 
 	c.proverToken[up] = loginToken{
-		LoginSchema: &loginResult,
-		phase:       phase,
+		LoginSchema: &types.LoginSchema{
+			Token: loginResult.Token,
+		},
+		phase: phase,
 	}
 	c.completionCtx = nil
 
-	return &loginResult, nil
+	return c.proverToken[up].LoginSchema, nil
 }
 
 const expireTolerant = 10 * time.Minute

coordinator/internal/logic/auth/login.go

@@ -93,16 +93,19 @@ func (l *LoginLogic) CompatiblityCheck(login *types.LoginParameter) error {
 		vks[vk] = struct{}{}
 	}
 
-	for _, vk := range login.Message.VKs {
-		if _, ok := vks[vk]; !ok {
-			log.Error("vk inconsistency", "prover vk", vk, "prover name", login.Message.ProverName,
-				"prover_version", login.Message.ProverVersion, "message", login.Message)
-			if !version.CheckScrollProverVersion(login.Message.ProverVersion) {
-				return fmt.Errorf("incompatible prover version. please upgrade your prover, expect version: %s, actual version: %s",
-					version.Version, login.Message.ProverVersion)
+	// new coordinator / proxy do not check vks while login, code only for backward compatibility
+	if len(vks) != 0 {
+		for _, vk := range login.Message.VKs {
+			if _, ok := vks[vk]; !ok {
+				log.Error("vk inconsistency", "prover vk", vk, "prover name", login.Message.ProverName,
+					"prover_version", login.Message.ProverVersion, "message", login.Message)
+				if !version.CheckScrollProverVersion(login.Message.ProverVersion) {
+					return fmt.Errorf("incompatible prover version. please upgrade your prover, expect version: %s, actual version: %s",
+						version.Version, login.Message.ProverVersion)
+				}
+				// if the prover reports a same prover version
+				return errors.New("incompatible vk. please check your params files or config files")
 			}
-			// if the prover reports a same prover version
-			return errors.New("incompatible vk. please check your params files or config files")
 		}
 	}
 

coordinator/internal/middleware/login_jwt.go

@@ -51,8 +51,8 @@ func LoginMiddleware(auth *config.Auth) *jwt.GinJWTMiddleware {
 // ProxyLoginMiddleware jwt auth middleware for proxy login
 func ProxyLoginMiddleware(auth *config.Auth) *jwt.GinJWTMiddleware {
 	jwtMiddleware, err := jwt.New(&jwt.GinJWTMiddleware{
-		PayloadFunc:     api.Auth.PayloadFunc,
-		IdentityHandler: api.Auth.IdentityHandler,
+		PayloadFunc:     proxy.Auth.PayloadFunc,
+		IdentityHandler: proxy.Auth.IdentityHandler,
 		IdentityKey:     types.PublicKey,
 		Key:             []byte(auth.Secret),
 		Timeout:         time.Second * time.Duration(auth.LoginExpireDurationSec),

coordinator/test/proxy_test.go

@@ -2,21 +2,30 @@ package test
 
 import (
 	"context"
+	"errors"
 	"fmt"
+	"net/http"
 	"testing"
 	"time"
 
+	"github.com/gin-gonic/gin"
+	"github.com/scroll-tech/da-codec/encoding"
 	"github.com/stretchr/testify/assert"
 
+	"scroll-tech/common/types/message"
+	"scroll-tech/common/version"
+
 	"scroll-tech/coordinator/internal/config"
 	"scroll-tech/coordinator/internal/controller/proxy"
+	"scroll-tech/coordinator/internal/route"
 )
 
 func testProxyClientCfg() *config.ProxyClient {
 
 	return &config.ProxyClient{
-		Secret:    "test-secret-key",
-		ProxyName: "test-proxy",
+		Secret:       "test-secret-key",
+		ProxyName:    "test-proxy",
+		ProxyVersion: version.Version,
 	}
 }
 
@@ -57,13 +66,107 @@ func testProxyClient(t *testing.T) {
 	// Client should not be nil if login succeeds
 	// Note: This might be nil if the coordinator is not properly set up for proxy authentication
 	// but the test validates that the Client method completes without panic
-	t.Logf("Client toke: %v", client)
+	assert.NotNil(t, client)
+	assert.NotEmpty(t, client.Token())
+	t.Logf("Client token: %s (%v)", client.Token(), client)
+}
+
+var (
+	proxyConf *config.ProxyConfig
+)
+
+func setupProxy(t *testing.T, proxyURL string, coordinatorURL []string) *http.Server {
+	var err error
+	assert.NoError(t, err)
+
+	coordinators := make(map[string]*config.UpStream)
+	for i, n := range coordinatorURL {
+		coordinators[fmt.Sprintf("coordinator_%d", i)] = testProxyUpStreamCfg(n)
+	}
+
+	tokenTimeout = 60
+	proxyConf = &config.ProxyConfig{
+		ProxyName: "test_proxy",
+		ProxyManager: &config.ProxyManager{
+			Verifier: &config.VerifierConfig{
+				MinProverVersion: "v4.4.89",
+				Verifiers: []config.AssetConfig{{
+					AssetsPath: "",
+					ForkName:   "euclidV2",
+				}},
+			},
+			Client: testProxyClientCfg(),
+			Auth: &config.Auth{
+				Secret:                     "proxy",
+				ChallengeExpireDurationSec: tokenTimeout,
+				LoginExpireDurationSec:     tokenTimeout,
+			},
+		},
+		Coordinators: coordinators,
+	}
+
+	router := gin.New()
+	proxy.InitController(proxyConf, nil)
+	route.ProxyRoute(router, proxyConf, nil)
+	srv := &http.Server{
+		Addr:    proxyURL,
+		Handler: router,
+	}
+	go func() {
+		runErr := srv.ListenAndServe()
+		if runErr != nil && !errors.Is(runErr, http.ErrServerClosed) {
+			assert.NoError(t, runErr)
+		}
+	}()
+	time.Sleep(time.Second * 2)
+
+	return srv
+}
+
+func testProxyHandshake(t *testing.T) {
+	// Setup proxy http server.
+	proxyURL := randomURL()
+	proxyHttpHandler := setupProxy(t, proxyURL, []string{})
+	defer func() {
+		assert.NoError(t, proxyHttpHandler.Shutdown(context.Background()))
+	}()
+
+	chunkProver := newMockProver(t, "prover_chunk_test", proxyURL, message.ProofTypeChunk, version.Version)
+	assert.True(t, chunkProver.healthCheckSuccess(t))
+}
+
+func testProxyGetTask(t *testing.T) {
+	// Setup coordinator and http server.
+	coordinatorURL := randomURL()
+	collector, httpHandler := setupCoordinator(t, 3, coordinatorURL)
+	defer func() {
+		collector.Stop()
+		assert.NoError(t, httpHandler.Shutdown(context.Background()))
+	}()
+
+	proxyURL := randomURL()
+	proxyHttpHandler := setupProxy(t, proxyURL, []string{coordinatorURL})
+	defer func() {
+		assert.NoError(t, proxyHttpHandler.Shutdown(context.Background()))
+	}()
+
+	err := l2BlockOrm.InsertL2Blocks(context.Background(), []*encoding.Block{block1, block2})
+	assert.NoError(t, err)
+	dbChunk, err := chunkOrm.InsertChunk(context.Background(), chunk)
+	assert.NoError(t, err)
+	err = l2BlockOrm.UpdateChunkHashInRange(context.Background(), 0, 100, dbChunk.Hash)
+	assert.NoError(t, err)
 
+	chunkProver := newMockProver(t, "prover_chunk_test", proxyURL, message.ProofTypeChunk, version.Version)
+	code, _ := chunkProver.tryGetProverTask(t, message.ProofTypeChunk)
+	assert.Empty(t, code)
 }
 
 func TestProxyClient(t *testing.T) {
 
 	// Set up the test environment.
 	setEnv(t)
-	t.Run("TestProxyHandshake", testProxyClient)
+	t.Run("TestProxyClient", testProxyClient)
+	t.Run("TestProxyHandshake", testProxyHandshake)
+	t.Run("TestProxyGetTask", testProxyGetTask)
 }