fix: unable to sync directories to work nodes

core/apps/server.go

@@ -1,149 +0,0 @@
-package apps
-
-import (
-	"fmt"
-	"github.com/apex/log"
-	"github.com/crawlab-team/crawlab/core/config"
-	"github.com/crawlab-team/crawlab/core/controllers"
-	"github.com/crawlab-team/crawlab/core/interfaces"
-	"github.com/crawlab-team/crawlab/core/node/service"
-	"github.com/crawlab-team/crawlab/core/utils"
-	"github.com/spf13/viper"
-	"net/http"
-	_ "net/http/pprof"
-)
-
-func init() {
-	injectModules()
-}
-
-type Server struct {
-	// settings
-	grpcAddress interfaces.Address
-
-	// dependencies
-	interfaces.WithConfigPath
-	nodeSvc interfaces.NodeService
-
-	// modules
-	api *Api
-	dck *Docker
-
-	// internals
-	quit chan int
-}
-
-func (app *Server) SetGrpcAddress(address interfaces.Address) {
-	app.grpcAddress = address
-}
-
-func (app *Server) GetApi() (api ApiApp) {
-	return app.api
-}
-
-func (app *Server) GetNodeService() (svc interfaces.NodeService) {
-	return app.nodeSvc
-}
-
-func (app *Server) Init() {
-	// log node info
-	app.logNodeInfo()
-
-	if utils.IsMaster() {
-
-		// initialize controllers
-		if err := controllers.InitControllers(); err != nil {
-			panic(err)
-		}
-	}
-
-	// pprof
-	app.initPprof()
-}
-
-func (app *Server) Start() {
-	if utils.IsMaster() {
-		// start docker app
-		if utils.IsDocker() {
-			go app.dck.Start()
-		}
-
-		// start api
-		go app.api.Start()
-	}
-
-	// start node service
-	go app.nodeSvc.Start()
-}
-
-func (app *Server) Wait() {
-	<-app.quit
-}
-
-func (app *Server) Stop() {
-	app.api.Stop()
-	app.quit <- 1
-}
-
-func (app *Server) logNodeInfo() {
-	log.Infof("current node type: %s", utils.GetNodeType())
-	if utils.IsDocker() {
-		log.Infof("running in docker container")
-	}
-}
-
-func (app *Server) initPprof() {
-	if viper.GetBool("pprof") {
-		go func() {
-			fmt.Println(http.ListenAndServe("0.0.0.0:6060", nil))
-		}()
-	}
-}
-
-func NewServer() (app NodeApp) {
-	// server
-	svr := &Server{
-		WithConfigPath: config.NewConfigPathService(),
-		quit:           make(chan int, 1),
-	}
-
-	// service options
-	var svcOpts []service.Option
-	if svr.grpcAddress != nil {
-		svcOpts = append(svcOpts, service.WithAddress(svr.grpcAddress))
-	}
-
-	// master modules
-	if utils.IsMaster() {
-		// api
-		svr.api = GetApi()
-
-		// docker
-		if utils.IsDocker() {
-			svr.dck = GetDocker(svr)
-		}
-	}
-
-	// node service
-	var err error
-	if utils.IsMaster() {
-		svr.nodeSvc, err = service.NewMasterService(svcOpts...)
-	} else {
-		svr.nodeSvc, err = service.NewWorkerService(svcOpts...)
-	}
-	if err != nil {
-		panic(err)
-	}
-
-	return svr
-}
-
-var server NodeApp
-
-func GetServer() NodeApp {
-	if server != nil {
-		return server
-	}
-	server = NewServer()
-	return server
-}

core/apps/server_test.go

@@ -1,29 +0,0 @@
-package apps
-
-import (
-	"fmt"
-	"github.com/imroc/req"
-	"github.com/spf13/viper"
-	"github.com/stretchr/testify/require"
-	"os"
-	"testing"
-	"time"
-)
-
-func init() {
-	_ = os.Setenv("CRAWLAB_DEMO", "false")
-}
-
-func TestServer_Start(t *testing.T) {
-	svr := GetServer()
-
-	// start
-	go Start(svr)
-	time.Sleep(1 * time.Second)
-
-	res, err := req.Get(fmt.Sprintf("http://localhost:%s/system-info", viper.GetString("server.port")))
-	require.Nil(t, err)
-	resStr, err := res.ToString()
-	require.Nil(t, err)
-	require.Contains(t, resStr, "success")
-}

core/apps/server_v2.go

@@ -104,9 +104,9 @@ func NewServerV2() (app NodeApp) {
 	// node service
 	var err error
 	if utils.IsMaster() {
-		svr.nodeSvc, err = service.NewMasterServiceV2()
+		svr.nodeSvc, err = service.GetMasterServiceV2()
 	} else {
-		svr.nodeSvc, err = service.NewWorkerServiceV2()
+		svr.nodeSvc, err = service.GetWorkerServiceV2()
 	}
 	if err != nil {
 		panic(err)

core/apps/utils.go

@@ -64,7 +64,6 @@ var injectors = []interface{}{
 	modelsclient.NewEnvironmentServiceDelegate,
 	grpcclient.NewClient,
 	grpcclient.NewPool,
-	grpcserver.GetServer,
 	grpcserver.NewModelDelegateServer,
 	grpcserver.NewModelBaseServiceServer,
 	grpcserver.NewNodeServer,
@@ -75,7 +74,7 @@ var injectors = []interface{}{
 	schedule.GetScheduleService,
 	admin.GetSpiderAdminService,
 	stats.GetStatsService,
-	nodeconfig.NewNodeConfigService,
+	nodeconfig.GetNodeConfigService,
 	taskstats.GetTaskStatsService,
 	color.NewService,
 	scheduler.GetTaskSchedulerService,

core/grpc/server/model_base_service_v2_server.go

@@ -34,6 +34,7 @@ var (
 		*new(models.ScheduleV2),
 		*new(models.SettingV2),
 		*new(models.SpiderV2),
+		*new(models.SpiderStatV2),
 		*new(models.TaskQueueItemV2),
 		*new(models.TaskStatV2),
 		*new(models.TaskV2),

core/grpc/server/node_server.go

@@ -193,10 +193,7 @@ func NewNodeServer() (res *NodeServer, err error) {
 	if err != nil {
 		return nil, err
 	}
-	svr.cfgSvc, err = nodeconfig.NewNodeConfigService()
-	if err != nil {
-		return nil, err
-	}
+	svr.cfgSvc = nodeconfig.GetNodeConfigService()
 
 	return svr, nil
 }

core/grpc/server/node_server_v2.go

@@ -2,7 +2,6 @@ package server
 
 import (
 	"context"
-	"encoding/json"
 	"github.com/apex/log"
 	"github.com/crawlab-team/crawlab/core/constants"
 	"github.com/crawlab-team/crawlab/core/entity"
@@ -16,6 +15,7 @@ import (
 	"go.mongodb.org/mongo-driver/bson"
 	"go.mongodb.org/mongo-driver/bson/primitive"
 	"go.mongodb.org/mongo-driver/mongo"
+	"sync"
 	"time"
 )
 
@@ -30,78 +30,61 @@ type NodeServerV2 struct {
 }
 
 // Register from handler/worker to master
-func (svr NodeServerV2) Register(ctx context.Context, req *grpc.Request) (res *grpc.Response, err error) {
+func (svr NodeServerV2) Register(ctx context.Context, req *grpc.NodeServiceRegisterRequest) (res *grpc.Response, err error) {
 	// unmarshall data
-	var node models.NodeV2
-	if req.Data != nil {
-		if err := json.Unmarshal(req.Data, &node); err != nil {
-			return HandleError(err)
-		}
-
-		if node.IsMaster {
-			// error: cannot register master node
-			return HandleError(errors.ErrorGrpcNotAllowed)
-		}
+	if req.IsMaster {
+		// error: cannot register master node
+		return HandleError(errors.ErrorGrpcNotAllowed)
 	}
 
 	// node key
-	var nodeKey string
-	if req.NodeKey != "" {
-		nodeKey = req.NodeKey
-	} else {
-		nodeKey = node.Key
-	}
-	if nodeKey == "" {
+	if req.Key == "" {
 		return HandleError(errors.ErrorModelMissingRequiredData)
 	}
 
 	// find in db
-	nodeDb, err := service.NewModelServiceV2[models.NodeV2]().GetOne(bson.M{"key": nodeKey}, nil)
+	var node *models.NodeV2
+	node, err = service.NewModelServiceV2[models.NodeV2]().GetOne(bson.M{"key": req.Key}, nil)
 	if err == nil {
-		if node.IsMaster {
-			// error: cannot register master node
-			return HandleError(errors.ErrorGrpcNotAllowed)
-		} else {
-			// register existing
-			nodeDb.Status = constants.NodeStatusRegistered
-			nodeDb.Active = true
-			err = service.NewModelServiceV2[models.NodeV2]().ReplaceById(nodeDb.Id, *nodeDb)
-			if err != nil {
-				return HandleError(err)
-			}
-			log.Infof("[NodeServerV2] updated worker[%s] in db. id: %s", nodeKey, nodeDb.Id.Hex())
-		}
-	} else if errors2.Is(err, mongo.ErrNoDocuments) {
-		// register new
-		node.Key = nodeKey
+		// register existing
 		node.Status = constants.NodeStatusRegistered
 		node.Active = true
 		node.ActiveAt = time.Now()
-		node.Enabled = true
-		if node.Name == "" {
-			node.Name = nodeKey
-		}
-		node.SetCreated(primitive.NilObjectID)
-		node.SetUpdated(primitive.NilObjectID)
-		node.Id, err = service.NewModelServiceV2[models.NodeV2]().InsertOne(node)
+		err = service.NewModelServiceV2[models.NodeV2]().ReplaceById(node.Id, *node)
 		if err != nil {
 			return HandleError(err)
 		}
-		log.Infof("[NodeServerV2] added worker[%s] in db. id: %s", nodeKey, node.Id.Hex())
+		log.Infof("[NodeServerV2] updated worker[%s] in db. id: %s", req.Key, node.Id.Hex())
+	} else if errors2.Is(err, mongo.ErrNoDocuments) {
+		// register new
+		node = &models.NodeV2{
+			Key:      req.Key,
+			Status:   constants.NodeStatusRegistered,
+			Active:   true,
+			ActiveAt: time.Now(),
+			Enabled:  true,
+		}
+		node.SetCreated(primitive.NilObjectID)
+		node.SetUpdated(primitive.NilObjectID)
+		node.Id, err = service.NewModelServiceV2[models.NodeV2]().InsertOne(*node)
+		if err != nil {
+			return HandleError(err)
+		}
+		log.Infof("[NodeServerV2] added worker[%s] in db. id: %s", req.Key, node.Id.Hex())
 	} else {
 		// error
 		return HandleError(err)
 	}
 
-	log.Infof("[NodeServerV2] master registered worker[%s]", req.GetNodeKey())
+	log.Infof("[NodeServerV2] master registered worker[%s]", req.Key)
 
 	return HandleSuccessWithData(node)
 }
 
 // SendHeartbeat from worker to master
-func (svr NodeServerV2) SendHeartbeat(ctx context.Context, req *grpc.Request) (res *grpc.Response, err error) {
+func (svr NodeServerV2) SendHeartbeat(ctx context.Context, req *grpc.NodeServiceSendHeartbeatRequest) (res *grpc.Response, err error) {
 	// find in db
-	node, err := service.NewModelServiceV2[models.NodeV2]().GetOne(bson.M{"key": req.NodeKey}, nil)
+	node, err := service.NewModelServiceV2[models.NodeV2]().GetOne(bson.M{"key": req.Key}, nil)
 	if err != nil {
 		if errors2.Is(err, mongo.ErrNoDocuments) {
 			return HandleError(errors.ErrorNodeNotExists)
@@ -126,11 +109,6 @@ func (svr NodeServerV2) SendHeartbeat(ctx context.Context, req *grpc.Request) (r
 	return HandleSuccessWithData(node)
 }
 
-// Ping from worker to master
-func (svr NodeServerV2) Ping(ctx context.Context, req *grpc.Request) (res *grpc.Response, err error) {
-	return HandleSuccess()
-}
-
 func (svr NodeServerV2) Subscribe(request *grpc.Request, stream grpc.NodeService_SubscribeServer) (err error) {
 	log.Infof("[NodeServerV2] master received subscribe request from node[%s]", request.NodeKey)
 
@@ -177,13 +155,22 @@ func (svr NodeServerV2) Unsubscribe(ctx context.Context, req *grpc.Request) (res
 	}, nil
 }
 
+var nodeSvrV2 *NodeServerV2
+var nodeSvrV2Once = new(sync.Once)
+
 func NewNodeServerV2() (res *NodeServerV2, err error) {
-	// node server
-	svr := &NodeServerV2{}
-	svr.cfgSvc, err = nodeconfig.NewNodeConfigService()
+	if nodeSvrV2 != nil {
+		return nodeSvrV2, nil
+	}
+	nodeSvrV2Once.Do(func() {
+		nodeSvrV2 = &NodeServerV2{}
+		nodeSvrV2.cfgSvc = nodeconfig.GetNodeConfigService()
+		if err != nil {
+			log.Errorf("[NodeServerV2] error: %s", err.Error())
+		}
+	})
 	if err != nil {
 		return nil, err
 	}
-
-	return svr, nil
+	return nodeSvrV2, nil
 }

core/grpc/server/server.go

@@ -1,265 +0,0 @@
-package server
-
-import (
-	"encoding/json"
-	"fmt"
-	"github.com/apex/log"
-	config2 "github.com/crawlab-team/crawlab/core/config"
-	"github.com/crawlab-team/crawlab/core/constants"
-	"github.com/crawlab-team/crawlab/core/container"
-	"github.com/crawlab-team/crawlab/core/entity"
-	"github.com/crawlab-team/crawlab/core/errors"
-	"github.com/crawlab-team/crawlab/core/grpc/middlewares"
-	"github.com/crawlab-team/crawlab/core/interfaces"
-	grpc2 "github.com/crawlab-team/crawlab/grpc"
-	"github.com/crawlab-team/crawlab/trace"
-	"github.com/grpc-ecosystem/go-grpc-middleware"
-	grpc_auth "github.com/grpc-ecosystem/go-grpc-middleware/auth"
-	"github.com/grpc-ecosystem/go-grpc-middleware/recovery"
-	"github.com/spf13/viper"
-	"go/types"
-	"google.golang.org/grpc"
-	"net"
-	"sync"
-)
-
-var subs = sync.Map{}
-
-type Server struct {
-	// dependencies
-	nodeCfgSvc          interfaces.NodeConfigService
-	nodeSvr             *NodeServer
-	taskSvr             *TaskServer
-	messageSvr          *MessageServer
-	modelDelegateSvr    *ModelDelegateServer
-	modelBaseServiceSvr *ModelBaseServiceServer
-
-	// settings
-	cfgPath string
-	address interfaces.Address
-
-	// internals
-	svr     *grpc.Server
-	l       net.Listener
-	stopped bool
-}
-
-func (svr *Server) Init() (err error) {
-	// register
-	if err := svr.Register(); err != nil {
-		return err
-	}
-
-	return nil
-}
-
-func (svr *Server) Start() (err error) {
-	// grpc server binding address
-	address := svr.address.String()
-
-	// listener
-	svr.l, err = net.Listen("tcp", address)
-	if err != nil {
-		_ = trace.TraceError(err)
-		return errors.ErrorGrpcServerFailedToListen
-	}
-	log.Infof("grpc server listens to %s", address)
-
-	// start grpc server
-	go func() {
-		if err := svr.svr.Serve(svr.l); err != nil {
-			if err == grpc.ErrServerStopped {
-				return
-			}
-			trace.PrintError(err)
-			log.Error(errors.ErrorGrpcServerFailedToServe.Error())
-		}
-	}()
-
-	return nil
-}
-
-func (svr *Server) Stop() (err error) {
-	// skip if listener is nil
-	if svr.l == nil {
-		return nil
-	}
-
-	// graceful stop
-	log.Infof("grpc server stopping...")
-	svr.svr.Stop()
-
-	// close listener
-	log.Infof("grpc server closing listener...")
-	_ = svr.l.Close()
-
-	// mark as stopped
-	svr.stopped = true
-
-	// log
-	log.Infof("grpc server stopped")
-
-	return nil
-}
-
-func (svr *Server) Register() (err error) {
-	grpc2.RegisterModelDelegateServer(svr.svr, *svr.modelDelegateSvr)       // model delegate
-	grpc2.RegisterModelBaseServiceServer(svr.svr, *svr.modelBaseServiceSvr) // model base service
-	grpc2.RegisterNodeServiceServer(svr.svr, *svr.nodeSvr)                  // node service
-	grpc2.RegisterTaskServiceServer(svr.svr, *svr.taskSvr)                  // task service
-	grpc2.RegisterMessageServiceServer(svr.svr, *svr.messageSvr)            // message service
-
-	return nil
-}
-
-func (svr *Server) SetAddress(address interfaces.Address) {
-	svr.address = address
-}
-
-func (svr *Server) GetConfigPath() (path string) {
-	return svr.cfgPath
-}
-
-func (svr *Server) SetConfigPath(path string) {
-	svr.cfgPath = path
-}
-
-func (svr *Server) GetSubscribe(key string) (sub interfaces.GrpcSubscribe, err error) {
-	res, ok := subs.Load(key)
-	if !ok {
-		return nil, trace.TraceError(errors.ErrorGrpcStreamNotFound)
-	}
-	sub, ok = res.(interfaces.GrpcSubscribe)
-	if !ok {
-		return nil, trace.TraceError(errors.ErrorGrpcInvalidType)
-	}
-	return sub, nil
-}
-
-func (svr *Server) SetSubscribe(key string, sub interfaces.GrpcSubscribe) {
-	subs.Store(key, sub)
-}
-
-func (svr *Server) DeleteSubscribe(key string) {
-	subs.Delete(key)
-}
-
-func (svr *Server) SendStreamMessage(key string, code grpc2.StreamMessageCode) (err error) {
-	return svr.SendStreamMessageWithData(key, code, nil)
-}
-
-func (svr *Server) SendStreamMessageWithData(key string, code grpc2.StreamMessageCode, d interface{}) (err error) {
-	var data []byte
-	switch d.(type) {
-	case types.Nil:
-		// do nothing
-	case []byte:
-		data = d.([]byte)
-	default:
-		var err error
-		data, err = json.Marshal(d)
-		if err != nil {
-			panic(err)
-		}
-	}
-	sub, err := svr.GetSubscribe(key)
-	if err != nil {
-		return err
-	}
-	msg := &grpc2.StreamMessage{
-		Code: code,
-		Key:  svr.nodeCfgSvc.GetNodeKey(),
-		Data: data,
-	}
-	return sub.GetStream().Send(msg)
-}
-
-func (svr *Server) IsStopped() (res bool) {
-	return svr.stopped
-}
-
-func (svr *Server) recoveryHandlerFunc(p interface{}) (err error) {
-	err = errors.NewError(errors.ErrorPrefixGrpc, fmt.Sprintf("%v", p))
-	trace.PrintError(err)
-	return err
-}
-
-func NewServer() (svr2 interfaces.GrpcServer, err error) {
-	// server
-	svr := &Server{
-		cfgPath: config2.GetConfigPath(),
-		address: entity.NewAddress(&entity.AddressOptions{
-			Host: constants.DefaultGrpcServerHost,
-			Port: constants.DefaultGrpcServerPort,
-		}),
-	}
-
-	if viper.GetString("grpc.server.address") != "" {
-		svr.address, err = entity.NewAddressFromString(viper.GetString("grpc.server.address"))
-		if err != nil {
-			return nil, err
-		}
-	}
-
-	// dependency injection
-	if err := container.GetContainer().Invoke(func(
-		nodeCfgSvc interfaces.NodeConfigService,
-		modelDelegateSvr *ModelDelegateServer,
-		modelBaseServiceSvr *ModelBaseServiceServer,
-		nodeSvr *NodeServer,
-		taskSvr *TaskServer,
-		messageSvr *MessageServer,
-	) {
-		// dependencies
-		svr.nodeCfgSvc = nodeCfgSvc
-		svr.modelDelegateSvr = modelDelegateSvr
-		svr.modelBaseServiceSvr = modelBaseServiceSvr
-		svr.nodeSvr = nodeSvr
-		svr.taskSvr = taskSvr
-		svr.messageSvr = messageSvr
-
-		// server
-		svr.nodeSvr.server = svr
-		svr.taskSvr.server = svr
-		svr.messageSvr.server = svr
-	}); err != nil {
-		return nil, err
-	}
-
-	// recovery options
-	recoveryOpts := []grpc_recovery.Option{
-		grpc_recovery.WithRecoveryHandler(svr.recoveryHandlerFunc),
-	}
-
-	// grpc server
-	svr.svr = grpc.NewServer(
-		grpc_middleware.WithUnaryServerChain(
-			grpc_recovery.UnaryServerInterceptor(recoveryOpts...),
-			grpc_auth.UnaryServerInterceptor(middlewares.GetAuthTokenFunc(svr.nodeCfgSvc)),
-		),
-		grpc_middleware.WithStreamServerChain(
-			grpc_recovery.StreamServerInterceptor(recoveryOpts...),
-			grpc_auth.StreamServerInterceptor(middlewares.GetAuthTokenFunc(svr.nodeCfgSvc)),
-		),
-	)
-
-	// initialize
-	if err := svr.Init(); err != nil {
-		return nil, err
-	}
-
-	return svr, nil
-}
-
-var _server interfaces.GrpcServer
-
-func GetServer() (svr interfaces.GrpcServer, err error) {
-	if _server != nil {
-		return _server, nil
-	}
-	_server, err = NewServer()
-	if err != nil {
-		return nil, err
-	}
-	return _server, nil
-}

core/grpc/server/task_server_v2.go

@@ -110,7 +110,7 @@ func (svr TaskServerV2) Fetch(ctx context.Context, request *grpc.Request) (respo
 }
 
 func (svr TaskServerV2) SendNotification(ctx context.Context, request *grpc.Request) (response *grpc.Response, err error) {
-	svc := notification.GetServiceV2()
+	svc := notification.GetNotificationServiceV2()
 	var t = new(models.TaskV2)
 	if err := json.Unmarshal(request.Data, t); err != nil {
 		return nil, trace.TraceError(err)

core/grpc/test/auth_token_test.go

@@ -1,96 +0,0 @@
-package test
-
-import (
-	"context"
-	"encoding/json"
-	"github.com/crawlab-team/crawlab/core/entity"
-	"github.com/crawlab-team/crawlab/core/grpc/client"
-	"github.com/crawlab-team/crawlab/core/grpc/server"
-	"github.com/crawlab-team/crawlab/core/node/config"
-	grpc "github.com/crawlab-team/crawlab/grpc"
-	"github.com/stretchr/testify/require"
-	"io/ioutil"
-	"os"
-	"path"
-	"testing"
-)
-
-func TestAuthToken(t *testing.T) {
-	var err error
-
-	// auth key
-	authKey := "test-auth-key"
-
-	// auth key (invalid)
-	authKeyInvalid := "test-auth-key-invalid"
-
-	// tmp dir
-	tmpDir := os.TempDir()
-
-	// master config
-	masterConfigPath := path.Join(tmpDir, "config-master.json")
-	masterConfig := config.Config{
-		Key:      "master",
-		IsMaster: true,
-		AuthKey:  authKey,
-	}
-	masterConfigData, err := json.Marshal(&masterConfig)
-	require.Nil(t, err)
-	err = ioutil.WriteFile(masterConfigPath, masterConfigData, os.FileMode(0777))
-
-	// worker config
-	workerConfigPath := path.Join(tmpDir, "config-worker.json")
-	workerConfig := config.Config{
-		Key:      "worker",
-		IsMaster: false,
-		AuthKey:  authKey,
-	}
-	workerConfigData, err := json.Marshal(&workerConfig)
-	require.Nil(t, err)
-	err = ioutil.WriteFile(workerConfigPath, workerConfigData, os.FileMode(0777))
-
-	// worker config (invalid)
-	workerInvalidConfigPath := path.Join(tmpDir, "worker-invalid")
-	workerInvalidConfig := config.Config{
-		Key:      "worker",
-		IsMaster: false,
-		AuthKey:  authKeyInvalid,
-	}
-	workerInvalidConfigData, err := json.Marshal(&workerInvalidConfig)
-	require.Nil(t, err)
-	err = ioutil.WriteFile(workerInvalidConfigPath, workerInvalidConfigData, os.FileMode(0777))
-
-	// server
-	svr, err := server.NewServer(
-		server.WithConfigPath(masterConfigPath),
-		server.WithAddress(entity.NewAddress(&entity.AddressOptions{
-			Host: "0.0.0.0",
-			Port: "9999",
-		})),
-	)
-	require.Nil(t, err)
-	err = svr.Start()
-	require.Nil(t, err)
-
-	// client
-	c, err := client.GetClient(workerConfigPath, client.WithAddress(entity.NewAddress(&entity.AddressOptions{
-		Host: "localhost",
-		Port: "9999",
-	})))
-	require.Nil(t, err)
-	err = c.Start()
-	require.Nil(t, err)
-	_, err = c.GetNodeClient().Ping(context.Background(), &grpc.Request{NodeKey: workerConfig.Key})
-	require.Nil(t, err)
-
-	// client (invalid)
-	ci, err := client.GetClient(workerInvalidConfigPath, client.WithAddress(entity.NewAddress(&entity.AddressOptions{
-		Host: "localhost",
-		Port: "9999",
-	})))
-	require.Nil(t, err)
-	err = ci.Start()
-	require.Nil(t, err)
-	_, err = ci.GetNodeClient().Ping(context.Background(), &grpc.Request{NodeKey: workerInvalidConfig.Key})
-	require.NotNil(t, err)
-}

core/grpc/test/base.go

@@ -1,77 +0,0 @@
-package test
-
-import (
-	"github.com/crawlab-team/crawlab/core/entity"
-	"github.com/crawlab-team/crawlab/core/grpc/client"
-	"github.com/crawlab-team/crawlab/core/grpc/server"
-	"github.com/crawlab-team/crawlab/core/interfaces"
-	"github.com/crawlab-team/crawlab/core/node/test"
-	"testing"
-	"time"
-)
-
-type Test struct {
-	Server interfaces.GrpcServer
-	Client interfaces.GrpcClient
-
-	MasterNodeInfo *entity.NodeInfo
-	WorkerNodeInfo *entity.NodeInfo
-}
-
-func (t *Test) Setup(t2 *testing.T) {
-	test.T.Cleanup()
-	t2.Cleanup(t.Cleanup)
-	if !T.Client.IsStarted() {
-		_ = T.Client.Start()
-	} else if T.Client.IsClosed() {
-		_ = T.Client.Restart()
-	}
-}
-
-func (t *Test) Cleanup() {
-	_ = t.Client.Stop()
-	_ = t.Server.Stop()
-	test.T.Cleanup()
-
-	// wait to avoid caching
-	time.Sleep(200 * time.Millisecond)
-}
-
-var T *Test
-
-func NewTest() (res *Test, err error) {
-	// test
-	t := &Test{}
-
-	// server
-	t.Server, err = server.NewServer(
-		server.WithConfigPath(test.T.MasterSvc.GetConfigPath()),
-		server.WithAddress(test.T.MasterSvc.GetAddress()),
-	)
-	if err != nil {
-		return nil, err
-	}
-	if err := t.Server.Start(); err != nil {
-		return nil, err
-	}
-
-	// client
-	t.Client, err = client.GetClient(test.T.WorkerSvc.GetConfigPath())
-	if err != nil {
-		return nil, err
-	}
-
-	// master node info
-	t.MasterNodeInfo = &entity.NodeInfo{
-		Key:      "master",
-		IsMaster: true,
-	}
-
-	// worker node info
-	t.WorkerNodeInfo = &entity.NodeInfo{
-		Key:      "worker",
-		IsMaster: false,
-	}
-
-	return t, nil
-}

core/models/client/model_service_v2.go

@@ -331,7 +331,7 @@ func NewModelServiceV2[T any]() *ModelServiceV2[T] {
 	typeName := t.Name()
 
 	if _, exists := onceMap[typeName]; !exists {
-		onceMap[typeName] = &sync.Once{}
+		onceMap[typeName] = new(sync.Once)
 	}
 
 	var instance *ModelServiceV2[T]

core/models/service/base_service_v2.go

@@ -146,7 +146,7 @@ func NewModelServiceV2[T any]() *ModelServiceV2[T] {
 	defer mu.Unlock()
 
 	if _, exists := onceMap[typeName]; !exists {
-		onceMap[typeName] = &sync.Once{}
+		onceMap[typeName] = new(sync.Once)
 	}
 
 	var instance *ModelServiceV2[T]
@@ -166,7 +166,7 @@ func NewModelServiceV2WithColName[T any](colName string) *ModelServiceV2[T] {
 	defer mu.Unlock()
 
 	if _, exists := onceColNameMap[colName]; !exists {
-		onceColNameMap[colName] = &sync.Once{}
+		onceColNameMap[colName] = new(sync.Once)
 	}
 
 	var instance *ModelServiceV2[T]

core/node/config/config_service.go

@@ -9,6 +9,7 @@ import (
 	"github.com/crawlab-team/crawlab/trace"
 	"os"
 	"path/filepath"
+	"sync"
 )
 
 type Service struct {
@@ -93,7 +94,7 @@ func (svc *Service) SetConfigPath(path string) {
 	svc.path = path
 }
 
-func NewNodeConfigService() (svc2 interfaces.NodeConfigService, err error) {
+func newNodeConfigService() (svc2 interfaces.NodeConfigService, err error) {
 	// cfg
 	cfg := NewConfig(nil)
 
@@ -115,17 +116,18 @@ func NewNodeConfigService() (svc2 interfaces.NodeConfigService, err error) {
 }
 
 var _service interfaces.NodeConfigService
+var _serviceOnce = new(sync.Once)
 
 func GetNodeConfigService() interfaces.NodeConfigService {
 	if _service != nil {
 		return _service
 	}
-
-	var err error
-	_service, err = NewNodeConfigService()
-	if err != nil {
-		panic(err)
-	}
-
+	_serviceOnce.Do(func() {
+		var err error
+		_service, err = newNodeConfigService()
+		if err != nil {
+			panic(err)
+		}
+	})
 	return _service
 }

core/node/service/master_service_v2.go

@@ -6,7 +6,6 @@ import (
 	"github.com/cenkalti/backoff/v4"
 	config2 "github.com/crawlab-team/crawlab/core/config"
 	"github.com/crawlab-team/crawlab/core/constants"
-	"github.com/crawlab-team/crawlab/core/container"
 	"github.com/crawlab-team/crawlab/core/grpc/server"
 	"github.com/crawlab-team/crawlab/core/interfaces"
 	"github.com/crawlab-team/crawlab/core/models/common"
@@ -20,7 +19,7 @@ import (
 	"github.com/crawlab-team/crawlab/core/task/handler"
 	"github.com/crawlab-team/crawlab/core/task/scheduler"
 	"github.com/crawlab-team/crawlab/core/utils"
-	grpc "github.com/crawlab-team/crawlab/grpc"
+	"github.com/crawlab-team/crawlab/grpc"
 	"github.com/crawlab-team/crawlab/trace"
 	"go.mongodb.org/mongo-driver/bson"
 	"go.mongodb.org/mongo-driver/bson/primitive"
@@ -320,7 +319,7 @@ func (svc *MasterServiceV2) updateNodeAvailableRunners(node *models.NodeV2) (err
 	return nil
 }
 
-func NewMasterServiceV2() (res interfaces.NodeMasterService, err error) {
+func newMasterServiceV2() (res *MasterServiceV2, err error) {
 	// master service
 	svc := &MasterServiceV2{
 		cfgPath:         config2.GetConfigPath(),
@@ -334,14 +333,8 @@ func NewMasterServiceV2() (res interfaces.NodeMasterService, err error) {
 		serverOpts = append(serverOpts, server.WithAddress(svc.address))
 	}
 
-	// dependency injection
-	if err := container.GetContainer().Invoke(func(
-		cfgSvc interfaces.NodeConfigService,
-	) {
-		svc.cfgSvc = cfgSvc
-	}); err != nil {
-		return nil, err
-	}
+	// node config service
+	svc.cfgSvc = config.GetNodeConfigService()
 
 	// grpc server
 	svc.server, err = server.GetGrpcServerV2()
@@ -368,7 +361,7 @@ func NewMasterServiceV2() (res interfaces.NodeMasterService, err error) {
 	}
 
 	// notification service
-	svc.notificationSvc = notification.GetServiceV2()
+	svc.notificationSvc = notification.GetNotificationServiceV2()
 
 	// spider admin service
 	svc.spiderAdminSvc, err = admin.GetSpiderAdminServiceV2()
@@ -377,7 +370,7 @@ func NewMasterServiceV2() (res interfaces.NodeMasterService, err error) {
 	}
 
 	// system service
-	svc.systemSvc = system.GetServiceV2()
+	svc.systemSvc = system.GetSystemServiceV2()
 
 	// init
 	if err := svc.Init(); err != nil {
@@ -386,3 +379,17 @@ func NewMasterServiceV2() (res interfaces.NodeMasterService, err error) {
 
 	return svc, nil
 }
+
+var masterServiceV2 *MasterServiceV2
+var masterServiceV2Once = new(sync.Once)
+
+func GetMasterServiceV2() (res *MasterServiceV2, err error) {
+	masterServiceV2Once.Do(func() {
+		masterServiceV2, err = newMasterServiceV2()
+		if err != nil {
+			log.Errorf("failed to get master service: %v", err)
+		}
+	})
+	return masterServiceV2, err
+
+}

core/node/service/worker_service.go

@@ -1,238 +0,0 @@
-package service
-
-import (
-	"context"
-	"encoding/json"
-	"github.com/apex/log"
-	config2 "github.com/crawlab-team/crawlab/core/config"
-	"github.com/crawlab-team/crawlab/core/container"
-	"github.com/crawlab-team/crawlab/core/grpc/client"
-	"github.com/crawlab-team/crawlab/core/interfaces"
-	"github.com/crawlab-team/crawlab/core/models/models"
-	"github.com/crawlab-team/crawlab/core/utils"
-	grpc "github.com/crawlab-team/crawlab/grpc"
-	"github.com/crawlab-team/crawlab/trace"
-	"github.com/spf13/viper"
-	"time"
-)
-
-type WorkerService struct {
-	// dependencies
-	cfgSvc     interfaces.NodeConfigService
-	client     interfaces.GrpcClient
-	handlerSvc interfaces.TaskHandlerService
-
-	// settings
-	cfgPath           string
-	address           interfaces.Address
-	heartbeatInterval time.Duration
-
-	// internals
-	n interfaces.Node
-	s grpc.NodeService_SubscribeClient
-}
-
-func (svc *WorkerService) Init() (err error) {
-	// do nothing
-	return nil
-}
-
-func (svc *WorkerService) Start() {
-	// start grpc client
-	if err := svc.client.Start(); err != nil {
-		panic(err)
-	}
-
-	// register to master
-	svc.Register()
-
-	// start receiving stream messages
-	go svc.Recv()
-
-	// start sending heartbeat to master
-	go svc.ReportStatus()
-
-	// start handler
-	go svc.handlerSvc.Start()
-
-	// wait for quit signal
-	svc.Wait()
-
-	// stop
-	svc.Stop()
-}
-
-func (svc *WorkerService) Wait() {
-	utils.DefaultWait()
-}
-
-func (svc *WorkerService) Stop() {
-	_ = svc.client.Stop()
-	log.Infof("worker[%s] service has stopped", svc.cfgSvc.GetNodeKey())
-}
-
-func (svc *WorkerService) Register() {
-	ctx, cancel := svc.client.Context()
-	defer cancel()
-	req := svc.client.NewRequest(svc.GetConfigService().GetBasicNodeInfo())
-	res, err := svc.client.GetNodeClient().Register(ctx, req)
-	if err != nil {
-		panic(err)
-	}
-	if err := json.Unmarshal(res.Data, svc.n); err != nil {
-		panic(err)
-	}
-	log.Infof("worker[%s] registered to master. id: %s", svc.GetConfigService().GetNodeKey(), svc.n.GetId().Hex())
-	return
-}
-
-func (svc *WorkerService) Recv() {
-	msgCh := svc.client.GetMessageChannel()
-	for {
-		// return if client is closed
-		if svc.client.IsClosed() {
-			return
-		}
-
-		// receive message from channel
-		msg := <-msgCh
-
-		// handle message
-		if err := svc.handleStreamMessage(msg); err != nil {
-			continue
-		}
-	}
-}
-
-func (svc *WorkerService) handleStreamMessage(msg *grpc.StreamMessage) (err error) {
-	log.Debugf("[WorkerService] handle msg: %v", msg)
-	switch msg.Code {
-	case grpc.StreamMessageCode_PING:
-		if _, err := svc.client.GetNodeClient().SendHeartbeat(context.Background(), svc.client.NewRequest(svc.cfgSvc.GetBasicNodeInfo())); err != nil {
-			return trace.TraceError(err)
-		}
-	case grpc.StreamMessageCode_RUN_TASK:
-		var t models.Task
-		if err := json.Unmarshal(msg.Data, &t); err != nil {
-			return trace.TraceError(err)
-		}
-		if err := svc.handlerSvc.Run(t.Id); err != nil {
-			return trace.TraceError(err)
-		}
-	case grpc.StreamMessageCode_CANCEL_TASK:
-		var t models.Task
-		if err := json.Unmarshal(msg.Data, &t); err != nil {
-			return trace.TraceError(err)
-		}
-		if err := svc.handlerSvc.Cancel(t.Id); err != nil {
-			return trace.TraceError(err)
-		}
-	}
-
-	return nil
-}
-
-func (svc *WorkerService) ReportStatus() {
-	for {
-		// return if client is closed
-		if svc.client.IsClosed() {
-			return
-		}
-
-		// report status
-		svc.reportStatus()
-
-		// sleep
-		time.Sleep(svc.heartbeatInterval)
-	}
-}
-
-func (svc *WorkerService) GetConfigService() (cfgSvc interfaces.NodeConfigService) {
-	return svc.cfgSvc
-}
-
-func (svc *WorkerService) GetConfigPath() (path string) {
-	return svc.cfgPath
-}
-
-func (svc *WorkerService) SetConfigPath(path string) {
-	svc.cfgPath = path
-}
-
-func (svc *WorkerService) GetAddress() (address interfaces.Address) {
-	return svc.address
-}
-
-func (svc *WorkerService) SetAddress(address interfaces.Address) {
-	svc.address = address
-}
-
-func (svc *WorkerService) SetHeartbeatInterval(duration time.Duration) {
-	svc.heartbeatInterval = duration
-}
-
-func (svc *WorkerService) reportStatus() {
-	ctx, cancel := context.WithTimeout(context.Background(), svc.heartbeatInterval)
-	defer cancel()
-	_, err := svc.client.GetNodeClient().SendHeartbeat(ctx, &grpc.Request{
-		NodeKey: svc.cfgSvc.GetNodeKey(),
-	})
-	if err != nil {
-		trace.PrintError(err)
-	}
-}
-
-func NewWorkerService(opts ...Option) (res *WorkerService, err error) {
-	svc := &WorkerService{
-		cfgPath:           config2.GetConfigPath(),
-		heartbeatInterval: 15 * time.Second,
-		n:                 &models.Node{},
-	}
-
-	// apply options
-	for _, opt := range opts {
-		opt(svc)
-	}
-
-	// dependency options
-	var clientOpts []client.Option
-	if svc.address != nil {
-		clientOpts = append(clientOpts, client.WithAddress(svc.address))
-	}
-
-	// dependency injection
-	if err := container.GetContainer().Invoke(func(
-		cfgSvc interfaces.NodeConfigService,
-		client interfaces.GrpcClient,
-		taskHandlerSvc interfaces.TaskHandlerService,
-	) {
-		svc.cfgSvc = cfgSvc
-		svc.client = client
-		svc.handlerSvc = taskHandlerSvc
-	}); err != nil {
-		return nil, err
-	}
-
-	// init
-	if err := svc.Init(); err != nil {
-		return nil, err
-	}
-
-	return svc, nil
-}
-
-func ProvideWorkerService(path string, opts ...Option) func() (interfaces.NodeWorkerService, error) {
-	// path
-	if path == "" || path == config2.GetConfigPath() {
-		if viper.GetString("config.path") != "" {
-			path = viper.GetString("config.path")
-		} else {
-			path = config2.GetConfigPath()
-		}
-	}
-	opts = append(opts, WithConfigPath(path))
-
-	return func() (interfaces.NodeWorkerService, error) {
-		return NewWorkerService(opts...)
-	}
-}

core/node/service/worker_service_v2.go

@@ -5,14 +5,17 @@ import (
 	"encoding/json"
 	"github.com/apex/log"
 	config2 "github.com/crawlab-team/crawlab/core/config"
-	"github.com/crawlab-team/crawlab/core/container"
 	"github.com/crawlab-team/crawlab/core/grpc/client"
 	"github.com/crawlab-team/crawlab/core/interfaces"
+	client2 "github.com/crawlab-team/crawlab/core/models/client"
 	"github.com/crawlab-team/crawlab/core/models/models"
+	nodeconfig "github.com/crawlab-team/crawlab/core/node/config"
 	"github.com/crawlab-team/crawlab/core/task/handler"
 	"github.com/crawlab-team/crawlab/core/utils"
 	grpc "github.com/crawlab-team/crawlab/grpc"
 	"github.com/crawlab-team/crawlab/trace"
+	"go.mongodb.org/mongo-driver/bson"
+	"sync"
 	"time"
 )
 
@@ -28,7 +31,7 @@ type WorkerServiceV2 struct {
 	heartbeatInterval time.Duration
 
 	// internals
-	n interfaces.Node
+	n *models.NodeV2
 	s grpc.NodeService_SubscribeClient
 }
 
@@ -74,15 +77,21 @@ func (svc *WorkerServiceV2) Stop() {
 func (svc *WorkerServiceV2) Register() {
 	ctx, cancel := svc.client.Context()
 	defer cancel()
-	req := svc.client.NewRequest(svc.GetConfigService().GetBasicNodeInfo())
-	res, err := svc.client.NodeClient.Register(ctx, req)
+	_, err := svc.client.NodeClient.Register(ctx, &grpc.NodeServiceRegisterRequest{
+		Key:        svc.cfgSvc.GetNodeKey(),
+		Name:       svc.cfgSvc.GetNodeName(),
+		IsMaster:   svc.cfgSvc.IsMaster(),
+		AuthKey:    svc.cfgSvc.GetAuthKey(),
+		MaxRunners: int32(svc.cfgSvc.GetMaxRunners()),
+	})
 	if err != nil {
 		panic(err)
 	}
-	if err := json.Unmarshal(res.Data, svc.n); err != nil {
+	svc.n, err = client2.NewModelServiceV2[models.NodeV2]().GetOne(bson.M{"key": svc.GetConfigService().GetNodeKey()}, nil)
+	if err != nil {
 		panic(err)
 	}
-	log.Infof("worker[%s] registered to master. id: %s", svc.GetConfigService().GetNodeKey(), svc.n.GetId().Hex())
+	log.Infof("worker[%s] registered to master. id: %s", svc.GetConfigService().GetNodeKey(), svc.n.Id.Hex())
 	return
 }
 
@@ -108,7 +117,10 @@ func (svc *WorkerServiceV2) handleStreamMessage(msg *grpc.StreamMessage) (err er
 	log.Debugf("[WorkerServiceV2] handle msg: %v", msg)
 	switch msg.Code {
 	case grpc.StreamMessageCode_PING:
-		if _, err := svc.client.NodeClient.SendHeartbeat(context.Background(), svc.client.NewRequest(svc.cfgSvc.GetBasicNodeInfo())); err != nil {
+		_, err := svc.client.NodeClient.SendHeartbeat(context.Background(), &grpc.NodeServiceSendHeartbeatRequest{
+			Key: svc.cfgSvc.GetNodeKey(),
+		})
+		if err != nil {
 			return trace.TraceError(err)
 		}
 	case grpc.StreamMessageCode_RUN_TASK:
@@ -133,9 +145,11 @@ func (svc *WorkerServiceV2) handleStreamMessage(msg *grpc.StreamMessage) (err er
 }
 
 func (svc *WorkerServiceV2) ReportStatus() {
+	ticker := time.NewTicker(svc.heartbeatInterval)
 	for {
 		// return if client is closed
 		if svc.client.IsClosed() {
+			ticker.Stop()
 			return
 		}
 
@@ -143,7 +157,7 @@ func (svc *WorkerServiceV2) ReportStatus() {
 		svc.reportStatus()
 
 		// sleep
-		time.Sleep(svc.heartbeatInterval)
+		<-ticker.C
 	}
 }
 
@@ -174,19 +188,21 @@ func (svc *WorkerServiceV2) SetHeartbeatInterval(duration time.Duration) {
 func (svc *WorkerServiceV2) reportStatus() {
 	ctx, cancel := context.WithTimeout(context.Background(), svc.heartbeatInterval)
 	defer cancel()
-	_, err := svc.client.NodeClient.SendHeartbeat(ctx, &grpc.Request{
-		NodeKey: svc.cfgSvc.GetNodeKey(),
+	_, err := svc.client.NodeClient.SendHeartbeat(ctx, &grpc.NodeServiceSendHeartbeatRequest{
+		Key: svc.cfgSvc.GetNodeKey(),
 	})
 	if err != nil {
 		trace.PrintError(err)
 	}
 }
 
-func NewWorkerServiceV2() (res *WorkerServiceV2, err error) {
+var workerServiceV2 *WorkerServiceV2
+var workerServiceV2Once = new(sync.Once)
+
+func newWorkerServiceV2() (res *WorkerServiceV2, err error) {
 	svc := &WorkerServiceV2{
 		cfgPath:           config2.GetConfigPath(),
 		heartbeatInterval: 15 * time.Second,
-		n:                 &models.Node{},
 	}
 
 	// dependency options
@@ -195,14 +211,8 @@ func NewWorkerServiceV2() (res *WorkerServiceV2, err error) {
 		clientOpts = append(clientOpts, client.WithAddress(svc.address))
 	}
 
-	// dependency injection
-	if err := container.GetContainer().Invoke(func(
-		cfgSvc interfaces.NodeConfigService,
-	) {
-		svc.cfgSvc = cfgSvc
-	}); err != nil {
-		return nil, err
-	}
+	// node config service
+	svc.cfgSvc = nodeconfig.GetNodeConfigService()
 
 	// grpc client
 	svc.client = client.GetGrpcClientV2()
@@ -214,9 +224,20 @@ func NewWorkerServiceV2() (res *WorkerServiceV2, err error) {
 	}
 
 	// init
-	if err := svc.Init(); err != nil {
+	err = svc.Init()
+	if err != nil {
 		return nil, err
 	}
 
 	return svc, nil
 }
+
+func GetWorkerServiceV2() (res *WorkerServiceV2, err error) {
+	workerServiceV2Once.Do(func() {
+		workerServiceV2, err = newWorkerServiceV2()
+		if err != nil {
+			log.Errorf("failed to get worker service: %v", err)
+		}
+	})
+	return workerServiceV2, err
+}

core/node/test/base.go

@@ -1,206 +0,0 @@
-package test
-
-import (
-	"github.com/crawlab-team/crawlab/core/entity"
-	"github.com/crawlab-team/crawlab/core/interfaces"
-	service2 "github.com/crawlab-team/crawlab/core/models/service"
-	"github.com/crawlab-team/crawlab/core/node/service"
-	"github.com/crawlab-team/crawlab/core/utils"
-	"github.com/spf13/viper"
-	"go.uber.org/dig"
-	"io/ioutil"
-	"os"
-	"path"
-	"testing"
-	"time"
-)
-
-func init() {
-	var err error
-	T, err = NewTest()
-	if err != nil {
-		panic(err)
-	}
-}
-
-var T *Test
-
-type Test struct {
-	DefaultSvc       interfaces.NodeMasterService
-	MasterSvc        interfaces.NodeMasterService
-	WorkerSvc        interfaces.NodeWorkerService
-	MasterSvcMonitor interfaces.NodeMasterService
-	WorkerSvcMonitor interfaces.NodeWorkerService
-	ModelSvc         service2.ModelService
-}
-
-func NewTest() (res *Test, err error) {
-	// test
-	t := &Test{}
-
-	// recreate config directory path
-	_ = os.RemoveAll(viper.GetString("metadata"))
-	_ = os.MkdirAll(viper.GetString("metadata"), os.FileMode(0766))
-
-	// master config and settings
-	masterNodeConfigName := "config-master.json"
-	masterNodeConfigPath := path.Join(viper.GetString("metadata"), masterNodeConfigName)
-	if err := ioutil.WriteFile(masterNodeConfigPath, []byte("{\"key\":\"master\",\"is_master\":true}"), os.FileMode(0766)); err != nil {
-		return nil, err
-	}
-	masterHost := "0.0.0.0"
-	masterPort := "9667"
-
-	// worker config and settings
-	workerNodeConfigName := "config-worker.json"
-	workerNodeConfigPath := path.Join(viper.GetString("metadata"), workerNodeConfigName)
-	if err = ioutil.WriteFile(workerNodeConfigPath, []byte("{\"key\":\"worker\",\"is_master\":false}"), os.FileMode(0766)); err != nil {
-		return nil, err
-	}
-	workerHost := "localhost"
-	workerPort := masterPort
-
-	// master for monitor config and settings
-	masterNodeMonitorConfigName := "config-master-monitor.json"
-	masterNodeMonitorConfigPath := path.Join(viper.GetString("metadata"), masterNodeMonitorConfigName)
-	if err := ioutil.WriteFile(masterNodeMonitorConfigPath, []byte("{\"key\":\"master-monitor\",\"is_master\":true}"), os.FileMode(0766)); err != nil {
-		return nil, err
-	}
-	masterMonitorHost := masterHost
-	masterMonitorPort := "9668"
-
-	// worker for monitor config and settings
-	workerNodeMonitorConfigName := "config-worker-monitor.json"
-	workerNodeMonitorConfigPath := path.Join(viper.GetString("metadata"), workerNodeMonitorConfigName)
-	if err := ioutil.WriteFile(workerNodeMonitorConfigPath, []byte("{\"key\":\"worker-monitor\",\"is_master\":false}"), os.FileMode(0766)); err != nil {
-		return nil, err
-	}
-	workerMonitorHost := workerHost
-	workerMonitorPort := masterMonitorPort
-
-	// dependency injection
-	c := dig.New()
-	if err := c.Provide(service.ProvideMasterService(
-		masterNodeConfigPath,
-		service.WithMonitorInterval(3*time.Second),
-		service.WithAddress(entity.NewAddress(&entity.AddressOptions{
-			Host: masterHost,
-			Port: masterPort,
-		})),
-	)); err != nil {
-		return nil, err
-	}
-	if err := c.Provide(service.ProvideWorkerService(
-		workerNodeConfigPath,
-		service.WithHeartbeatInterval(1*time.Second),
-		service.WithAddress(entity.NewAddress(&entity.AddressOptions{
-			Host: workerHost,
-			Port: workerPort,
-		})),
-	)); err != nil {
-		return nil, err
-	}
-	if err := c.Provide(service2.NewService); err != nil {
-		return nil, err
-	}
-	if err := c.Invoke(func(masterSvc interfaces.NodeMasterService, workerSvc interfaces.NodeWorkerService, modelSvc service2.ModelService) {
-		t.MasterSvc = masterSvc
-		t.WorkerSvc = workerSvc
-		t.ModelSvc = modelSvc
-	}); err != nil {
-		return nil, err
-	}
-
-	// default service
-	t.DefaultSvc, err = service.NewMasterService()
-	if err != nil {
-		return nil, err
-	}
-
-	// master and worker for monitor
-	t.MasterSvcMonitor, err = service.NewMasterService(
-		service.WithConfigPath(masterNodeMonitorConfigPath),
-		service.WithAddress(entity.NewAddress(&entity.AddressOptions{
-			Host: masterMonitorHost,
-			Port: masterMonitorPort,
-		})),
-		service.WithMonitorInterval(3*time.Second),
-		service.WithStopOnError(),
-	)
-	if err != nil {
-		return nil, err
-	}
-	t.WorkerSvcMonitor, err = service.NewWorkerService(
-		service.WithConfigPath(workerNodeMonitorConfigPath),
-		service.WithAddress(entity.NewAddress(&entity.AddressOptions{
-			Host: workerMonitorHost,
-			Port: workerMonitorPort,
-		})),
-		service.WithHeartbeatInterval(1*time.Second),
-		service.WithStopOnError(),
-	)
-	if err != nil {
-		return nil, err
-	}
-
-	// removed all data in db
-	_ = t.ModelSvc.DropAll()
-
-	// visualize dependencies
-	if err := utils.VisualizeContainer(c); err != nil {
-		return nil, err
-	}
-
-	return t, nil
-}
-
-func (t *Test) Setup(t2 *testing.T) {
-	if err := t.ModelSvc.DropAll(); err != nil {
-		panic(err)
-	}
-	_ = os.RemoveAll(viper.GetString("metadata"))
-	t2.Cleanup(t.Cleanup)
-}
-
-func (t *Test) Cleanup() {
-	if err := t.ModelSvc.DropAll(); err != nil {
-		panic(err)
-	}
-	_ = os.RemoveAll(viper.GetString("metadata"))
-}
-
-func (t *Test) StartMasterWorker() {
-	startMasterWorker()
-}
-
-func (t *Test) StopMasterWorker() {
-	stopMasterWorker()
-}
-
-func startMasterWorker() {
-	go T.MasterSvc.Start()
-	time.Sleep(1 * time.Second)
-	go T.WorkerSvc.Start()
-	time.Sleep(1 * time.Second)
-}
-
-func stopMasterWorker() {
-	go T.MasterSvc.Stop()
-	time.Sleep(1 * time.Second)
-	go T.WorkerSvc.Stop()
-	time.Sleep(1 * time.Second)
-}
-
-func startMasterWorkerMonitor() {
-	go T.MasterSvcMonitor.Start()
-	time.Sleep(1 * time.Second)
-	go T.WorkerSvcMonitor.Start()
-	time.Sleep(1 * time.Second)
-}
-
-func stopMasterWorkerMonitor() {
-	go T.MasterSvcMonitor.Stop()
-	time.Sleep(1 * time.Second)
-	go T.WorkerSvcMonitor.Stop()
-	time.Sleep(1 * time.Second)
-}

core/node/test/base_test.go

@@ -1,67 +0,0 @@
-package test
-
-import (
-	"github.com/crawlab-team/crawlab/core/constants"
-	"github.com/stretchr/testify/require"
-	"testing"
-	"time"
-)
-
-func TestNodeServices_Master_Worker(t *testing.T) {
-	T, _ = NewTest()
-	T.Setup(t)
-	startMasterWorker()
-
-	// validate master
-	masterNodeKey := T.MasterSvc.GetConfigService().GetNodeKey()
-	masterNode, err := T.ModelSvc.GetNodeByKey(masterNodeKey, nil)
-	require.Nil(t, err)
-	require.Equal(t, constants.NodeStatusOnline, masterNode.Status)
-	require.Equal(t, masterNodeKey, masterNode.Key)
-	require.True(t, masterNode.IsMaster)
-
-	// validate worker
-	workerNodeKey := T.WorkerSvc.GetConfigService().GetNodeKey()
-	workerNode, err := T.ModelSvc.GetNodeByKey(workerNodeKey, nil)
-	require.Nil(t, err)
-	require.Equal(t, constants.NodeStatusOnline, workerNode.Status)
-	require.Equal(t, workerNodeKey, workerNode.Key)
-	require.False(t, workerNode.IsMaster)
-
-	stopMasterWorker()
-}
-
-func TestNodeServices_Default(t *testing.T) {
-	T, _ = NewTest()
-	T.Setup(t)
-
-	go T.DefaultSvc.Start()
-	time.Sleep(1 * time.Second)
-
-	// validate default
-	defaultNodeKey := T.DefaultSvc.GetConfigService().GetNodeKey()
-	defaultNode, err := T.ModelSvc.GetNodeByKey(defaultNodeKey, nil)
-	require.Nil(t, err)
-	require.Equal(t, constants.NodeStatusOnline, defaultNode.Status)
-	require.Equal(t, defaultNodeKey, defaultNode.Key)
-	require.True(t, defaultNode.IsMaster)
-
-	T.DefaultSvc.Stop()
-	time.Sleep(1 * time.Second)
-}
-
-func TestNodeServices_Monitor(t *testing.T) {
-	T, _ = NewTest()
-	T.Setup(t)
-	startMasterWorkerMonitor()
-	time.Sleep(3 * time.Second)
-
-	// stop worker
-	T.WorkerSvcMonitor.Stop()
-	time.Sleep(5 * time.Second)
-
-	// validate
-	require.True(t, T.MasterSvcMonitor.GetServer().IsStopped())
-
-	stopMasterWorkerMonitor()
-}

core/notification/service_v2.go

@@ -11,6 +11,7 @@ import (
 	"go.mongodb.org/mongo-driver/bson"
 	"go.mongodb.org/mongo-driver/bson/primitive"
 	"go.mongodb.org/mongo-driver/mongo"
+	"sync"
 )
 
 type ServiceV2 struct {
@@ -341,7 +342,7 @@ func (svc *ServiceV2) _toggleSettingFunc(value bool) func(id primitive.ObjectID)
 	}
 }
 
-func NewServiceV2() *ServiceV2 {
+func newNotificationServiceV2() *ServiceV2 {
 	// service
 	svc := &ServiceV2{}
 
@@ -349,10 +350,14 @@ func NewServiceV2() *ServiceV2 {
 }
 
 var _serviceV2 *ServiceV2
+var _serviceV2Once = new(sync.Once)
 
-func GetServiceV2() *ServiceV2 {
-	if _serviceV2 == nil {
-		_serviceV2 = NewServiceV2()
+func GetNotificationServiceV2() *ServiceV2 {
+	if _serviceV2 != nil {
+		return _serviceV2
 	}
+	_serviceV2Once.Do(func() {
+		_serviceV2 = newNotificationServiceV2()
+	})
 	return _serviceV2
 }

core/schedule/service_v2.go

@@ -1,6 +1,7 @@
 package schedule
 
 import (
+	"github.com/apex/log"
 	"github.com/crawlab-team/crawlab/core/config"
 	"github.com/crawlab-team/crawlab/core/interfaces"
 	"github.com/crawlab-team/crawlab/core/models/models"
@@ -270,12 +271,18 @@ func NewScheduleServiceV2() (svc2 *ServiceV2, err error) {
 }
 
 var svcV2 *ServiceV2
+var svcV2Once = new(sync.Once)
 
 func GetScheduleServiceV2() (res *ServiceV2, err error) {
 	if svcV2 != nil {
 		return svcV2, nil
 	}
-	svcV2, err = NewScheduleServiceV2()
+	svcV2Once.Do(func() {
+		svcV2, err = NewScheduleServiceV2()
+		if err != nil {
+			log.Errorf("failed to get schedule service: %v", err)
+		}
+	})
 	if err != nil {
 		return nil, err
 	}

core/spider/admin/service_v2.go

@@ -1,6 +1,7 @@
 package admin
 
 import (
+	log2 "github.com/apex/log"
 	config2 "github.com/crawlab-team/crawlab/core/config"
 	"github.com/crawlab-team/crawlab/core/constants"
 	"github.com/crawlab-team/crawlab/core/errors"
@@ -13,6 +14,7 @@ import (
 	"github.com/robfig/cron/v3"
 	"go.mongodb.org/mongo-driver/bson"
 	"go.mongodb.org/mongo-driver/bson/primitive"
+	"sync"
 	"time"
 )
 
@@ -160,7 +162,7 @@ func (svc *ServiceV2) isMultiTask(opts *interfaces.SpiderRunOptions) (res bool)
 	}
 }
 
-func NewSpiderAdminServiceV2() (svc2 *ServiceV2, err error) {
+func newSpiderAdminServiceV2() (svc2 *ServiceV2, err error) {
 	svc := &ServiceV2{
 		nodeCfgSvc: config.GetNodeConfigService(),
 		cfgPath:    config2.GetConfigPath(),
@@ -182,16 +184,20 @@ func NewSpiderAdminServiceV2() (svc2 *ServiceV2, err error) {
 }
 
 var svcV2 *ServiceV2
+var svcV2Once = new(sync.Once)
 
 func GetSpiderAdminServiceV2() (svc2 *ServiceV2, err error) {
 	if svcV2 != nil {
 		return svcV2, nil
 	}
-
-	svcV2, err = NewSpiderAdminServiceV2()
+	svcV2Once.Do(func() {
+		svcV2, err = newSpiderAdminServiceV2()
+		if err != nil {
+			log2.Errorf("[GetSpiderAdminServiceV2] error: %v", err)
+		}
+	})
 	if err != nil {
 		return nil, err
 	}
-
 	return svcV2, nil
 }

core/system/service_v2.go

@@ -4,6 +4,7 @@ import (
 	"github.com/crawlab-team/crawlab/core/models/models"
 	"github.com/crawlab-team/crawlab/core/models/service"
 	"go.mongodb.org/mongo-driver/bson"
+	"sync"
 )
 
 type ServiceV2 struct {
@@ -46,7 +47,7 @@ func (svc *ServiceV2) initData() (err error) {
 	return nil
 }
 
-func NewServiceV2() *ServiceV2 {
+func newSystemServiceV2() *ServiceV2 {
 	// service
 	svc := &ServiceV2{}
 
@@ -58,10 +59,14 @@ func NewServiceV2() *ServiceV2 {
 }
 
 var _serviceV2 *ServiceV2
+var _serviceV2Once = new(sync.Once)
 
-func GetServiceV2() *ServiceV2 {
+func GetSystemServiceV2() *ServiceV2 {
 	if _serviceV2 == nil {
-		_serviceV2 = NewServiceV2()
+		_serviceV2 = newSystemServiceV2()
 	}
+	_serviceV2Once.Do(func() {
+		_serviceV2 = newSystemServiceV2()
+	})
 	return _serviceV2
 }

core/task/handler/runner_v2.go

@@ -4,14 +4,14 @@ import (
 	"bufio"
 	"context"
 	"encoding/json"
+	"errors"
 	"fmt"
 	"github.com/apex/log"
 	"github.com/cenkalti/backoff/v4"
 	"github.com/crawlab-team/crawlab/core/constants"
-	"github.com/crawlab-team/crawlab/core/container"
 	"github.com/crawlab-team/crawlab/core/entity"
-	"github.com/crawlab-team/crawlab/core/errors"
 	fs2 "github.com/crawlab-team/crawlab/core/fs"
+	client2 "github.com/crawlab-team/crawlab/core/grpc/client"
 	"github.com/crawlab-team/crawlab/core/interfaces"
 	"github.com/crawlab-team/crawlab/core/models/client"
 	"github.com/crawlab-team/crawlab/core/models/models"
@@ -21,7 +21,6 @@ import (
 	grpc "github.com/crawlab-team/crawlab/grpc"
 	"github.com/crawlab-team/crawlab/trace"
 	"github.com/shirou/gopsutil/process"
-	"github.com/sirupsen/logrus"
 	"github.com/spf13/viper"
 	"go.mongodb.org/mongo-driver/bson"
 	"go.mongodb.org/mongo-driver/bson/primitive"
@@ -54,7 +53,7 @@ type RunnerV2 struct {
 	err  error                            // standard process error
 	envs []models.Env                     // environment variables
 	cwd  string                           // working directory
-	c    interfaces.GrpcClient            // grpc client
+	c    *client2.GrpcClientV2            // grpc client
 	sub  grpc.TaskService_SubscribeClient // grpc task service stream client
 
 	// log internals
@@ -181,7 +180,7 @@ func (r *RunnerV2) Cancel() (err error) {
 	// make sure the process does not exist
 	op := func() error {
 		if exists, _ := process.PidExists(int32(r.pid)); exists {
-			return errors.ErrorTaskProcessStillExists
+			return errors.New(fmt.Sprintf("task process %d still exists", r.pid))
 		}
 		return nil
 	}
@@ -189,7 +188,8 @@ func (r *RunnerV2) Cancel() (err error) {
 	defer cancel()
 	b := backoff.WithContext(backoff.NewConstantBackOff(1*time.Second), ctx)
 	if err := backoff.Retry(op, b); err != nil {
-		return trace.TraceError(errors.ErrorTaskUnableToCancel)
+		log.Errorf("Error canceling task %s: %v", r.tid, err)
+		return trace.TraceError(err)
 	}
 
 	return nil
@@ -362,7 +362,7 @@ func (r *RunnerV2) syncFiles() (err error) {
 		masterFilesMap[file.Path] = file
 	}
 
-	// create worker directory if not exists
+	// create working directory if not exists
 	if _, err := os.Stat(r.cwd); os.IsNotExist(err) {
 		if err := os.MkdirAll(r.cwd, os.ModePerm); err != nil {
 			log.Errorf("Error creating worker directory: %v", err)
@@ -377,10 +377,6 @@ func (r *RunnerV2) syncFiles() (err error) {
 		return trace.TraceError(err)
 	}
 
-	// set up wait group and error channel
-	var wg sync.WaitGroup
-	errCh := make(chan error, 1)
-
 	// delete files that are deleted on master node
 	for path, workerFile := range workerFiles {
 		if _, exists := masterFilesMap[path]; !exists {
@@ -392,50 +388,85 @@ func (r *RunnerV2) syncFiles() (err error) {
 		}
 	}
 
+	// set up wait group and error channel
+	var wg sync.WaitGroup
+	pool := make(chan struct{}, 10)
+
 	// download files that are new or modified on master node
 	for path, masterFile := range masterFilesMap {
 		workerFile, exists := workerFiles[path]
 		if !exists || masterFile.Hash != workerFile.Hash {
 			wg.Add(1)
-			go func(path string, masterFile entity.FsFileInfo) {
+
+			// acquire token
+			pool <- struct{}{}
+
+			// start goroutine to synchronize file or directory
+			go func(path string, masterFile *entity.FsFileInfo) {
 				defer wg.Done()
-				logrus.Infof("File needs to be synchronized: %s", path)
-				err := r.downloadFile(masterURL+"/download?path="+path, filepath.Join(r.cwd, path))
-				if err != nil {
-					logrus.Errorf("Error downloading file: %v", err)
-					select {
-					case errCh <- err:
-					default:
+
+				if masterFile.IsDir {
+					log.Infof("Directory needs to be synchronized: %s", path)
+					_err := os.MkdirAll(filepath.Join(r.cwd, path), masterFile.Mode)
+					if _err != nil {
+						log.Errorf("Error creating directory: %v", _err)
+						err = errors.Join(err, _err)
+					}
+				} else {
+					log.Infof("File needs to be synchronized: %s", path)
+					_err := r.downloadFile(masterURL+"/download?path="+path, filepath.Join(r.cwd, path), masterFile)
+					if _err != nil {
+						log.Errorf("Error downloading file: %v", _err)
+						err = errors.Join(err, _err)
 					}
 				}
-			}(path, masterFile)
+
+				// release token
+				<-pool
+
+			}(path, &masterFile)
 		}
 	}
 
+	// wait for all files and directories to be synchronized
 	wg.Wait()
-	close(errCh)
-	if err := <-errCh; err != nil {
-		return err
-	}
 
-	return nil
+	return err
 }
 
-func (r *RunnerV2) downloadFile(url string, filePath string) error {
+func (r *RunnerV2) downloadFile(url string, filePath string, fileInfo *entity.FsFileInfo) error {
+	// get file response
 	resp, err := http.Get(url)
 	if err != nil {
+		log.Errorf("Error getting file response: %v", err)
 		return err
 	}
 	defer resp.Body.Close()
 
-	out, err := os.Create(filePath)
+	// create directory if not exists
+	dirPath := filepath.Dir(filePath)
+	utils.Exists(dirPath)
+	err = os.MkdirAll(dirPath, os.ModePerm)
 	if err != nil {
+		log.Errorf("Error creating directory: %v", err)
+		return err
+	}
+
+	// create local file
+	out, err := os.OpenFile(filePath, os.O_RDWR|os.O_CREATE|os.O_TRUNC, fileInfo.Mode)
+	if err != nil {
+		log.Errorf("Error creating file: %v", err)
 		return err
 	}
 	defer out.Close()
 
+	// copy file content to local file
 	_, err = io.Copy(out, resp.Body)
-	return err
+	if err != nil {
+		log.Errorf("Error copying file: %v", err)
+		return err
+	}
+	return nil
 }
 
 // wait for process to finish and send task signal (constants.TaskSignal)
@@ -443,7 +474,8 @@ func (r *RunnerV2) downloadFile(url string, filePath string) error {
 func (r *RunnerV2) wait() {
 	// wait for process to finish
 	if err := r.cmd.Wait(); err != nil {
-		exitError, ok := err.(*exec.ExitError)
+		var exitError *exec.ExitError
+		ok := errors.As(err, &exitError)
 		if !ok {
 			r.ch <- constants.TaskSignalError
 			return
@@ -505,7 +537,7 @@ func (r *RunnerV2) updateTask(status string, e error) (err error) {
 }
 
 func (r *RunnerV2) initSub() (err error) {
-	r.sub, err = r.c.GetTaskClient().Subscribe(context.Background())
+	r.sub, err = r.c.TaskClient.Subscribe(context.Background())
 	if err != nil {
 		return trace.TraceError(err)
 	}
@@ -577,7 +609,7 @@ func (r *RunnerV2) sendNotification() {
 		NodeKey: r.svc.GetNodeConfigService().GetNodeKey(),
 		Data:    data,
 	}
-	_, err = r.c.GetTaskClient().SendNotification(context.Background(), req)
+	_, err = r.c.TaskClient.SendNotification(context.Background(), req)
 	if err != nil {
 		trace.PrintError(err)
 		return
@@ -617,7 +649,8 @@ func (r *RunnerV2) _updateSpiderStat(status string) {
 			},
 		}
 	default:
-		trace.PrintError(errors.ErrorTaskInvalidType)
+		log.Errorf("Invalid task status: %s", status)
+		trace.PrintError(errors.New("invalid task status"))
 		return
 	}
 
@@ -679,14 +712,8 @@ func NewTaskRunnerV2(id primitive.ObjectID, svc *ServiceV2) (r2 *RunnerV2, err e
 	// task fs service
 	r.fsSvc = fs2.NewFsServiceV2(filepath.Join(viper.GetString("workspace"), r.s.Id.Hex()))
 
-	// dependency injection
-	if err := container.GetContainer().Invoke(func(
-		c interfaces.GrpcClient,
-	) {
-		r.c = c
-	}); err != nil {
-		return nil, trace.TraceError(err)
-	}
+	// grpc client
+	r.c = client2.GetGrpcClientV2()
 
 	// initialize task runner
 	if err := r.Init(); err != nil {

core/task/handler/service_v2.go

@@ -74,9 +74,10 @@ func (svc *ServiceV2) Cancel(taskId primitive.ObjectID) (err error) {
 }
 
 func (svc *ServiceV2) Fetch() {
+	ticker := time.NewTicker(svc.fetchInterval)
 	for {
 		// wait
-		time.Sleep(svc.fetchInterval)
+		<-ticker.C
 
 		// current node
 		n, err := svc.GetCurrentNode()
@@ -96,6 +97,7 @@ func (svc *ServiceV2) Fetch() {
 
 		// stop
 		if svc.stopped {
+			ticker.Stop()
 			return
 		}
 
@@ -115,10 +117,11 @@ func (svc *ServiceV2) Fetch() {
 		if err := svc.run(tid); err != nil {
 			trace.PrintError(err)
 			t, err := svc.GetTaskById(tid)
-			if err == nil && t.Status != constants.TaskStatusCancelled {
+			if err != nil && t.Status != constants.TaskStatusCancelled {
 				t.Error = err.Error()
 				t.Status = constants.TaskStatusError
 				t.SetUpdated(t.CreatedBy)
+				_ = client.NewModelServiceV2[models.TaskV2]().ReplaceById(t.Id, *t)
 				continue
 			}
 			continue
@@ -388,7 +391,7 @@ func (svc *ServiceV2) run(taskId primitive.ObjectID) (err error) {
 	return nil
 }
 
-func NewTaskHandlerServiceV2() (svc2 *ServiceV2, err error) {
+func newTaskHandlerServiceV2() (svc2 *ServiceV2, err error) {
 	// service
 	svc := &ServiceV2{
 		exitWatchDuration: 60 * time.Second,
@@ -413,12 +416,18 @@ func NewTaskHandlerServiceV2() (svc2 *ServiceV2, err error) {
 }
 
 var _serviceV2 *ServiceV2
+var _serviceV2Once = new(sync.Once)
 
 func GetTaskHandlerServiceV2() (svr *ServiceV2, err error) {
 	if _serviceV2 != nil {
 		return _serviceV2, nil
 	}
-	_serviceV2, err = NewTaskHandlerServiceV2()
+	_serviceV2Once.Do(func() {
+		_serviceV2, err = newTaskHandlerServiceV2()
+		if err != nil {
+			log.Errorf("failed to create task handler service: %v", err)
+		}
+	})
 	if err != nil {
 		return nil, err
 	}

core/task/scheduler/service_v2.go

@@ -2,12 +2,15 @@ package scheduler
 
 import (
 	errors2 "errors"
+	"github.com/apex/log"
 	"github.com/crawlab-team/crawlab/core/constants"
-	"github.com/crawlab-team/crawlab/core/container"
 	"github.com/crawlab-team/crawlab/core/errors"
+	"github.com/crawlab-team/crawlab/core/grpc/server"
 	"github.com/crawlab-team/crawlab/core/interfaces"
 	"github.com/crawlab-team/crawlab/core/models/models"
 	"github.com/crawlab-team/crawlab/core/models/service"
+	nodeconfig "github.com/crawlab-team/crawlab/core/node/config"
+	"github.com/crawlab-team/crawlab/core/task/handler"
 	"github.com/crawlab-team/crawlab/core/utils"
 	grpc "github.com/crawlab-team/crawlab/grpc"
 	"github.com/crawlab-team/crawlab/trace"
@@ -20,8 +23,8 @@ import (
 type ServiceV2 struct {
 	// dependencies
 	nodeCfgSvc interfaces.NodeConfigService
-	svr        interfaces.GrpcServer
-	handlerSvc interfaces.TaskHandlerService
+	svr        *server.GrpcServerV2
+	handlerSvc *handler.ServiceV2
 
 	// settings
 	interval time.Duration
@@ -233,17 +236,15 @@ func NewTaskSchedulerServiceV2() (svc2 *ServiceV2, err error) {
 	svc := &ServiceV2{
 		interval: 5 * time.Second,
 	}
-
-	// dependency injection
-	if err := container.GetContainer().Invoke(func(
-		nodeCfgSvc interfaces.NodeConfigService,
-		svr interfaces.GrpcServer,
-		handlerSvc interfaces.TaskHandlerService,
-	) {
-		svc.nodeCfgSvc = nodeCfgSvc
-		svc.svr = svr
-		svc.handlerSvc = handlerSvc
-	}); err != nil {
+	svc.nodeCfgSvc = nodeconfig.GetNodeConfigService()
+	svc.svr, err = server.GetGrpcServerV2()
+	if err != nil {
+		log.Errorf("failed to get grpc server: %v", err)
+		return nil, err
+	}
+	svc.handlerSvc, err = handler.GetTaskHandlerServiceV2()
+	if err != nil {
+		log.Errorf("failed to get task handler service: %v", err)
 		return nil, err
 	}
 

core/utils/file.go

@@ -348,13 +348,13 @@ func ScanDirectory(dir string) (res map[string]entity.FsFileInfo, err error) {
 		if err != nil {
 			return err
 		}
-		if info.IsDir() {
-			return nil
-		}
 
-		hash, err := GetFileHash(path)
-		if err != nil {
-			return err
+		var hash string
+		if !info.IsDir() {
+			hash, err = GetFileHash(path)
+			if err != nil {
+				return err
+			}
 		}
 
 		relPath, err := filepath.Rel(dir, path)
@@ -367,6 +367,7 @@ func ScanDirectory(dir string) (res map[string]entity.FsFileInfo, err error) {
 			Path:      relPath,
 			FullPath:  path,
 			Extension: filepath.Ext(path),
+			IsDir:     info.IsDir(),
 			FileSize:  info.Size(),
 			ModTime:   info.ModTime(),
 			Mode:      info.Mode(),

grpc/bin/compile.sh

@@ -8,30 +8,8 @@ else
 fi
 base_path=$(cd $BASE_DIR/..; pwd)
 
-cd $base_path && \
-  rm -rf dist | true
-
-cd $base_path && \
-  mkdir -p dist/python | true && \
-  mkdir -p dist/js | true && \
-  mkdir -p dist/ts | true && \
-  mkdir -p dist/java | true && \
-  mkdir -p dist/csharp | true && \
-  mkdir -p dist/php | true && \
-  mkdir -p dist/ruby | true
-
 cd $base_path && \
   protoc -I ./proto \
   --go_out=. \
   --go-grpc_out=. \
-  --python_out=dist/python \
-  --js_out=dist/js \
-  --java_out=dist/java \
-  --csharp_out=dist/csharp \
-  ./proto/**/*.proto
-
-# python
-cd $base_path && \
-  python3 -m grpc_tools.protoc -I ./proto \
-  --grpc_python_out=dist/python \
-  ./proto/**/*.proto
+  ./proto/**/*.proto

grpc/bin/compile_all.sh

@@ -0,0 +1,37 @@
+#!/bin/bash
+
+if [ -L $0 ]
+then
+    BASE_DIR=`dirname $(readlink $0)`
+else
+    BASE_DIR=`dirname $0`
+fi
+base_path=$(cd $BASE_DIR/..; pwd)
+
+cd $base_path && \
+  rm -rf dist | true
+
+cd $base_path && \
+  mkdir -p dist/python | true && \
+  mkdir -p dist/js | true && \
+  mkdir -p dist/ts | true && \
+  mkdir -p dist/java | true && \
+  mkdir -p dist/csharp | true && \
+  mkdir -p dist/php | true && \
+  mkdir -p dist/ruby | true
+
+cd $base_path && \
+  protoc -I ./proto \
+  --go_out=. \
+  --go-grpc_out=. \
+  --python_out=dist/python \
+  --js_out=dist/js \
+  --java_out=dist/java \
+  --csharp_out=dist/csharp \
+  ./proto/**/*.proto
+
+# python
+cd $base_path && \
+  python3 -m grpc_tools.protoc -I ./proto \
+  --grpc_python_out=dist/python \
+  ./proto/**/*.proto

grpc/dependencies_service_v2_grpc.pb.go

@@ -1,6 +1,6 @@
 // Code generated by protoc-gen-go-grpc. DO NOT EDIT.
 // versions:
-// - protoc-gen-go-grpc v1.2.0
+// - protoc-gen-go-grpc v1.4.0
 // - protoc             v5.27.2
 // source: services/dependencies_service_v2.proto
 
@@ -15,8 +15,14 @@ import (
 
 // This is a compile-time assertion to ensure that this generated file
 // is compatible with the grpc package it is being compiled against.
-// Requires gRPC-Go v1.32.0 or later.
-const _ = grpc.SupportPackageIsVersion7
+// Requires gRPC-Go v1.62.0 or later.
+const _ = grpc.SupportPackageIsVersion8
+
+const (
+	DependenciesServiceV2_Connect_FullMethodName       = "/grpc.DependenciesServiceV2/Connect"
+	DependenciesServiceV2_Sync_FullMethodName          = "/grpc.DependenciesServiceV2/Sync"
+	DependenciesServiceV2_UpdateTaskLog_FullMethodName = "/grpc.DependenciesServiceV2/UpdateTaskLog"
+)
 
 // DependenciesServiceV2Client is the client API for DependenciesServiceV2 service.
 //
@@ -36,11 +42,12 @@ func NewDependenciesServiceV2Client(cc grpc.ClientConnInterface) DependenciesSer
 }
 
 func (c *dependenciesServiceV2Client) Connect(ctx context.Context, in *DependenciesServiceV2ConnectRequest, opts ...grpc.CallOption) (DependenciesServiceV2_ConnectClient, error) {
-	stream, err := c.cc.NewStream(ctx, &DependenciesServiceV2_ServiceDesc.Streams[0], "/grpc.DependenciesServiceV2/Connect", opts...)
+	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
+	stream, err := c.cc.NewStream(ctx, &DependenciesServiceV2_ServiceDesc.Streams[0], DependenciesServiceV2_Connect_FullMethodName, cOpts...)
 	if err != nil {
 		return nil, err
 	}
-	x := &dependenciesServiceV2ConnectClient{stream}
+	x := &dependenciesServiceV2ConnectClient{ClientStream: stream}
 	if err := x.ClientStream.SendMsg(in); err != nil {
 		return nil, err
 	}
@@ -68,8 +75,9 @@ func (x *dependenciesServiceV2ConnectClient) Recv() (*DependenciesServiceV2Conne
 }
 
 func (c *dependenciesServiceV2Client) Sync(ctx context.Context, in *DependenciesServiceV2SyncRequest, opts ...grpc.CallOption) (*Response, error) {
+	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
 	out := new(Response)
-	err := c.cc.Invoke(ctx, "/grpc.DependenciesServiceV2/Sync", in, out, opts...)
+	err := c.cc.Invoke(ctx, DependenciesServiceV2_Sync_FullMethodName, in, out, cOpts...)
 	if err != nil {
 		return nil, err
 	}
@@ -77,11 +85,12 @@ func (c *dependenciesServiceV2Client) Sync(ctx context.Context, in *Dependencies
 }
 
 func (c *dependenciesServiceV2Client) UpdateTaskLog(ctx context.Context, opts ...grpc.CallOption) (DependenciesServiceV2_UpdateTaskLogClient, error) {
-	stream, err := c.cc.NewStream(ctx, &DependenciesServiceV2_ServiceDesc.Streams[1], "/grpc.DependenciesServiceV2/UpdateTaskLog", opts...)
+	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
+	stream, err := c.cc.NewStream(ctx, &DependenciesServiceV2_ServiceDesc.Streams[1], DependenciesServiceV2_UpdateTaskLog_FullMethodName, cOpts...)
 	if err != nil {
 		return nil, err
 	}
-	x := &dependenciesServiceV2UpdateTaskLogClient{stream}
+	x := &dependenciesServiceV2UpdateTaskLogClient{ClientStream: stream}
 	return x, nil
 }
 
@@ -151,7 +160,7 @@ func _DependenciesServiceV2_Connect_Handler(srv interface{}, stream grpc.ServerS
 	if err := stream.RecvMsg(m); err != nil {
 		return err
 	}
-	return srv.(DependenciesServiceV2Server).Connect(m, &dependenciesServiceV2ConnectServer{stream})
+	return srv.(DependenciesServiceV2Server).Connect(m, &dependenciesServiceV2ConnectServer{ServerStream: stream})
 }
 
 type DependenciesServiceV2_ConnectServer interface {
@@ -177,7 +186,7 @@ func _DependenciesServiceV2_Sync_Handler(srv interface{}, ctx context.Context, d
 	}
 	info := &grpc.UnaryServerInfo{
 		Server:     srv,
-		FullMethod: "/grpc.DependenciesServiceV2/Sync",
+		FullMethod: DependenciesServiceV2_Sync_FullMethodName,
 	}
 	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
 		return srv.(DependenciesServiceV2Server).Sync(ctx, req.(*DependenciesServiceV2SyncRequest))
@@ -186,7 +195,7 @@ func _DependenciesServiceV2_Sync_Handler(srv interface{}, ctx context.Context, d
 }
 
 func _DependenciesServiceV2_UpdateTaskLog_Handler(srv interface{}, stream grpc.ServerStream) error {
-	return srv.(DependenciesServiceV2Server).UpdateTaskLog(&dependenciesServiceV2UpdateTaskLogServer{stream})
+	return srv.(DependenciesServiceV2Server).UpdateTaskLog(&dependenciesServiceV2UpdateTaskLogServer{ServerStream: stream})
 }
 
 type DependenciesServiceV2_UpdateTaskLogServer interface {

grpc/message_service_grpc.pb.go

@@ -1,6 +1,6 @@
 // Code generated by protoc-gen-go-grpc. DO NOT EDIT.
 // versions:
-// - protoc-gen-go-grpc v1.2.0
+// - protoc-gen-go-grpc v1.4.0
 // - protoc             v5.27.2
 // source: services/message_service.proto
 
@@ -15,8 +15,12 @@ import (
 
 // This is a compile-time assertion to ensure that this generated file
 // is compatible with the grpc package it is being compiled against.
-// Requires gRPC-Go v1.32.0 or later.
-const _ = grpc.SupportPackageIsVersion7
+// Requires gRPC-Go v1.62.0 or later.
+const _ = grpc.SupportPackageIsVersion8
+
+const (
+	MessageService_Connect_FullMethodName = "/grpc.MessageService/Connect"
+)
 
 // MessageServiceClient is the client API for MessageService service.
 //
@@ -34,11 +38,12 @@ func NewMessageServiceClient(cc grpc.ClientConnInterface) MessageServiceClient {
 }
 
 func (c *messageServiceClient) Connect(ctx context.Context, opts ...grpc.CallOption) (MessageService_ConnectClient, error) {
-	stream, err := c.cc.NewStream(ctx, &MessageService_ServiceDesc.Streams[0], "/grpc.MessageService/Connect", opts...)
+	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
+	stream, err := c.cc.NewStream(ctx, &MessageService_ServiceDesc.Streams[0], MessageService_Connect_FullMethodName, cOpts...)
 	if err != nil {
 		return nil, err
 	}
-	x := &messageServiceConnectClient{stream}
+	x := &messageServiceConnectClient{ClientStream: stream}
 	return x, nil
 }
 
@@ -93,7 +98,7 @@ func RegisterMessageServiceServer(s grpc.ServiceRegistrar, srv MessageServiceSer
 }
 
 func _MessageService_Connect_Handler(srv interface{}, stream grpc.ServerStream) error {
-	return srv.(MessageServiceServer).Connect(&messageServiceConnectServer{stream})
+	return srv.(MessageServiceServer).Connect(&messageServiceConnectServer{ServerStream: stream})
 }
 
 type MessageService_ConnectServer interface {

grpc/metrics_service_v2_grpc.pb.go

@@ -1,6 +1,6 @@
 // Code generated by protoc-gen-go-grpc. DO NOT EDIT.
 // versions:
-// - protoc-gen-go-grpc v1.2.0
+// - protoc-gen-go-grpc v1.4.0
 // - protoc             v5.27.2
 // source: services/metrics_service_v2.proto
 
@@ -15,8 +15,12 @@ import (
 
 // This is a compile-time assertion to ensure that this generated file
 // is compatible with the grpc package it is being compiled against.
-// Requires gRPC-Go v1.32.0 or later.
-const _ = grpc.SupportPackageIsVersion7
+// Requires gRPC-Go v1.62.0 or later.
+const _ = grpc.SupportPackageIsVersion8
+
+const (
+	MetricsServiceV2_Connect_FullMethodName = "/grpc.MetricsServiceV2/Connect"
+)
 
 // MetricsServiceV2Client is the client API for MetricsServiceV2 service.
 //
@@ -34,11 +38,12 @@ func NewMetricsServiceV2Client(cc grpc.ClientConnInterface) MetricsServiceV2Clie
 }
 
 func (c *metricsServiceV2Client) Connect(ctx context.Context, opts ...grpc.CallOption) (MetricsServiceV2_ConnectClient, error) {
-	stream, err := c.cc.NewStream(ctx, &MetricsServiceV2_ServiceDesc.Streams[0], "/grpc.MetricsServiceV2/Connect", opts...)
+	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
+	stream, err := c.cc.NewStream(ctx, &MetricsServiceV2_ServiceDesc.Streams[0], MetricsServiceV2_Connect_FullMethodName, cOpts...)
 	if err != nil {
 		return nil, err
 	}
-	x := &metricsServiceV2ConnectClient{stream}
+	x := &metricsServiceV2ConnectClient{ClientStream: stream}
 	return x, nil
 }
 
@@ -93,7 +98,7 @@ func RegisterMetricsServiceV2Server(s grpc.ServiceRegistrar, srv MetricsServiceV
 }
 
 func _MetricsServiceV2_Connect_Handler(srv interface{}, stream grpc.ServerStream) error {
-	return srv.(MetricsServiceV2Server).Connect(&metricsServiceV2ConnectServer{stream})
+	return srv.(MetricsServiceV2Server).Connect(&metricsServiceV2ConnectServer{ServerStream: stream})
 }
 
 type MetricsServiceV2_ConnectServer interface {

grpc/model_base_service_grpc.pb.go

@@ -1,6 +1,6 @@
 // Code generated by protoc-gen-go-grpc. DO NOT EDIT.
 // versions:
-// - protoc-gen-go-grpc v1.2.0
+// - protoc-gen-go-grpc v1.4.0
 // - protoc             v5.27.2
 // source: services/model_base_service.proto
 
@@ -15,8 +15,23 @@ import (
 
 // This is a compile-time assertion to ensure that this generated file
 // is compatible with the grpc package it is being compiled against.
-// Requires gRPC-Go v1.32.0 or later.
-const _ = grpc.SupportPackageIsVersion7
+// Requires gRPC-Go v1.62.0 or later.
+const _ = grpc.SupportPackageIsVersion8
+
+const (
+	ModelBaseService_GetById_FullMethodName         = "/grpc.ModelBaseService/GetById"
+	ModelBaseService_Get_FullMethodName             = "/grpc.ModelBaseService/Get"
+	ModelBaseService_GetList_FullMethodName         = "/grpc.ModelBaseService/GetList"
+	ModelBaseService_DeleteById_FullMethodName      = "/grpc.ModelBaseService/DeleteById"
+	ModelBaseService_Delete_FullMethodName          = "/grpc.ModelBaseService/Delete"
+	ModelBaseService_DeleteList_FullMethodName      = "/grpc.ModelBaseService/DeleteList"
+	ModelBaseService_ForceDeleteList_FullMethodName = "/grpc.ModelBaseService/ForceDeleteList"
+	ModelBaseService_UpdateById_FullMethodName      = "/grpc.ModelBaseService/UpdateById"
+	ModelBaseService_Update_FullMethodName          = "/grpc.ModelBaseService/Update"
+	ModelBaseService_UpdateDoc_FullMethodName       = "/grpc.ModelBaseService/UpdateDoc"
+	ModelBaseService_Insert_FullMethodName          = "/grpc.ModelBaseService/Insert"
+	ModelBaseService_Count_FullMethodName           = "/grpc.ModelBaseService/Count"
+)
 
 // ModelBaseServiceClient is the client API for ModelBaseService service.
 //
@@ -45,8 +60,9 @@ func NewModelBaseServiceClient(cc grpc.ClientConnInterface) ModelBaseServiceClie
 }
 
 func (c *modelBaseServiceClient) GetById(ctx context.Context, in *Request, opts ...grpc.CallOption) (*Response, error) {
+	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
 	out := new(Response)
-	err := c.cc.Invoke(ctx, "/grpc.ModelBaseService/GetById", in, out, opts...)
+	err := c.cc.Invoke(ctx, ModelBaseService_GetById_FullMethodName, in, out, cOpts...)
 	if err != nil {
 		return nil, err
 	}
@@ -54,8 +70,9 @@ func (c *modelBaseServiceClient) GetById(ctx context.Context, in *Request, opts
 }
 
 func (c *modelBaseServiceClient) Get(ctx context.Context, in *Request, opts ...grpc.CallOption) (*Response, error) {
+	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
 	out := new(Response)
-	err := c.cc.Invoke(ctx, "/grpc.ModelBaseService/Get", in, out, opts...)
+	err := c.cc.Invoke(ctx, ModelBaseService_Get_FullMethodName, in, out, cOpts...)
 	if err != nil {
 		return nil, err
 	}
@@ -63,8 +80,9 @@ func (c *modelBaseServiceClient) Get(ctx context.Context, in *Request, opts ...g
 }
 
 func (c *modelBaseServiceClient) GetList(ctx context.Context, in *Request, opts ...grpc.CallOption) (*Response, error) {
+	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
 	out := new(Response)
-	err := c.cc.Invoke(ctx, "/grpc.ModelBaseService/GetList", in, out, opts...)
+	err := c.cc.Invoke(ctx, ModelBaseService_GetList_FullMethodName, in, out, cOpts...)
 	if err != nil {
 		return nil, err
 	}
@@ -72,8 +90,9 @@ func (c *modelBaseServiceClient) GetList(ctx context.Context, in *Request, opts
 }
 
 func (c *modelBaseServiceClient) DeleteById(ctx context.Context, in *Request, opts ...grpc.CallOption) (*Response, error) {
+	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
 	out := new(Response)
-	err := c.cc.Invoke(ctx, "/grpc.ModelBaseService/DeleteById", in, out, opts...)
+	err := c.cc.Invoke(ctx, ModelBaseService_DeleteById_FullMethodName, in, out, cOpts...)
 	if err != nil {
 		return nil, err
 	}
@@ -81,8 +100,9 @@ func (c *modelBaseServiceClient) DeleteById(ctx context.Context, in *Request, op
 }
 
 func (c *modelBaseServiceClient) Delete(ctx context.Context, in *Request, opts ...grpc.CallOption) (*Response, error) {
+	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
 	out := new(Response)
-	err := c.cc.Invoke(ctx, "/grpc.ModelBaseService/Delete", in, out, opts...)
+	err := c.cc.Invoke(ctx, ModelBaseService_Delete_FullMethodName, in, out, cOpts...)
 	if err != nil {
 		return nil, err
 	}
@@ -90,8 +110,9 @@ func (c *modelBaseServiceClient) Delete(ctx context.Context, in *Request, opts .
 }
 
 func (c *modelBaseServiceClient) DeleteList(ctx context.Context, in *Request, opts ...grpc.CallOption) (*Response, error) {
+	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
 	out := new(Response)
-	err := c.cc.Invoke(ctx, "/grpc.ModelBaseService/DeleteList", in, out, opts...)
+	err := c.cc.Invoke(ctx, ModelBaseService_DeleteList_FullMethodName, in, out, cOpts...)
 	if err != nil {
 		return nil, err
 	}
@@ -99,8 +120,9 @@ func (c *modelBaseServiceClient) DeleteList(ctx context.Context, in *Request, op
 }
 
 func (c *modelBaseServiceClient) ForceDeleteList(ctx context.Context, in *Request, opts ...grpc.CallOption) (*Response, error) {
+	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
 	out := new(Response)
-	err := c.cc.Invoke(ctx, "/grpc.ModelBaseService/ForceDeleteList", in, out, opts...)
+	err := c.cc.Invoke(ctx, ModelBaseService_ForceDeleteList_FullMethodName, in, out, cOpts...)
 	if err != nil {
 		return nil, err
 	}
@@ -108,8 +130,9 @@ func (c *modelBaseServiceClient) ForceDeleteList(ctx context.Context, in *Reques
 }
 
 func (c *modelBaseServiceClient) UpdateById(ctx context.Context, in *Request, opts ...grpc.CallOption) (*Response, error) {
+	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
 	out := new(Response)
-	err := c.cc.Invoke(ctx, "/grpc.ModelBaseService/UpdateById", in, out, opts...)
+	err := c.cc.Invoke(ctx, ModelBaseService_UpdateById_FullMethodName, in, out, cOpts...)
 	if err != nil {
 		return nil, err
 	}
@@ -117,8 +140,9 @@ func (c *modelBaseServiceClient) UpdateById(ctx context.Context, in *Request, op
 }
 
 func (c *modelBaseServiceClient) Update(ctx context.Context, in *Request, opts ...grpc.CallOption) (*Response, error) {
+	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
 	out := new(Response)
-	err := c.cc.Invoke(ctx, "/grpc.ModelBaseService/Update", in, out, opts...)
+	err := c.cc.Invoke(ctx, ModelBaseService_Update_FullMethodName, in, out, cOpts...)
 	if err != nil {
 		return nil, err
 	}
@@ -126,8 +150,9 @@ func (c *modelBaseServiceClient) Update(ctx context.Context, in *Request, opts .
 }
 
 func (c *modelBaseServiceClient) UpdateDoc(ctx context.Context, in *Request, opts ...grpc.CallOption) (*Response, error) {
+	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
 	out := new(Response)
-	err := c.cc.Invoke(ctx, "/grpc.ModelBaseService/UpdateDoc", in, out, opts...)
+	err := c.cc.Invoke(ctx, ModelBaseService_UpdateDoc_FullMethodName, in, out, cOpts...)
 	if err != nil {
 		return nil, err
 	}
@@ -135,8 +160,9 @@ func (c *modelBaseServiceClient) UpdateDoc(ctx context.Context, in *Request, opt
 }
 
 func (c *modelBaseServiceClient) Insert(ctx context.Context, in *Request, opts ...grpc.CallOption) (*Response, error) {
+	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
 	out := new(Response)
-	err := c.cc.Invoke(ctx, "/grpc.ModelBaseService/Insert", in, out, opts...)
+	err := c.cc.Invoke(ctx, ModelBaseService_Insert_FullMethodName, in, out, cOpts...)
 	if err != nil {
 		return nil, err
 	}
@@ -144,8 +170,9 @@ func (c *modelBaseServiceClient) Insert(ctx context.Context, in *Request, opts .
 }
 
 func (c *modelBaseServiceClient) Count(ctx context.Context, in *Request, opts ...grpc.CallOption) (*Response, error) {
+	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
 	out := new(Response)
-	err := c.cc.Invoke(ctx, "/grpc.ModelBaseService/Count", in, out, opts...)
+	err := c.cc.Invoke(ctx, ModelBaseService_Count_FullMethodName, in, out, cOpts...)
 	if err != nil {
 		return nil, err
 	}
@@ -234,7 +261,7 @@ func _ModelBaseService_GetById_Handler(srv interface{}, ctx context.Context, dec
 	}
 	info := &grpc.UnaryServerInfo{
 		Server:     srv,
-		FullMethod: "/grpc.ModelBaseService/GetById",
+		FullMethod: ModelBaseService_GetById_FullMethodName,
 	}
 	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
 		return srv.(ModelBaseServiceServer).GetById(ctx, req.(*Request))
@@ -252,7 +279,7 @@ func _ModelBaseService_Get_Handler(srv interface{}, ctx context.Context, dec fun
 	}
 	info := &grpc.UnaryServerInfo{
 		Server:     srv,
-		FullMethod: "/grpc.ModelBaseService/Get",
+		FullMethod: ModelBaseService_Get_FullMethodName,
 	}
 	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
 		return srv.(ModelBaseServiceServer).Get(ctx, req.(*Request))
@@ -270,7 +297,7 @@ func _ModelBaseService_GetList_Handler(srv interface{}, ctx context.Context, dec
 	}
 	info := &grpc.UnaryServerInfo{
 		Server:     srv,
-		FullMethod: "/grpc.ModelBaseService/GetList",
+		FullMethod: ModelBaseService_GetList_FullMethodName,
 	}
 	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
 		return srv.(ModelBaseServiceServer).GetList(ctx, req.(*Request))
@@ -288,7 +315,7 @@ func _ModelBaseService_DeleteById_Handler(srv interface{}, ctx context.Context,
 	}
 	info := &grpc.UnaryServerInfo{
 		Server:     srv,
-		FullMethod: "/grpc.ModelBaseService/DeleteById",
+		FullMethod: ModelBaseService_DeleteById_FullMethodName,
 	}
 	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
 		return srv.(ModelBaseServiceServer).DeleteById(ctx, req.(*Request))
@@ -306,7 +333,7 @@ func _ModelBaseService_Delete_Handler(srv interface{}, ctx context.Context, dec
 	}
 	info := &grpc.UnaryServerInfo{
 		Server:     srv,
-		FullMethod: "/grpc.ModelBaseService/Delete",
+		FullMethod: ModelBaseService_Delete_FullMethodName,
 	}
 	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
 		return srv.(ModelBaseServiceServer).Delete(ctx, req.(*Request))
@@ -324,7 +351,7 @@ func _ModelBaseService_DeleteList_Handler(srv interface{}, ctx context.Context,
 	}
 	info := &grpc.UnaryServerInfo{
 		Server:     srv,
-		FullMethod: "/grpc.ModelBaseService/DeleteList",
+		FullMethod: ModelBaseService_DeleteList_FullMethodName,
 	}
 	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
 		return srv.(ModelBaseServiceServer).DeleteList(ctx, req.(*Request))
@@ -342,7 +369,7 @@ func _ModelBaseService_ForceDeleteList_Handler(srv interface{}, ctx context.Cont
 	}
 	info := &grpc.UnaryServerInfo{
 		Server:     srv,
-		FullMethod: "/grpc.ModelBaseService/ForceDeleteList",
+		FullMethod: ModelBaseService_ForceDeleteList_FullMethodName,
 	}
 	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
 		return srv.(ModelBaseServiceServer).ForceDeleteList(ctx, req.(*Request))
@@ -360,7 +387,7 @@ func _ModelBaseService_UpdateById_Handler(srv interface{}, ctx context.Context,
 	}
 	info := &grpc.UnaryServerInfo{
 		Server:     srv,
-		FullMethod: "/grpc.ModelBaseService/UpdateById",
+		FullMethod: ModelBaseService_UpdateById_FullMethodName,
 	}
 	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
 		return srv.(ModelBaseServiceServer).UpdateById(ctx, req.(*Request))
@@ -378,7 +405,7 @@ func _ModelBaseService_Update_Handler(srv interface{}, ctx context.Context, dec
 	}
 	info := &grpc.UnaryServerInfo{
 		Server:     srv,
-		FullMethod: "/grpc.ModelBaseService/Update",
+		FullMethod: ModelBaseService_Update_FullMethodName,
 	}
 	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
 		return srv.(ModelBaseServiceServer).Update(ctx, req.(*Request))
@@ -396,7 +423,7 @@ func _ModelBaseService_UpdateDoc_Handler(srv interface{}, ctx context.Context, d
 	}
 	info := &grpc.UnaryServerInfo{
 		Server:     srv,
-		FullMethod: "/grpc.ModelBaseService/UpdateDoc",
+		FullMethod: ModelBaseService_UpdateDoc_FullMethodName,
 	}
 	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
 		return srv.(ModelBaseServiceServer).UpdateDoc(ctx, req.(*Request))
@@ -414,7 +441,7 @@ func _ModelBaseService_Insert_Handler(srv interface{}, ctx context.Context, dec
 	}
 	info := &grpc.UnaryServerInfo{
 		Server:     srv,
-		FullMethod: "/grpc.ModelBaseService/Insert",
+		FullMethod: ModelBaseService_Insert_FullMethodName,
 	}
 	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
 		return srv.(ModelBaseServiceServer).Insert(ctx, req.(*Request))
@@ -432,7 +459,7 @@ func _ModelBaseService_Count_Handler(srv interface{}, ctx context.Context, dec f
 	}
 	info := &grpc.UnaryServerInfo{
 		Server:     srv,
-		FullMethod: "/grpc.ModelBaseService/Count",
+		FullMethod: ModelBaseService_Count_FullMethodName,
 	}
 	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
 		return srv.(ModelBaseServiceServer).Count(ctx, req.(*Request))

grpc/model_base_service_v2_grpc.pb.go

@@ -1,6 +1,6 @@
 // Code generated by protoc-gen-go-grpc. DO NOT EDIT.
 // versions:
-// - protoc-gen-go-grpc v1.2.0
+// - protoc-gen-go-grpc v1.4.0
 // - protoc             v5.27.2
 // source: services/model_base_service_v2.proto
 
@@ -15,8 +15,25 @@ import (
 
 // This is a compile-time assertion to ensure that this generated file
 // is compatible with the grpc package it is being compiled against.
-// Requires gRPC-Go v1.32.0 or later.
-const _ = grpc.SupportPackageIsVersion7
+// Requires gRPC-Go v1.62.0 or later.
+const _ = grpc.SupportPackageIsVersion8
+
+const (
+	ModelBaseServiceV2_GetById_FullMethodName     = "/grpc.ModelBaseServiceV2/GetById"
+	ModelBaseServiceV2_GetOne_FullMethodName      = "/grpc.ModelBaseServiceV2/GetOne"
+	ModelBaseServiceV2_GetMany_FullMethodName     = "/grpc.ModelBaseServiceV2/GetMany"
+	ModelBaseServiceV2_DeleteById_FullMethodName  = "/grpc.ModelBaseServiceV2/DeleteById"
+	ModelBaseServiceV2_DeleteOne_FullMethodName   = "/grpc.ModelBaseServiceV2/DeleteOne"
+	ModelBaseServiceV2_DeleteMany_FullMethodName  = "/grpc.ModelBaseServiceV2/DeleteMany"
+	ModelBaseServiceV2_UpdateById_FullMethodName  = "/grpc.ModelBaseServiceV2/UpdateById"
+	ModelBaseServiceV2_UpdateOne_FullMethodName   = "/grpc.ModelBaseServiceV2/UpdateOne"
+	ModelBaseServiceV2_UpdateMany_FullMethodName  = "/grpc.ModelBaseServiceV2/UpdateMany"
+	ModelBaseServiceV2_ReplaceById_FullMethodName = "/grpc.ModelBaseServiceV2/ReplaceById"
+	ModelBaseServiceV2_ReplaceOne_FullMethodName  = "/grpc.ModelBaseServiceV2/ReplaceOne"
+	ModelBaseServiceV2_InsertOne_FullMethodName   = "/grpc.ModelBaseServiceV2/InsertOne"
+	ModelBaseServiceV2_InsertMany_FullMethodName  = "/grpc.ModelBaseServiceV2/InsertMany"
+	ModelBaseServiceV2_Count_FullMethodName       = "/grpc.ModelBaseServiceV2/Count"
+)
 
 // ModelBaseServiceV2Client is the client API for ModelBaseServiceV2 service.
 //
@@ -47,8 +64,9 @@ func NewModelBaseServiceV2Client(cc grpc.ClientConnInterface) ModelBaseServiceV2
 }
 
 func (c *modelBaseServiceV2Client) GetById(ctx context.Context, in *ModelServiceV2GetByIdRequest, opts ...grpc.CallOption) (*Response, error) {
+	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
 	out := new(Response)
-	err := c.cc.Invoke(ctx, "/grpc.ModelBaseServiceV2/GetById", in, out, opts...)
+	err := c.cc.Invoke(ctx, ModelBaseServiceV2_GetById_FullMethodName, in, out, cOpts...)
 	if err != nil {
 		return nil, err
 	}
@@ -56,8 +74,9 @@ func (c *modelBaseServiceV2Client) GetById(ctx context.Context, in *ModelService
 }
 
 func (c *modelBaseServiceV2Client) GetOne(ctx context.Context, in *ModelServiceV2GetOneRequest, opts ...grpc.CallOption) (*Response, error) {
+	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
 	out := new(Response)
-	err := c.cc.Invoke(ctx, "/grpc.ModelBaseServiceV2/GetOne", in, out, opts...)
+	err := c.cc.Invoke(ctx, ModelBaseServiceV2_GetOne_FullMethodName, in, out, cOpts...)
 	if err != nil {
 		return nil, err
 	}
@@ -65,8 +84,9 @@ func (c *modelBaseServiceV2Client) GetOne(ctx context.Context, in *ModelServiceV
 }
 
 func (c *modelBaseServiceV2Client) GetMany(ctx context.Context, in *ModelServiceV2GetManyRequest, opts ...grpc.CallOption) (*Response, error) {
+	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
 	out := new(Response)
-	err := c.cc.Invoke(ctx, "/grpc.ModelBaseServiceV2/GetMany", in, out, opts...)
+	err := c.cc.Invoke(ctx, ModelBaseServiceV2_GetMany_FullMethodName, in, out, cOpts...)
 	if err != nil {
 		return nil, err
 	}
@@ -74,8 +94,9 @@ func (c *modelBaseServiceV2Client) GetMany(ctx context.Context, in *ModelService
 }
 
 func (c *modelBaseServiceV2Client) DeleteById(ctx context.Context, in *ModelServiceV2DeleteByIdRequest, opts ...grpc.CallOption) (*Response, error) {
+	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
 	out := new(Response)
-	err := c.cc.Invoke(ctx, "/grpc.ModelBaseServiceV2/DeleteById", in, out, opts...)
+	err := c.cc.Invoke(ctx, ModelBaseServiceV2_DeleteById_FullMethodName, in, out, cOpts...)
 	if err != nil {
 		return nil, err
 	}
@@ -83,8 +104,9 @@ func (c *modelBaseServiceV2Client) DeleteById(ctx context.Context, in *ModelServ
 }
 
 func (c *modelBaseServiceV2Client) DeleteOne(ctx context.Context, in *ModelServiceV2DeleteOneRequest, opts ...grpc.CallOption) (*Response, error) {
+	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
 	out := new(Response)
-	err := c.cc.Invoke(ctx, "/grpc.ModelBaseServiceV2/DeleteOne", in, out, opts...)
+	err := c.cc.Invoke(ctx, ModelBaseServiceV2_DeleteOne_FullMethodName, in, out, cOpts...)
 	if err != nil {
 		return nil, err
 	}
@@ -92,8 +114,9 @@ func (c *modelBaseServiceV2Client) DeleteOne(ctx context.Context, in *ModelServi
 }
 
 func (c *modelBaseServiceV2Client) DeleteMany(ctx context.Context, in *ModelServiceV2DeleteManyRequest, opts ...grpc.CallOption) (*Response, error) {
+	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
 	out := new(Response)
-	err := c.cc.Invoke(ctx, "/grpc.ModelBaseServiceV2/DeleteMany", in, out, opts...)
+	err := c.cc.Invoke(ctx, ModelBaseServiceV2_DeleteMany_FullMethodName, in, out, cOpts...)
 	if err != nil {
 		return nil, err
 	}
@@ -101,8 +124,9 @@ func (c *modelBaseServiceV2Client) DeleteMany(ctx context.Context, in *ModelServ
 }
 
 func (c *modelBaseServiceV2Client) UpdateById(ctx context.Context, in *ModelServiceV2UpdateByIdRequest, opts ...grpc.CallOption) (*Response, error) {
+	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
 	out := new(Response)
-	err := c.cc.Invoke(ctx, "/grpc.ModelBaseServiceV2/UpdateById", in, out, opts...)
+	err := c.cc.Invoke(ctx, ModelBaseServiceV2_UpdateById_FullMethodName, in, out, cOpts...)
 	if err != nil {
 		return nil, err
 	}
@@ -110,8 +134,9 @@ func (c *modelBaseServiceV2Client) UpdateById(ctx context.Context, in *ModelServ
 }
 
 func (c *modelBaseServiceV2Client) UpdateOne(ctx context.Context, in *ModelServiceV2UpdateOneRequest, opts ...grpc.CallOption) (*Response, error) {
+	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
 	out := new(Response)
-	err := c.cc.Invoke(ctx, "/grpc.ModelBaseServiceV2/UpdateOne", in, out, opts...)
+	err := c.cc.Invoke(ctx, ModelBaseServiceV2_UpdateOne_FullMethodName, in, out, cOpts...)
 	if err != nil {
 		return nil, err
 	}
@@ -119,8 +144,9 @@ func (c *modelBaseServiceV2Client) UpdateOne(ctx context.Context, in *ModelServi
 }
 
 func (c *modelBaseServiceV2Client) UpdateMany(ctx context.Context, in *ModelServiceV2UpdateManyRequest, opts ...grpc.CallOption) (*Response, error) {
+	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
 	out := new(Response)
-	err := c.cc.Invoke(ctx, "/grpc.ModelBaseServiceV2/UpdateMany", in, out, opts...)
+	err := c.cc.Invoke(ctx, ModelBaseServiceV2_UpdateMany_FullMethodName, in, out, cOpts...)
 	if err != nil {
 		return nil, err
 	}
@@ -128,8 +154,9 @@ func (c *modelBaseServiceV2Client) UpdateMany(ctx context.Context, in *ModelServ
 }
 
 func (c *modelBaseServiceV2Client) ReplaceById(ctx context.Context, in *ModelServiceV2ReplaceByIdRequest, opts ...grpc.CallOption) (*Response, error) {
+	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
 	out := new(Response)
-	err := c.cc.Invoke(ctx, "/grpc.ModelBaseServiceV2/ReplaceById", in, out, opts...)
+	err := c.cc.Invoke(ctx, ModelBaseServiceV2_ReplaceById_FullMethodName, in, out, cOpts...)
 	if err != nil {
 		return nil, err
 	}
@@ -137,8 +164,9 @@ func (c *modelBaseServiceV2Client) ReplaceById(ctx context.Context, in *ModelSer
 }
 
 func (c *modelBaseServiceV2Client) ReplaceOne(ctx context.Context, in *ModelServiceV2ReplaceOneRequest, opts ...grpc.CallOption) (*Response, error) {
+	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
 	out := new(Response)
-	err := c.cc.Invoke(ctx, "/grpc.ModelBaseServiceV2/ReplaceOne", in, out, opts...)
+	err := c.cc.Invoke(ctx, ModelBaseServiceV2_ReplaceOne_FullMethodName, in, out, cOpts...)
 	if err != nil {
 		return nil, err
 	}
@@ -146,8 +174,9 @@ func (c *modelBaseServiceV2Client) ReplaceOne(ctx context.Context, in *ModelServ
 }
 
 func (c *modelBaseServiceV2Client) InsertOne(ctx context.Context, in *ModelServiceV2InsertOneRequest, opts ...grpc.CallOption) (*Response, error) {
+	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
 	out := new(Response)
-	err := c.cc.Invoke(ctx, "/grpc.ModelBaseServiceV2/InsertOne", in, out, opts...)
+	err := c.cc.Invoke(ctx, ModelBaseServiceV2_InsertOne_FullMethodName, in, out, cOpts...)
 	if err != nil {
 		return nil, err
 	}
@@ -155,8 +184,9 @@ func (c *modelBaseServiceV2Client) InsertOne(ctx context.Context, in *ModelServi
 }
 
 func (c *modelBaseServiceV2Client) InsertMany(ctx context.Context, in *ModelServiceV2InsertManyRequest, opts ...grpc.CallOption) (*Response, error) {
+	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
 	out := new(Response)
-	err := c.cc.Invoke(ctx, "/grpc.ModelBaseServiceV2/InsertMany", in, out, opts...)
+	err := c.cc.Invoke(ctx, ModelBaseServiceV2_InsertMany_FullMethodName, in, out, cOpts...)
 	if err != nil {
 		return nil, err
 	}
@@ -164,8 +194,9 @@ func (c *modelBaseServiceV2Client) InsertMany(ctx context.Context, in *ModelServ
 }
 
 func (c *modelBaseServiceV2Client) Count(ctx context.Context, in *ModelServiceV2CountRequest, opts ...grpc.CallOption) (*Response, error) {
+	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
 	out := new(Response)
-	err := c.cc.Invoke(ctx, "/grpc.ModelBaseServiceV2/Count", in, out, opts...)
+	err := c.cc.Invoke(ctx, ModelBaseServiceV2_Count_FullMethodName, in, out, cOpts...)
 	if err != nil {
 		return nil, err
 	}
@@ -262,7 +293,7 @@ func _ModelBaseServiceV2_GetById_Handler(srv interface{}, ctx context.Context, d
 	}
 	info := &grpc.UnaryServerInfo{
 		Server:     srv,
-		FullMethod: "/grpc.ModelBaseServiceV2/GetById",
+		FullMethod: ModelBaseServiceV2_GetById_FullMethodName,
 	}
 	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
 		return srv.(ModelBaseServiceV2Server).GetById(ctx, req.(*ModelServiceV2GetByIdRequest))
@@ -280,7 +311,7 @@ func _ModelBaseServiceV2_GetOne_Handler(srv interface{}, ctx context.Context, de
 	}
 	info := &grpc.UnaryServerInfo{
 		Server:     srv,
-		FullMethod: "/grpc.ModelBaseServiceV2/GetOne",
+		FullMethod: ModelBaseServiceV2_GetOne_FullMethodName,
 	}
 	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
 		return srv.(ModelBaseServiceV2Server).GetOne(ctx, req.(*ModelServiceV2GetOneRequest))
@@ -298,7 +329,7 @@ func _ModelBaseServiceV2_GetMany_Handler(srv interface{}, ctx context.Context, d
 	}
 	info := &grpc.UnaryServerInfo{
 		Server:     srv,
-		FullMethod: "/grpc.ModelBaseServiceV2/GetMany",
+		FullMethod: ModelBaseServiceV2_GetMany_FullMethodName,
 	}
 	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
 		return srv.(ModelBaseServiceV2Server).GetMany(ctx, req.(*ModelServiceV2GetManyRequest))
@@ -316,7 +347,7 @@ func _ModelBaseServiceV2_DeleteById_Handler(srv interface{}, ctx context.Context
 	}
 	info := &grpc.UnaryServerInfo{
 		Server:     srv,
-		FullMethod: "/grpc.ModelBaseServiceV2/DeleteById",
+		FullMethod: ModelBaseServiceV2_DeleteById_FullMethodName,
 	}
 	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
 		return srv.(ModelBaseServiceV2Server).DeleteById(ctx, req.(*ModelServiceV2DeleteByIdRequest))
@@ -334,7 +365,7 @@ func _ModelBaseServiceV2_DeleteOne_Handler(srv interface{}, ctx context.Context,
 	}
 	info := &grpc.UnaryServerInfo{
 		Server:     srv,
-		FullMethod: "/grpc.ModelBaseServiceV2/DeleteOne",
+		FullMethod: ModelBaseServiceV2_DeleteOne_FullMethodName,
 	}
 	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
 		return srv.(ModelBaseServiceV2Server).DeleteOne(ctx, req.(*ModelServiceV2DeleteOneRequest))
@@ -352,7 +383,7 @@ func _ModelBaseServiceV2_DeleteMany_Handler(srv interface{}, ctx context.Context
 	}
 	info := &grpc.UnaryServerInfo{
 		Server:     srv,
-		FullMethod: "/grpc.ModelBaseServiceV2/DeleteMany",
+		FullMethod: ModelBaseServiceV2_DeleteMany_FullMethodName,
 	}
 	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
 		return srv.(ModelBaseServiceV2Server).DeleteMany(ctx, req.(*ModelServiceV2DeleteManyRequest))
@@ -370,7 +401,7 @@ func _ModelBaseServiceV2_UpdateById_Handler(srv interface{}, ctx context.Context
 	}
 	info := &grpc.UnaryServerInfo{
 		Server:     srv,
-		FullMethod: "/grpc.ModelBaseServiceV2/UpdateById",
+		FullMethod: ModelBaseServiceV2_UpdateById_FullMethodName,
 	}
 	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
 		return srv.(ModelBaseServiceV2Server).UpdateById(ctx, req.(*ModelServiceV2UpdateByIdRequest))
@@ -388,7 +419,7 @@ func _ModelBaseServiceV2_UpdateOne_Handler(srv interface{}, ctx context.Context,
 	}
 	info := &grpc.UnaryServerInfo{
 		Server:     srv,
-		FullMethod: "/grpc.ModelBaseServiceV2/UpdateOne",
+		FullMethod: ModelBaseServiceV2_UpdateOne_FullMethodName,
 	}
 	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
 		return srv.(ModelBaseServiceV2Server).UpdateOne(ctx, req.(*ModelServiceV2UpdateOneRequest))
@@ -406,7 +437,7 @@ func _ModelBaseServiceV2_UpdateMany_Handler(srv interface{}, ctx context.Context
 	}
 	info := &grpc.UnaryServerInfo{
 		Server:     srv,
-		FullMethod: "/grpc.ModelBaseServiceV2/UpdateMany",
+		FullMethod: ModelBaseServiceV2_UpdateMany_FullMethodName,
 	}
 	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
 		return srv.(ModelBaseServiceV2Server).UpdateMany(ctx, req.(*ModelServiceV2UpdateManyRequest))
@@ -424,7 +455,7 @@ func _ModelBaseServiceV2_ReplaceById_Handler(srv interface{}, ctx context.Contex
 	}
 	info := &grpc.UnaryServerInfo{
 		Server:     srv,
-		FullMethod: "/grpc.ModelBaseServiceV2/ReplaceById",
+		FullMethod: ModelBaseServiceV2_ReplaceById_FullMethodName,
 	}
 	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
 		return srv.(ModelBaseServiceV2Server).ReplaceById(ctx, req.(*ModelServiceV2ReplaceByIdRequest))
@@ -442,7 +473,7 @@ func _ModelBaseServiceV2_ReplaceOne_Handler(srv interface{}, ctx context.Context
 	}
 	info := &grpc.UnaryServerInfo{
 		Server:     srv,
-		FullMethod: "/grpc.ModelBaseServiceV2/ReplaceOne",
+		FullMethod: ModelBaseServiceV2_ReplaceOne_FullMethodName,
 	}
 	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
 		return srv.(ModelBaseServiceV2Server).ReplaceOne(ctx, req.(*ModelServiceV2ReplaceOneRequest))
@@ -460,7 +491,7 @@ func _ModelBaseServiceV2_InsertOne_Handler(srv interface{}, ctx context.Context,
 	}
 	info := &grpc.UnaryServerInfo{
 		Server:     srv,
-		FullMethod: "/grpc.ModelBaseServiceV2/InsertOne",
+		FullMethod: ModelBaseServiceV2_InsertOne_FullMethodName,
 	}
 	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
 		return srv.(ModelBaseServiceV2Server).InsertOne(ctx, req.(*ModelServiceV2InsertOneRequest))
@@ -478,7 +509,7 @@ func _ModelBaseServiceV2_InsertMany_Handler(srv interface{}, ctx context.Context
 	}
 	info := &grpc.UnaryServerInfo{
 		Server:     srv,
-		FullMethod: "/grpc.ModelBaseServiceV2/InsertMany",
+		FullMethod: ModelBaseServiceV2_InsertMany_FullMethodName,
 	}
 	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
 		return srv.(ModelBaseServiceV2Server).InsertMany(ctx, req.(*ModelServiceV2InsertManyRequest))
@@ -496,7 +527,7 @@ func _ModelBaseServiceV2_Count_Handler(srv interface{}, ctx context.Context, dec
 	}
 	info := &grpc.UnaryServerInfo{
 		Server:     srv,
-		FullMethod: "/grpc.ModelBaseServiceV2/Count",
+		FullMethod: ModelBaseServiceV2_Count_FullMethodName,
 	}
 	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
 		return srv.(ModelBaseServiceV2Server).Count(ctx, req.(*ModelServiceV2CountRequest))

grpc/model_delegate_grpc.pb.go

@@ -1,6 +1,6 @@
 // Code generated by protoc-gen-go-grpc. DO NOT EDIT.
 // versions:
-// - protoc-gen-go-grpc v1.2.0
+// - protoc-gen-go-grpc v1.4.0
 // - protoc             v5.27.2
 // source: services/model_delegate.proto
 
@@ -15,8 +15,12 @@ import (
 
 // This is a compile-time assertion to ensure that this generated file
 // is compatible with the grpc package it is being compiled against.
-// Requires gRPC-Go v1.32.0 or later.
-const _ = grpc.SupportPackageIsVersion7
+// Requires gRPC-Go v1.62.0 or later.
+const _ = grpc.SupportPackageIsVersion8
+
+const (
+	ModelDelegate_Do_FullMethodName = "/grpc.ModelDelegate/Do"
+)
 
 // ModelDelegateClient is the client API for ModelDelegate service.
 //
@@ -34,8 +38,9 @@ func NewModelDelegateClient(cc grpc.ClientConnInterface) ModelDelegateClient {
 }
 
 func (c *modelDelegateClient) Do(ctx context.Context, in *Request, opts ...grpc.CallOption) (*Response, error) {
+	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
 	out := new(Response)
-	err := c.cc.Invoke(ctx, "/grpc.ModelDelegate/Do", in, out, opts...)
+	err := c.cc.Invoke(ctx, ModelDelegate_Do_FullMethodName, in, out, cOpts...)
 	if err != nil {
 		return nil, err
 	}
@@ -80,7 +85,7 @@ func _ModelDelegate_Do_Handler(srv interface{}, ctx context.Context, dec func(in
 	}
 	info := &grpc.UnaryServerInfo{
 		Server:     srv,
-		FullMethod: "/grpc.ModelDelegate/Do",
+		FullMethod: ModelDelegate_Do_FullMethodName,
 	}
 	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
 		return srv.(ModelDelegateServer).Do(ctx, req.(*Request))

grpc/node_service.pb.go

@@ -10,6 +10,7 @@ import (
 	protoreflect "google.golang.org/protobuf/reflect/protoreflect"
 	protoimpl "google.golang.org/protobuf/runtime/protoimpl"
 	reflect "reflect"
+	sync "sync"
 )
 
 const (
@@ -19,6 +20,132 @@ const (
 	_ = protoimpl.EnforceVersion(protoimpl.MaxVersion - 20)
 )
 
+type NodeServiceRegisterRequest struct {
+	state         protoimpl.MessageState
+	sizeCache     protoimpl.SizeCache
+	unknownFields protoimpl.UnknownFields
+
+	Key        string `protobuf:"bytes,1,opt,name=key,proto3" json:"key,omitempty"`
+	Name       string `protobuf:"bytes,2,opt,name=name,proto3" json:"name,omitempty"`
+	IsMaster   bool   `protobuf:"varint,3,opt,name=isMaster,proto3" json:"isMaster,omitempty"`
+	AuthKey    string `protobuf:"bytes,4,opt,name=authKey,proto3" json:"authKey,omitempty"`
+	MaxRunners int32  `protobuf:"varint,5,opt,name=maxRunners,proto3" json:"maxRunners,omitempty"`
+}
+
+func (x *NodeServiceRegisterRequest) Reset() {
+	*x = NodeServiceRegisterRequest{}
+	if protoimpl.UnsafeEnabled {
+		mi := &file_services_node_service_proto_msgTypes[0]
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		ms.StoreMessageInfo(mi)
+	}
+}
+
+func (x *NodeServiceRegisterRequest) String() string {
+	return protoimpl.X.MessageStringOf(x)
+}
+
+func (*NodeServiceRegisterRequest) ProtoMessage() {}
+
+func (x *NodeServiceRegisterRequest) ProtoReflect() protoreflect.Message {
+	mi := &file_services_node_service_proto_msgTypes[0]
+	if protoimpl.UnsafeEnabled && x != nil {
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		if ms.LoadMessageInfo() == nil {
+			ms.StoreMessageInfo(mi)
+		}
+		return ms
+	}
+	return mi.MessageOf(x)
+}
+
+// Deprecated: Use NodeServiceRegisterRequest.ProtoReflect.Descriptor instead.
+func (*NodeServiceRegisterRequest) Descriptor() ([]byte, []int) {
+	return file_services_node_service_proto_rawDescGZIP(), []int{0}
+}
+
+func (x *NodeServiceRegisterRequest) GetKey() string {
+	if x != nil {
+		return x.Key
+	}
+	return ""
+}
+
+func (x *NodeServiceRegisterRequest) GetName() string {
+	if x != nil {
+		return x.Name
+	}
+	return ""
+}
+
+func (x *NodeServiceRegisterRequest) GetIsMaster() bool {
+	if x != nil {
+		return x.IsMaster
+	}
+	return false
+}
+
+func (x *NodeServiceRegisterRequest) GetAuthKey() string {
+	if x != nil {
+		return x.AuthKey
+	}
+	return ""
+}
+
+func (x *NodeServiceRegisterRequest) GetMaxRunners() int32 {
+	if x != nil {
+		return x.MaxRunners
+	}
+	return 0
+}
+
+type NodeServiceSendHeartbeatRequest struct {
+	state         protoimpl.MessageState
+	sizeCache     protoimpl.SizeCache
+	unknownFields protoimpl.UnknownFields
+
+	Key string `protobuf:"bytes,1,opt,name=key,proto3" json:"key,omitempty"`
+}
+
+func (x *NodeServiceSendHeartbeatRequest) Reset() {
+	*x = NodeServiceSendHeartbeatRequest{}
+	if protoimpl.UnsafeEnabled {
+		mi := &file_services_node_service_proto_msgTypes[1]
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		ms.StoreMessageInfo(mi)
+	}
+}
+
+func (x *NodeServiceSendHeartbeatRequest) String() string {
+	return protoimpl.X.MessageStringOf(x)
+}
+
+func (*NodeServiceSendHeartbeatRequest) ProtoMessage() {}
+
+func (x *NodeServiceSendHeartbeatRequest) ProtoReflect() protoreflect.Message {
+	mi := &file_services_node_service_proto_msgTypes[1]
+	if protoimpl.UnsafeEnabled && x != nil {
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		if ms.LoadMessageInfo() == nil {
+			ms.StoreMessageInfo(mi)
+		}
+		return ms
+	}
+	return mi.MessageOf(x)
+}
+
+// Deprecated: Use NodeServiceSendHeartbeatRequest.ProtoReflect.Descriptor instead.
+func (*NodeServiceSendHeartbeatRequest) Descriptor() ([]byte, []int) {
+	return file_services_node_service_proto_rawDescGZIP(), []int{1}
+}
+
+func (x *NodeServiceSendHeartbeatRequest) GetKey() string {
+	if x != nil {
+		return x.Key
+	}
+	return ""
+}
+
 var File_services_node_service_proto protoreflect.FileDescriptor
 
 var file_services_node_service_proto_rawDesc = []byte{
@@ -28,44 +155,70 @@ var file_services_node_service_proto_rawDesc = []byte{
 	0x65, 0x73, 0x74, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x1a, 0x15, 0x65, 0x6e, 0x74, 0x69, 0x74,
 	0x79, 0x2f, 0x72, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f,
 	0x1a, 0x1b, 0x65, 0x6e, 0x74, 0x69, 0x74, 0x79, 0x2f, 0x73, 0x74, 0x72, 0x65, 0x61, 0x6d, 0x5f,
-	0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x32, 0xfa, 0x01,
-	0x0a, 0x0b, 0x4e, 0x6f, 0x64, 0x65, 0x53, 0x65, 0x72, 0x76, 0x69, 0x63, 0x65, 0x12, 0x2b, 0x0a,
-	0x08, 0x52, 0x65, 0x67, 0x69, 0x73, 0x74, 0x65, 0x72, 0x12, 0x0d, 0x2e, 0x67, 0x72, 0x70, 0x63,
-	0x2e, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x0e, 0x2e, 0x67, 0x72, 0x70, 0x63, 0x2e,
-	0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, 0x00, 0x12, 0x30, 0x0a, 0x0d, 0x53, 0x65,
-	0x6e, 0x64, 0x48, 0x65, 0x61, 0x72, 0x74, 0x62, 0x65, 0x61, 0x74, 0x12, 0x0d, 0x2e, 0x67, 0x72,
+	0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x22, 0x98, 0x01,
+	0x0a, 0x1a, 0x4e, 0x6f, 0x64, 0x65, 0x53, 0x65, 0x72, 0x76, 0x69, 0x63, 0x65, 0x52, 0x65, 0x67,
+	0x69, 0x73, 0x74, 0x65, 0x72, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x12, 0x10, 0x0a, 0x03,
+	0x6b, 0x65, 0x79, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x03, 0x6b, 0x65, 0x79, 0x12, 0x12,
+	0x0a, 0x04, 0x6e, 0x61, 0x6d, 0x65, 0x18, 0x02, 0x20, 0x01, 0x28, 0x09, 0x52, 0x04, 0x6e, 0x61,
+	0x6d, 0x65, 0x12, 0x1a, 0x0a, 0x08, 0x69, 0x73, 0x4d, 0x61, 0x73, 0x74, 0x65, 0x72, 0x18, 0x03,
+	0x20, 0x01, 0x28, 0x08, 0x52, 0x08, 0x69, 0x73, 0x4d, 0x61, 0x73, 0x74, 0x65, 0x72, 0x12, 0x18,
+	0x0a, 0x07, 0x61, 0x75, 0x74, 0x68, 0x4b, 0x65, 0x79, 0x18, 0x04, 0x20, 0x01, 0x28, 0x09, 0x52,
+	0x07, 0x61, 0x75, 0x74, 0x68, 0x4b, 0x65, 0x79, 0x12, 0x1e, 0x0a, 0x0a, 0x6d, 0x61, 0x78, 0x52,
+	0x75, 0x6e, 0x6e, 0x65, 0x72, 0x73, 0x18, 0x05, 0x20, 0x01, 0x28, 0x05, 0x52, 0x0a, 0x6d, 0x61,
+	0x78, 0x52, 0x75, 0x6e, 0x6e, 0x65, 0x72, 0x73, 0x22, 0x33, 0x0a, 0x1f, 0x4e, 0x6f, 0x64, 0x65,
+	0x53, 0x65, 0x72, 0x76, 0x69, 0x63, 0x65, 0x53, 0x65, 0x6e, 0x64, 0x48, 0x65, 0x61, 0x72, 0x74,
+	0x62, 0x65, 0x61, 0x74, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x12, 0x10, 0x0a, 0x03, 0x6b,
+	0x65, 0x79, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x03, 0x6b, 0x65, 0x79, 0x32, 0xfc, 0x01,
+	0x0a, 0x0b, 0x4e, 0x6f, 0x64, 0x65, 0x53, 0x65, 0x72, 0x76, 0x69, 0x63, 0x65, 0x12, 0x3e, 0x0a,
+	0x08, 0x52, 0x65, 0x67, 0x69, 0x73, 0x74, 0x65, 0x72, 0x12, 0x20, 0x2e, 0x67, 0x72, 0x70, 0x63,
+	0x2e, 0x4e, 0x6f, 0x64, 0x65, 0x53, 0x65, 0x72, 0x76, 0x69, 0x63, 0x65, 0x52, 0x65, 0x67, 0x69,
+	0x73, 0x74, 0x65, 0x72, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x0e, 0x2e, 0x67, 0x72,
+	0x70, 0x63, 0x2e, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, 0x00, 0x12, 0x48, 0x0a,
+	0x0d, 0x53, 0x65, 0x6e, 0x64, 0x48, 0x65, 0x61, 0x72, 0x74, 0x62, 0x65, 0x61, 0x74, 0x12, 0x25,
+	0x2e, 0x67, 0x72, 0x70, 0x63, 0x2e, 0x4e, 0x6f, 0x64, 0x65, 0x53, 0x65, 0x72, 0x76, 0x69, 0x63,
+	0x65, 0x53, 0x65, 0x6e, 0x64, 0x48, 0x65, 0x61, 0x72, 0x74, 0x62, 0x65, 0x61, 0x74, 0x52, 0x65,
+	0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x0e, 0x2e, 0x67, 0x72, 0x70, 0x63, 0x2e, 0x52, 0x65, 0x73,
+	0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, 0x00, 0x12, 0x33, 0x0a, 0x09, 0x53, 0x75, 0x62, 0x73, 0x63,
+	0x72, 0x69, 0x62, 0x65, 0x12, 0x0d, 0x2e, 0x67, 0x72, 0x70, 0x63, 0x2e, 0x52, 0x65, 0x71, 0x75,
+	0x65, 0x73, 0x74, 0x1a, 0x13, 0x2e, 0x67, 0x72, 0x70, 0x63, 0x2e, 0x53, 0x74, 0x72, 0x65, 0x61,
+	0x6d, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x22, 0x00, 0x30, 0x01, 0x12, 0x2e, 0x0a, 0x0b,
+	0x55, 0x6e, 0x73, 0x75, 0x62, 0x73, 0x63, 0x72, 0x69, 0x62, 0x65, 0x12, 0x0d, 0x2e, 0x67, 0x72,
 	0x70, 0x63, 0x2e, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x0e, 0x2e, 0x67, 0x72, 0x70,
-	0x63, 0x2e, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, 0x00, 0x12, 0x27, 0x0a, 0x04,
-	0x50, 0x69, 0x6e, 0x67, 0x12, 0x0d, 0x2e, 0x67, 0x72, 0x70, 0x63, 0x2e, 0x52, 0x65, 0x71, 0x75,
-	0x65, 0x73, 0x74, 0x1a, 0x0e, 0x2e, 0x67, 0x72, 0x70, 0x63, 0x2e, 0x52, 0x65, 0x73, 0x70, 0x6f,
-	0x6e, 0x73, 0x65, 0x22, 0x00, 0x12, 0x33, 0x0a, 0x09, 0x53, 0x75, 0x62, 0x73, 0x63, 0x72, 0x69,
-	0x62, 0x65, 0x12, 0x0d, 0x2e, 0x67, 0x72, 0x70, 0x63, 0x2e, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73,
-	0x74, 0x1a, 0x13, 0x2e, 0x67, 0x72, 0x70, 0x63, 0x2e, 0x53, 0x74, 0x72, 0x65, 0x61, 0x6d, 0x4d,
-	0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x22, 0x00, 0x30, 0x01, 0x12, 0x2e, 0x0a, 0x0b, 0x55, 0x6e,
-	0x73, 0x75, 0x62, 0x73, 0x63, 0x72, 0x69, 0x62, 0x65, 0x12, 0x0d, 0x2e, 0x67, 0x72, 0x70, 0x63,
-	0x2e, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x0e, 0x2e, 0x67, 0x72, 0x70, 0x63, 0x2e,
-	0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, 0x00, 0x42, 0x08, 0x5a, 0x06, 0x2e, 0x3b,
-	0x67, 0x72, 0x70, 0x63, 0x62, 0x06, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x33,
+	0x63, 0x2e, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, 0x00, 0x42, 0x08, 0x5a, 0x06,
+	0x2e, 0x3b, 0x67, 0x72, 0x70, 0x63, 0x62, 0x06, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x33,
 }
 
+var (
+	file_services_node_service_proto_rawDescOnce sync.Once
+	file_services_node_service_proto_rawDescData = file_services_node_service_proto_rawDesc
+)
+
+func file_services_node_service_proto_rawDescGZIP() []byte {
+	file_services_node_service_proto_rawDescOnce.Do(func() {
+		file_services_node_service_proto_rawDescData = protoimpl.X.CompressGZIP(file_services_node_service_proto_rawDescData)
+	})
+	return file_services_node_service_proto_rawDescData
+}
+
+var file_services_node_service_proto_msgTypes = make([]protoimpl.MessageInfo, 2)
 var file_services_node_service_proto_goTypes = []any{
-	(*Request)(nil),       // 0: grpc.Request
-	(*Response)(nil),      // 1: grpc.Response
-	(*StreamMessage)(nil), // 2: grpc.StreamMessage
+	(*NodeServiceRegisterRequest)(nil),      // 0: grpc.NodeServiceRegisterRequest
+	(*NodeServiceSendHeartbeatRequest)(nil), // 1: grpc.NodeServiceSendHeartbeatRequest
+	(*Request)(nil),                         // 2: grpc.Request
+	(*Response)(nil),                        // 3: grpc.Response
+	(*StreamMessage)(nil),                   // 4: grpc.StreamMessage
 }
 var file_services_node_service_proto_depIdxs = []int32{
-	0, // 0: grpc.NodeService.Register:input_type -> grpc.Request
-	0, // 1: grpc.NodeService.SendHeartbeat:input_type -> grpc.Request
-	0, // 2: grpc.NodeService.Ping:input_type -> grpc.Request
-	0, // 3: grpc.NodeService.Subscribe:input_type -> grpc.Request
-	0, // 4: grpc.NodeService.Unsubscribe:input_type -> grpc.Request
-	1, // 5: grpc.NodeService.Register:output_type -> grpc.Response
-	1, // 6: grpc.NodeService.SendHeartbeat:output_type -> grpc.Response
-	1, // 7: grpc.NodeService.Ping:output_type -> grpc.Response
-	2, // 8: grpc.NodeService.Subscribe:output_type -> grpc.StreamMessage
-	1, // 9: grpc.NodeService.Unsubscribe:output_type -> grpc.Response
-	5, // [5:10] is the sub-list for method output_type
-	0, // [0:5] is the sub-list for method input_type
+	0, // 0: grpc.NodeService.Register:input_type -> grpc.NodeServiceRegisterRequest
+	1, // 1: grpc.NodeService.SendHeartbeat:input_type -> grpc.NodeServiceSendHeartbeatRequest
+	2, // 2: grpc.NodeService.Subscribe:input_type -> grpc.Request
+	2, // 3: grpc.NodeService.Unsubscribe:input_type -> grpc.Request
+	3, // 4: grpc.NodeService.Register:output_type -> grpc.Response
+	3, // 5: grpc.NodeService.SendHeartbeat:output_type -> grpc.Response
+	4, // 6: grpc.NodeService.Subscribe:output_type -> grpc.StreamMessage
+	3, // 7: grpc.NodeService.Unsubscribe:output_type -> grpc.Response
+	4, // [4:8] is the sub-list for method output_type
+	0, // [0:4] is the sub-list for method input_type
 	0, // [0:0] is the sub-list for extension type_name
 	0, // [0:0] is the sub-list for extension extendee
 	0, // [0:0] is the sub-list for field type_name
@@ -79,18 +232,45 @@ func file_services_node_service_proto_init() {
 	file_entity_request_proto_init()
 	file_entity_response_proto_init()
 	file_entity_stream_message_proto_init()
+	if !protoimpl.UnsafeEnabled {
+		file_services_node_service_proto_msgTypes[0].Exporter = func(v any, i int) any {
+			switch v := v.(*NodeServiceRegisterRequest); i {
+			case 0:
+				return &v.state
+			case 1:
+				return &v.sizeCache
+			case 2:
+				return &v.unknownFields
+			default:
+				return nil
+			}
+		}
+		file_services_node_service_proto_msgTypes[1].Exporter = func(v any, i int) any {
+			switch v := v.(*NodeServiceSendHeartbeatRequest); i {
+			case 0:
+				return &v.state
+			case 1:
+				return &v.sizeCache
+			case 2:
+				return &v.unknownFields
+			default:
+				return nil
+			}
+		}
+	}
 	type x struct{}
 	out := protoimpl.TypeBuilder{
 		File: protoimpl.DescBuilder{
 			GoPackagePath: reflect.TypeOf(x{}).PkgPath(),
 			RawDescriptor: file_services_node_service_proto_rawDesc,
 			NumEnums:      0,
-			NumMessages:   0,
+			NumMessages:   2,
 			NumExtensions: 0,
 			NumServices:   1,
 		},
 		GoTypes:           file_services_node_service_proto_goTypes,
 		DependencyIndexes: file_services_node_service_proto_depIdxs,
+		MessageInfos:      file_services_node_service_proto_msgTypes,
 	}.Build()
 	File_services_node_service_proto = out.File
 	file_services_node_service_proto_rawDesc = nil

grpc/node_service_grpc.pb.go

@@ -1,6 +1,6 @@
 // Code generated by protoc-gen-go-grpc. DO NOT EDIT.
 // versions:
-// - protoc-gen-go-grpc v1.2.0
+// - protoc-gen-go-grpc v1.4.0
 // - protoc             v5.27.2
 // source: services/node_service.proto
 
@@ -15,16 +15,22 @@ import (
 
 // This is a compile-time assertion to ensure that this generated file
 // is compatible with the grpc package it is being compiled against.
-// Requires gRPC-Go v1.32.0 or later.
-const _ = grpc.SupportPackageIsVersion7
+// Requires gRPC-Go v1.62.0 or later.
+const _ = grpc.SupportPackageIsVersion8
+
+const (
+	NodeService_Register_FullMethodName      = "/grpc.NodeService/Register"
+	NodeService_SendHeartbeat_FullMethodName = "/grpc.NodeService/SendHeartbeat"
+	NodeService_Subscribe_FullMethodName     = "/grpc.NodeService/Subscribe"
+	NodeService_Unsubscribe_FullMethodName   = "/grpc.NodeService/Unsubscribe"
+)
 
 // NodeServiceClient is the client API for NodeService service.
 //
 // For semantics around ctx use and closing/ending streaming RPCs, please refer to https://pkg.go.dev/google.golang.org/grpc/?tab=doc#ClientConn.NewStream.
 type NodeServiceClient interface {
-	Register(ctx context.Context, in *Request, opts ...grpc.CallOption) (*Response, error)
-	SendHeartbeat(ctx context.Context, in *Request, opts ...grpc.CallOption) (*Response, error)
-	Ping(ctx context.Context, in *Request, opts ...grpc.CallOption) (*Response, error)
+	Register(ctx context.Context, in *NodeServiceRegisterRequest, opts ...grpc.CallOption) (*Response, error)
+	SendHeartbeat(ctx context.Context, in *NodeServiceSendHeartbeatRequest, opts ...grpc.CallOption) (*Response, error)
 	Subscribe(ctx context.Context, in *Request, opts ...grpc.CallOption) (NodeService_SubscribeClient, error)
 	Unsubscribe(ctx context.Context, in *Request, opts ...grpc.CallOption) (*Response, error)
 }
@@ -37,27 +43,20 @@ func NewNodeServiceClient(cc grpc.ClientConnInterface) NodeServiceClient {
 	return &nodeServiceClient{cc}
 }
 
-func (c *nodeServiceClient) Register(ctx context.Context, in *Request, opts ...grpc.CallOption) (*Response, error) {
+func (c *nodeServiceClient) Register(ctx context.Context, in *NodeServiceRegisterRequest, opts ...grpc.CallOption) (*Response, error) {
+	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
 	out := new(Response)
-	err := c.cc.Invoke(ctx, "/grpc.NodeService/Register", in, out, opts...)
+	err := c.cc.Invoke(ctx, NodeService_Register_FullMethodName, in, out, cOpts...)
 	if err != nil {
 		return nil, err
 	}
 	return out, nil
 }
 
-func (c *nodeServiceClient) SendHeartbeat(ctx context.Context, in *Request, opts ...grpc.CallOption) (*Response, error) {
+func (c *nodeServiceClient) SendHeartbeat(ctx context.Context, in *NodeServiceSendHeartbeatRequest, opts ...grpc.CallOption) (*Response, error) {
+	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
 	out := new(Response)
-	err := c.cc.Invoke(ctx, "/grpc.NodeService/SendHeartbeat", in, out, opts...)
-	if err != nil {
-		return nil, err
-	}
-	return out, nil
-}
-
-func (c *nodeServiceClient) Ping(ctx context.Context, in *Request, opts ...grpc.CallOption) (*Response, error) {
-	out := new(Response)
-	err := c.cc.Invoke(ctx, "/grpc.NodeService/Ping", in, out, opts...)
+	err := c.cc.Invoke(ctx, NodeService_SendHeartbeat_FullMethodName, in, out, cOpts...)
 	if err != nil {
 		return nil, err
 	}
@@ -65,11 +64,12 @@ func (c *nodeServiceClient) Ping(ctx context.Context, in *Request, opts ...grpc.
 }
 
 func (c *nodeServiceClient) Subscribe(ctx context.Context, in *Request, opts ...grpc.CallOption) (NodeService_SubscribeClient, error) {
-	stream, err := c.cc.NewStream(ctx, &NodeService_ServiceDesc.Streams[0], "/grpc.NodeService/Subscribe", opts...)
+	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
+	stream, err := c.cc.NewStream(ctx, &NodeService_ServiceDesc.Streams[0], NodeService_Subscribe_FullMethodName, cOpts...)
 	if err != nil {
 		return nil, err
 	}
-	x := &nodeServiceSubscribeClient{stream}
+	x := &nodeServiceSubscribeClient{ClientStream: stream}
 	if err := x.ClientStream.SendMsg(in); err != nil {
 		return nil, err
 	}
@@ -97,8 +97,9 @@ func (x *nodeServiceSubscribeClient) Recv() (*StreamMessage, error) {
 }
 
 func (c *nodeServiceClient) Unsubscribe(ctx context.Context, in *Request, opts ...grpc.CallOption) (*Response, error) {
+	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
 	out := new(Response)
-	err := c.cc.Invoke(ctx, "/grpc.NodeService/Unsubscribe", in, out, opts...)
+	err := c.cc.Invoke(ctx, NodeService_Unsubscribe_FullMethodName, in, out, cOpts...)
 	if err != nil {
 		return nil, err
 	}
@@ -109,9 +110,8 @@ func (c *nodeServiceClient) Unsubscribe(ctx context.Context, in *Request, opts .
 // All implementations must embed UnimplementedNodeServiceServer
 // for forward compatibility
 type NodeServiceServer interface {
-	Register(context.Context, *Request) (*Response, error)
-	SendHeartbeat(context.Context, *Request) (*Response, error)
-	Ping(context.Context, *Request) (*Response, error)
+	Register(context.Context, *NodeServiceRegisterRequest) (*Response, error)
+	SendHeartbeat(context.Context, *NodeServiceSendHeartbeatRequest) (*Response, error)
 	Subscribe(*Request, NodeService_SubscribeServer) error
 	Unsubscribe(context.Context, *Request) (*Response, error)
 	mustEmbedUnimplementedNodeServiceServer()
@@ -121,15 +121,12 @@ type NodeServiceServer interface {
 type UnimplementedNodeServiceServer struct {
 }
 
-func (UnimplementedNodeServiceServer) Register(context.Context, *Request) (*Response, error) {
+func (UnimplementedNodeServiceServer) Register(context.Context, *NodeServiceRegisterRequest) (*Response, error) {
 	return nil, status.Errorf(codes.Unimplemented, "method Register not implemented")
 }
-func (UnimplementedNodeServiceServer) SendHeartbeat(context.Context, *Request) (*Response, error) {
+func (UnimplementedNodeServiceServer) SendHeartbeat(context.Context, *NodeServiceSendHeartbeatRequest) (*Response, error) {
 	return nil, status.Errorf(codes.Unimplemented, "method SendHeartbeat not implemented")
 }
-func (UnimplementedNodeServiceServer) Ping(context.Context, *Request) (*Response, error) {
-	return nil, status.Errorf(codes.Unimplemented, "method Ping not implemented")
-}
 func (UnimplementedNodeServiceServer) Subscribe(*Request, NodeService_SubscribeServer) error {
 	return status.Errorf(codes.Unimplemented, "method Subscribe not implemented")
 }
@@ -150,7 +147,7 @@ func RegisterNodeServiceServer(s grpc.ServiceRegistrar, srv NodeServiceServer) {
 }
 
 func _NodeService_Register_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
-	in := new(Request)
+	in := new(NodeServiceRegisterRequest)
 	if err := dec(in); err != nil {
 		return nil, err
 	}
@@ -159,16 +156,16 @@ func _NodeService_Register_Handler(srv interface{}, ctx context.Context, dec fun
 	}
 	info := &grpc.UnaryServerInfo{
 		Server:     srv,
-		FullMethod: "/grpc.NodeService/Register",
+		FullMethod: NodeService_Register_FullMethodName,
 	}
 	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
-		return srv.(NodeServiceServer).Register(ctx, req.(*Request))
+		return srv.(NodeServiceServer).Register(ctx, req.(*NodeServiceRegisterRequest))
 	}
 	return interceptor(ctx, in, info, handler)
 }
 
 func _NodeService_SendHeartbeat_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
-	in := new(Request)
+	in := new(NodeServiceSendHeartbeatRequest)
 	if err := dec(in); err != nil {
 		return nil, err
 	}
@@ -177,28 +174,10 @@ func _NodeService_SendHeartbeat_Handler(srv interface{}, ctx context.Context, de
 	}
 	info := &grpc.UnaryServerInfo{
 		Server:     srv,
-		FullMethod: "/grpc.NodeService/SendHeartbeat",
+		FullMethod: NodeService_SendHeartbeat_FullMethodName,
 	}
 	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
-		return srv.(NodeServiceServer).SendHeartbeat(ctx, req.(*Request))
-	}
-	return interceptor(ctx, in, info, handler)
-}
-
-func _NodeService_Ping_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
-	in := new(Request)
-	if err := dec(in); err != nil {
-		return nil, err
-	}
-	if interceptor == nil {
-		return srv.(NodeServiceServer).Ping(ctx, in)
-	}
-	info := &grpc.UnaryServerInfo{
-		Server:     srv,
-		FullMethod: "/grpc.NodeService/Ping",
-	}
-	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
-		return srv.(NodeServiceServer).Ping(ctx, req.(*Request))
+		return srv.(NodeServiceServer).SendHeartbeat(ctx, req.(*NodeServiceSendHeartbeatRequest))
 	}
 	return interceptor(ctx, in, info, handler)
 }
@@ -208,7 +187,7 @@ func _NodeService_Subscribe_Handler(srv interface{}, stream grpc.ServerStream) e
 	if err := stream.RecvMsg(m); err != nil {
 		return err
 	}
-	return srv.(NodeServiceServer).Subscribe(m, &nodeServiceSubscribeServer{stream})
+	return srv.(NodeServiceServer).Subscribe(m, &nodeServiceSubscribeServer{ServerStream: stream})
 }
 
 type NodeService_SubscribeServer interface {
@@ -234,7 +213,7 @@ func _NodeService_Unsubscribe_Handler(srv interface{}, ctx context.Context, dec
 	}
 	info := &grpc.UnaryServerInfo{
 		Server:     srv,
-		FullMethod: "/grpc.NodeService/Unsubscribe",
+		FullMethod: NodeService_Unsubscribe_FullMethodName,
 	}
 	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
 		return srv.(NodeServiceServer).Unsubscribe(ctx, req.(*Request))
@@ -257,10 +236,6 @@ var NodeService_ServiceDesc = grpc.ServiceDesc{
 			MethodName: "SendHeartbeat",
 			Handler:    _NodeService_SendHeartbeat_Handler,
 		},
-		{
-			MethodName: "Ping",
-			Handler:    _NodeService_Ping_Handler,
-		},
 		{
 			MethodName: "Unsubscribe",
 			Handler:    _NodeService_Unsubscribe_Handler,

grpc/plugin_service_grpc.pb.go

@@ -1,6 +1,6 @@
 // Code generated by protoc-gen-go-grpc. DO NOT EDIT.
 // versions:
-// - protoc-gen-go-grpc v1.2.0
+// - protoc-gen-go-grpc v1.4.0
 // - protoc             v5.27.2
 // source: services/plugin_service.proto
 
@@ -15,8 +15,14 @@ import (
 
 // This is a compile-time assertion to ensure that this generated file
 // is compatible with the grpc package it is being compiled against.
-// Requires gRPC-Go v1.32.0 or later.
-const _ = grpc.SupportPackageIsVersion7
+// Requires gRPC-Go v1.62.0 or later.
+const _ = grpc.SupportPackageIsVersion8
+
+const (
+	PluginService_Register_FullMethodName  = "/grpc.PluginService/Register"
+	PluginService_Subscribe_FullMethodName = "/grpc.PluginService/Subscribe"
+	PluginService_Poll_FullMethodName      = "/grpc.PluginService/Poll"
+)
 
 // PluginServiceClient is the client API for PluginService service.
 //
@@ -36,8 +42,9 @@ func NewPluginServiceClient(cc grpc.ClientConnInterface) PluginServiceClient {
 }
 
 func (c *pluginServiceClient) Register(ctx context.Context, in *PluginRequest, opts ...grpc.CallOption) (*Response, error) {
+	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
 	out := new(Response)
-	err := c.cc.Invoke(ctx, "/grpc.PluginService/Register", in, out, opts...)
+	err := c.cc.Invoke(ctx, PluginService_Register_FullMethodName, in, out, cOpts...)
 	if err != nil {
 		return nil, err
 	}
@@ -45,11 +52,12 @@ func (c *pluginServiceClient) Register(ctx context.Context, in *PluginRequest, o
 }
 
 func (c *pluginServiceClient) Subscribe(ctx context.Context, in *PluginRequest, opts ...grpc.CallOption) (PluginService_SubscribeClient, error) {
-	stream, err := c.cc.NewStream(ctx, &PluginService_ServiceDesc.Streams[0], "/grpc.PluginService/Subscribe", opts...)
+	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
+	stream, err := c.cc.NewStream(ctx, &PluginService_ServiceDesc.Streams[0], PluginService_Subscribe_FullMethodName, cOpts...)
 	if err != nil {
 		return nil, err
 	}
-	x := &pluginServiceSubscribeClient{stream}
+	x := &pluginServiceSubscribeClient{ClientStream: stream}
 	if err := x.ClientStream.SendMsg(in); err != nil {
 		return nil, err
 	}
@@ -77,11 +85,12 @@ func (x *pluginServiceSubscribeClient) Recv() (*StreamMessage, error) {
 }
 
 func (c *pluginServiceClient) Poll(ctx context.Context, opts ...grpc.CallOption) (PluginService_PollClient, error) {
-	stream, err := c.cc.NewStream(ctx, &PluginService_ServiceDesc.Streams[1], "/grpc.PluginService/Poll", opts...)
+	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
+	stream, err := c.cc.NewStream(ctx, &PluginService_ServiceDesc.Streams[1], PluginService_Poll_FullMethodName, cOpts...)
 	if err != nil {
 		return nil, err
 	}
-	x := &pluginServicePollClient{stream}
+	x := &pluginServicePollClient{ClientStream: stream}
 	return x, nil
 }
 
@@ -153,7 +162,7 @@ func _PluginService_Register_Handler(srv interface{}, ctx context.Context, dec f
 	}
 	info := &grpc.UnaryServerInfo{
 		Server:     srv,
-		FullMethod: "/grpc.PluginService/Register",
+		FullMethod: PluginService_Register_FullMethodName,
 	}
 	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
 		return srv.(PluginServiceServer).Register(ctx, req.(*PluginRequest))
@@ -166,7 +175,7 @@ func _PluginService_Subscribe_Handler(srv interface{}, stream grpc.ServerStream)
 	if err := stream.RecvMsg(m); err != nil {
 		return err
 	}
-	return srv.(PluginServiceServer).Subscribe(m, &pluginServiceSubscribeServer{stream})
+	return srv.(PluginServiceServer).Subscribe(m, &pluginServiceSubscribeServer{ServerStream: stream})
 }
 
 type PluginService_SubscribeServer interface {
@@ -183,7 +192,7 @@ func (x *pluginServiceSubscribeServer) Send(m *StreamMessage) error {
 }
 
 func _PluginService_Poll_Handler(srv interface{}, stream grpc.ServerStream) error {
-	return srv.(PluginServiceServer).Poll(&pluginServicePollServer{stream})
+	return srv.(PluginServiceServer).Poll(&pluginServicePollServer{ServerStream: stream})
 }
 
 type PluginService_PollServer interface {

grpc/proto/services/node_service.proto

@@ -7,10 +7,20 @@ import "entity/stream_message.proto";
 package grpc;
 option go_package = ".;grpc";
 
+message NodeServiceRegisterRequest {
+  string key = 1;
+  string name = 2;
+  bool isMaster = 3;
+  string authKey = 4;
+  int32 maxRunners = 5;
+}
+message NodeServiceSendHeartbeatRequest {
+  string key = 1;
+}
+
 service NodeService {
-  rpc Register(Request) returns (Response){};
-  rpc SendHeartbeat(Request) returns (Response){};
-  rpc Ping(Request) returns (Response){};
+  rpc Register(NodeServiceRegisterRequest) returns (Response){};
+  rpc SendHeartbeat(NodeServiceSendHeartbeatRequest) returns (Response){};
   rpc Subscribe(Request) returns (stream StreamMessage){};
   rpc Unsubscribe(Request) returns (Response){};
 }

grpc/task_service_grpc.pb.go

@@ -1,6 +1,6 @@
 // Code generated by protoc-gen-go-grpc. DO NOT EDIT.
 // versions:
-// - protoc-gen-go-grpc v1.2.0
+// - protoc-gen-go-grpc v1.4.0
 // - protoc             v5.27.2
 // source: services/task_service.proto
 
@@ -15,8 +15,14 @@ import (
 
 // This is a compile-time assertion to ensure that this generated file
 // is compatible with the grpc package it is being compiled against.
-// Requires gRPC-Go v1.32.0 or later.
-const _ = grpc.SupportPackageIsVersion7
+// Requires gRPC-Go v1.62.0 or later.
+const _ = grpc.SupportPackageIsVersion8
+
+const (
+	TaskService_Subscribe_FullMethodName        = "/grpc.TaskService/Subscribe"
+	TaskService_Fetch_FullMethodName            = "/grpc.TaskService/Fetch"
+	TaskService_SendNotification_FullMethodName = "/grpc.TaskService/SendNotification"
+)
 
 // TaskServiceClient is the client API for TaskService service.
 //
@@ -36,11 +42,12 @@ func NewTaskServiceClient(cc grpc.ClientConnInterface) TaskServiceClient {
 }
 
 func (c *taskServiceClient) Subscribe(ctx context.Context, opts ...grpc.CallOption) (TaskService_SubscribeClient, error) {
-	stream, err := c.cc.NewStream(ctx, &TaskService_ServiceDesc.Streams[0], "/grpc.TaskService/Subscribe", opts...)
+	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
+	stream, err := c.cc.NewStream(ctx, &TaskService_ServiceDesc.Streams[0], TaskService_Subscribe_FullMethodName, cOpts...)
 	if err != nil {
 		return nil, err
 	}
-	x := &taskServiceSubscribeClient{stream}
+	x := &taskServiceSubscribeClient{ClientStream: stream}
 	return x, nil
 }
 
@@ -70,8 +77,9 @@ func (x *taskServiceSubscribeClient) CloseAndRecv() (*Response, error) {
 }
 
 func (c *taskServiceClient) Fetch(ctx context.Context, in *Request, opts ...grpc.CallOption) (*Response, error) {
+	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
 	out := new(Response)
-	err := c.cc.Invoke(ctx, "/grpc.TaskService/Fetch", in, out, opts...)
+	err := c.cc.Invoke(ctx, TaskService_Fetch_FullMethodName, in, out, cOpts...)
 	if err != nil {
 		return nil, err
 	}
@@ -79,8 +87,9 @@ func (c *taskServiceClient) Fetch(ctx context.Context, in *Request, opts ...grpc
 }
 
 func (c *taskServiceClient) SendNotification(ctx context.Context, in *Request, opts ...grpc.CallOption) (*Response, error) {
+	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
 	out := new(Response)
-	err := c.cc.Invoke(ctx, "/grpc.TaskService/SendNotification", in, out, opts...)
+	err := c.cc.Invoke(ctx, TaskService_SendNotification_FullMethodName, in, out, cOpts...)
 	if err != nil {
 		return nil, err
 	}
@@ -124,7 +133,7 @@ func RegisterTaskServiceServer(s grpc.ServiceRegistrar, srv TaskServiceServer) {
 }
 
 func _TaskService_Subscribe_Handler(srv interface{}, stream grpc.ServerStream) error {
-	return srv.(TaskServiceServer).Subscribe(&taskServiceSubscribeServer{stream})
+	return srv.(TaskServiceServer).Subscribe(&taskServiceSubscribeServer{ServerStream: stream})
 }
 
 type TaskService_SubscribeServer interface {
@@ -159,7 +168,7 @@ func _TaskService_Fetch_Handler(srv interface{}, ctx context.Context, dec func(i
 	}
 	info := &grpc.UnaryServerInfo{
 		Server:     srv,
-		FullMethod: "/grpc.TaskService/Fetch",
+		FullMethod: TaskService_Fetch_FullMethodName,
 	}
 	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
 		return srv.(TaskServiceServer).Fetch(ctx, req.(*Request))
@@ -177,7 +186,7 @@ func _TaskService_SendNotification_Handler(srv interface{}, ctx context.Context,
 	}
 	info := &grpc.UnaryServerInfo{
 		Server:     srv,
-		FullMethod: "/grpc.TaskService/SendNotification",
+		FullMethod: TaskService_SendNotification_FullMethodName,
 	}
 	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
 		return srv.(TaskServiceServer).SendNotification(ctx, req.(*Request))