add code

.idea/.gitignore

+# Default ignored files
+/shelf/
+/workspace.xml
+# Editor-based HTTP Client requests
+/httpRequests/
+# Datasource local storage ignored files
+/dataSources/
+/dataSources.local.xml
+# GitHub Copilot persisted chat sessions
+/copilot/chatSessions

.idea/modules.xml

+<?xml version="1.0" encoding="UTF-8"?>
+<project version="4">
+  <component name="ProjectModuleManager">
+    <modules>
+      <module fileurl="file://$PROJECT_DIR$/.idea/mogo.iml" filepath="$PROJECT_DIR$/.idea/mogo.iml" />
+    </modules>
+  </component>
+</project>
\ No newline at end of file

.idea/mogo.iml

+<?xml version="1.0" encoding="UTF-8"?>
+<module type="WEB_MODULE" version="4">
+  <component name="Go" enabled="true" />
+  <component name="NewModuleRootManager">
+    <content url="file://$MODULE_DIR$">
+      <excludeFolder url="file://$MODULE_DIR$/.idea/copilot/chatSessions" />
+    </content>
+    <orderEntry type="inheritedJdk" />
+    <orderEntry type="sourceFolder" forTests="false" />
+  </component>
+</module>
\ No newline at end of file

.idea/vcs.xml

+<?xml version="1.0" encoding="UTF-8"?>
+<project version="4">
+  <component name="VcsDirectoryMappings">
+    <mapping directory="" vcs="Git" />
+  </component>
+</project>
\ No newline at end of file

db/db.go

+package db
+
+import (
+	"context"
+	"time"
+
+	"go.mongodb.org/mongo-driver/mongo"
+	"go.mongodb.org/mongo-driver/mongo/options"
+)
+
+func ConnectMongoDB(uri string, username, passwd string) (*mongo.Client, error) {
+	ctx, _ := context.WithTimeout(context.Background(), 10*time.Second)
+	client, err := mongo.Connect(ctx, options.Client().ApplyURI(uri).SetAuth(options.Credential{
+		Username: username,
+		Password: passwd,
+	}))
+	if err != nil {
+		return nil, err
+	}
+
+	return client, nil
+}

db/taskinfo.go

+package db
+
+type DbTaskInfo struct {
+	ID                string `bson:"_id,omitempty" json:"id"`
+	TaskId            int32  `json:"task_id"` // 任务类型id
+	Name              string `json:"name"`
+	Desc              string `json:"desc"`  // 任务类型描述
+	Price             int64  `json:"price"` // 该任务类型的费用
+	PublicKey         string `json:"public_key"`
+	Complexity        int8   `json:"complexity"`
+	HardwareRequire   string `json:"hardware_require"`
+	ImageId           string `json:"image_id"`
+	ImageUrl          string `json:"image_url"`
+	ImageName         string `json:"image_name"`
+	SignUrl           string `json:"sign_url"`
+	Username          string `json:"username"`
+	Password          string `json:"password"`
+	Cmd               string `json:"cmd"`
+	Workload          int32  `json:"workload"`
+	ApiPath           string `json:"api_path"`
+	Type              int8   `json:"type"` // 类型 1=txt2img 2=txt2txt 3=txt2video
+	BaseModel         string `json:"base_model"`
+	Model             string `json:"model"`
+	Examples          string `json:"examples"`
+	ApiDocUrl         string `json:"api_doc_url"`
+	ApiDocContent     string `json:"api_doc_content"`
+	Codes             string `json:"codes"`
+	Tags              string `json:"tags"`
+	Kind              int8   `json:"kind"` // 任务种类 SystemTask = 0; ComputeTask = 1; CustomTask = 2; StandardTask = 3;
+	Category          int8   `json:"category"`
+	ResultFileExpires int32  `json:"result_file_expires"`
+	Version           string `json:"version"`
+	Form              string `json:"form"`
+	AccessStatus      int8   `json:"access_status"`    // 接入状体啊 1= 公开 2-= 私有
+	EstimatExeTime    int32  `json:"estimat_exe_time"` // 预计执行时长
+	Unit              string `json:"unit"`
+	PublishStatus     int8   `json:"publish_status"` // 发布状态 1= 发布 2= 取消发布
+	MaxExecTime       int32  `json:"max_exec_time"`  // 任务执行超时时间
+}

db/workerInstalledInfo.go

+package db
+
+import (
+	"context"
+	"go.mongodb.org/mongo-driver/bson"
+	"go.mongodb.org/mongo-driver/mongo"
+	"go.mongodb.org/mongo-driver/mongo/options"
+)
+
+type WorkerInstalledInfo struct {
+	ID       string `bson:"_id,omitempty" json:"id"`
+	WorkerId string `bson:"worker_id" json:"worker_id"` // use worker MinerPubkey
+	ModelId  int    `bson:"model_id" json:"model_id"`   // installed model.
+	GpuFree  int64  `bson:"gpu_free" json:"gpu_free"`
+}
+
+type WorkerInstalledOperator struct {
+	client *mongo.Client
+	col    *mongo.Collection
+}
+
+func NewDBWorkerInstalled(client *mongo.Client, database string) *WorkerInstalledOperator {
+	return &WorkerInstalledOperator{
+		client: client,
+		col:    client.Database(database).Collection("worker_running_info"),
+	}
+}
+
+func (d *WorkerInstalledOperator) Insert(ctx context.Context, worker *WorkerRunningInfo) (*mongo.InsertOneResult, error) {
+	return d.col.InsertOne(ctx, worker)
+}
+
+func (d *WorkerInstalledOperator) UpdateGpuFree(ctx context.Context, id string, gpuFree int64) error {
+	update := bson.M{"$set": bson.M{"gpu_free": gpuFree}}
+	_, err := d.col.UpdateOne(ctx, bson.M{"_id": id}, update)
+	return err
+}
+
+func (d *WorkerInstalledOperator) FindWorkerByModelId(ctx context.Context, modelId int, limit int) ([]*WorkerInstalledInfo, error) {
+	// find all worker that at least one installed model's mode_id is equal modelId
+	// sort by wait time
+	findOptions := options.Find()
+	findOptions.SetLimit(int64(limit))
+	findOptions.SetSort(bson.D{{"exec_time", 1}})
+
+	selector := bson.M{"model_id": modelId}
+	cursor, err := d.col.Find(ctx, selector, findOptions)
+	if err != nil {
+		return nil, err
+	}
+	defer cursor.Close(ctx)
+
+	var workers []*WorkerInstalledInfo
+	if err = cursor.All(ctx, &workers); err != nil {
+		return nil, err
+	}
+	return workers, nil
+}

db/workerRunningInfo.go

+package db
+
+import (
+	"context"
+	"go.mongodb.org/mongo-driver/bson"
+	"go.mongodb.org/mongo-driver/mongo"
+	"go.mongodb.org/mongo-driver/mongo/options"
+)
+
+type WorkerRunningInfo struct {
+	ID       string `bson:"_id,omitempty" json:"id"`
+	WorkerId string `bson:"worker_id" json:"worker_id"` // use worker MinerPubkey
+	ModelId  int    `bson:"model_id" json:"model_id"`
+	ExecTime int    `bson:"exec_time" json:"exec_time"`
+}
+
+type WorkerRunningOperator struct {
+	client *mongo.Client
+	col    *mongo.Collection
+}
+
+func NewDBWorkerRunning(client *mongo.Client, database string) *WorkerRunningOperator {
+	return &WorkerRunningOperator{
+		client: client,
+		col:    client.Database(database).Collection("worker_running_info"),
+	}
+}
+
+func (d *WorkerRunningOperator) Insert(ctx context.Context, worker *WorkerRunningInfo) (*mongo.InsertOneResult, error) {
+	return d.col.InsertOne(ctx, worker)
+}
+
+func (d *WorkerRunningOperator) UpdateExecTime(ctx context.Context, id string, execTime int) error {
+	update := bson.M{"$set": bson.M{"exec_time": execTime}}
+	_, err := d.col.UpdateOne(ctx, bson.M{"_id": id}, update)
+	return err
+}
+
+func (d *WorkerRunningOperator) FindWorkerByModelId(ctx context.Context, modelId int, limit int) ([]*WorkerRunningInfo, error) {
+	// find all worker that at least one running model's mode_id is equal modelId
+	// sort by wait time
+	findOptions := options.Find()
+	findOptions.SetLimit(int64(limit))
+	findOptions.SetSort(bson.D{{"exec_time", 1}})
+
+	selector := bson.M{"model_id": modelId}
+	cursor, err := d.col.Find(ctx, selector, findOptions)
+	if err != nil {
+		return nil, err
+	}
+	defer cursor.Close(ctx)
+
+	var workers []*WorkerRunningInfo
+	if err = cursor.All(ctx, &workers); err != nil {
+		return nil, err
+	}
+	return workers, nil
+}

db/workerinfo.go

+package db
+
+import (
+	"context"
+	"go.mongodb.org/mongo-driver/bson"
+	"go.mongodb.org/mongo-driver/mongo"
+	"go.mongodb.org/mongo-driver/mongo/options"
+	"mogo/types"
+)
+
+type WorkerInfo struct {
+	ID       string              `bson:"_id,omitempty" json:"id"`
+	WorkerId string              `bson:"worker_id" json:"worker_id"` // use worker MinerPubkey
+	NodeInfo *types.NodeInfo     `bson:"node_info" json:"node_info"`
+	Models   *types.ModelInfo    `bson:"model_infos" json:"model_infos"`
+	Hardware *types.HardwareInfo `bson:"hardware" json:"hardware"`
+}
+
+type WorkerInfoOperator struct {
+	client *mongo.Client
+	col    *mongo.Collection
+}
+
+func NewDBWorker(client *mongo.Client, database string) *WorkerInfoOperator {
+	return &WorkerInfoOperator{
+		client: client,
+		col:    client.Database(database).Collection("workerinfo"),
+	}
+}
+
+func (d *WorkerInfoOperator) InsertWorker(ctx context.Context, worker *WorkerInfo) (*mongo.InsertOneResult, error) {
+	return d.col.InsertOne(ctx, worker)
+}
+
+func (d *WorkerInfoOperator) UpdateModel(ctx context.Context, id string, models *types.ModelInfo) error {
+	update := bson.M{"$set": bson.M{"model_infos": models}}
+	_, err := d.col.UpdateOne(ctx, bson.M{"_id": id}, update)
+	return err
+}
+
+func (d *WorkerInfoOperator) UpdateHardware(ctx context.Context, id string, hardware *types.HardwareInfo) error {
+	update := bson.M{"$set": bson.M{"hardware": hardware}}
+	_, err := d.col.UpdateOne(ctx, bson.M{"_id": id}, update)
+	return err
+}
+
+func (d *WorkerInfoOperator) UpdateNodeInfo(ctx context.Context, id string, nodeInfo *types.NodeInfo) error {
+	update := bson.M{"$set": bson.M{"node_info": nodeInfo}}
+	_, err := d.col.UpdateOne(ctx, bson.M{"_id": id}, update)
+	return err
+}
+
+func (d *WorkerInfoOperator) FindWorkerByRunningModelAndSortByWaitTime(ctx context.Context, modelId string, limit int) ([]*WorkerInfo, error) {
+	// find all worker that at least one running model's mode_id is equal modelId
+	// sort by wait time
+	findOptions := options.Find()
+	findOptions.SetLimit(int64(limit))
+	findOptions.SetSort(bson.D{{"model_infos.running_models.wait_time", 1}})
+
+	selector := bson.M{"model_infos.running_models.model_id": modelId}
+	cursor, err := d.col.Find(ctx, selector, findOptions)
+	if err != nil {
+		return nil, err
+	}
+	defer cursor.Close(ctx)
+
+	var workers []*WorkerInfo
+	if err = cursor.All(ctx, &workers); err != nil {
+		return nil, err
+	}
+	return workers, nil
+}
+
+func (d *WorkerInfoOperator) FindWorkerByInstallModelAndSortByGpuRam(ctx context.Context, modelId string, performance int, ram int64, limit int) ([]*WorkerInfo, error) {
+	// find all worker that at least one installed model's mode_id is equal modelId
+	// sort by gpu ram
+	findOptions := options.Find()
+	findOptions.SetLimit(int64(limit))
+	findOptions.SetSort(bson.D{{"hardware.gpu.ram", 1}})
+
+	selector := bson.M{"model_infos.installed_models.model_id": modelId, "hardware.gpu.performance": bson.M{"$gte": performance}, "hardware.gpu.ram": bson.M{"$gte": ram}}
+	cursor, err := d.col.Find(ctx, selector, findOptions)
+	if err != nil {
+		return nil, err
+	}
+	defer cursor.Close(ctx)
+
+	var workers []*WorkerInfo
+	if err = cursor.All(ctx, &workers); err != nil {
+		return nil, err
+	}
+	return workers, nil
+}
+
+func (d *WorkerInfoOperator) FindWorkerByWorkerId(ctx context.Context, workerId string) (*WorkerInfo, error) {
+	var worker *WorkerInfo
+	err := d.col.FindOne(ctx, bson.M{"worker_id": workerId}).Decode(&worker)
+	return worker, err
+}

db/workerinfo_test.go

+package db
+
+import (
+	"context"
+	crand "crypto/rand"
+	"encoding/hex"
+	"fmt"
+	"github.com/google/uuid"
+	"go.mongodb.org/mongo-driver/bson/primitive"
+	"go.mongodb.org/mongo-driver/mongo"
+	"log"
+	"math/rand"
+	"mogo/types"
+	"strconv"
+	"testing"
+	"time"
+)
+
+var (
+	maxModelId = 10000
+	idlist     = make([]string, 0, 1000000)
+	//workers    = make([]*DbWorkerInfo, 0, 1000000)
+	database                = "test"
+	collection              = "workers"
+	workerRunningCollection = "worker_running"
+)
+
+func init() {
+	client, err := ConnectMongoDB("mongodb://localhost:27017", "admin", "admin")
+	if err != nil {
+		log.Fatal(err)
+	}
+	idlist = initdata(client)
+}
+
+func initdata(client *mongo.Client) []string {
+	t1 := time.Now()
+	db := NewDBWorker(client, database)
+	dbRunning := NewDBWorkerRunning(client, database)
+
+	// Insert 1,000,000 DbWorkerInfo to db
+	for i := 0; i < 1000; i++ {
+		worker := generateAWroker()
+		result, err := db.InsertWorker(context.Background(), worker)
+		if err != nil {
+			panic(fmt.Sprintf("insert worker failed with err:%s", err))
+		}
+		{
+			// add worker running info to dbRunning
+			for _, model := range worker.Models.RunningModels {
+				id, _ := strconv.Atoi(model.ModelID)
+				runningInfo := &WorkerRunningInfo{
+					WorkerId: worker.WorkerId,
+					ModelId:  id,
+					ExecTime: model.ExecTime,
+				}
+				_, err := dbRunning.Insert(context.Background(), runningInfo)
+				if err != nil {
+					panic(fmt.Sprintf("insert worker failed with err:%s", err))
+				}
+			}
+		}
+
+		id, ok := result.InsertedID.(primitive.ObjectID)
+		if !ok {
+			panic("inserted id is not primitive.ObjectID")
+		}
+		idlist = append(idlist, id.Hex())
+		//fmt.Printf("insert worker %s: %v\n", id.Hex(), worker)
+	}
+	t2 := time.Now()
+	fmt.Printf("init data cost %s\n", t2.Sub(t1).String())
+	return idlist
+}
+
+func getRandId(max int) string {
+	return strconv.Itoa(rand.Intn(max) + 1)
+}
+
+func getRandIdInt(max int) int {
+	return rand.Intn(max) + 1
+}
+
+func generateAWroker() *WorkerInfo {
+	return &WorkerInfo{
+		WorkerId: uuid.NewString(),
+		NodeInfo: generateANodeInfo(),
+		Models:   generateAModel(),
+		Hardware: generateAHardware(),
+	}
+}
+
+func generateANodeInfo() *types.NodeInfo {
+	x := make([]byte, 32)
+	y := make([]byte, 32)
+	z := make([]byte, 20)
+	crand.Read(x)
+	crand.Read(y)
+	crand.Read(z)
+
+	return &types.NodeInfo{
+		MinerPubkey:    hex.EncodeToString(x) + hex.EncodeToString(y),
+		BenefitAddress: hex.EncodeToString(z),
+	}
+}
+
+func generateACpu() *types.CpuInfo {
+	return &types.CpuInfo{
+		Model:   "Intel(R) Core(TM) i7-8700 CPU @ 3.20GHz",
+		Number:  1,
+		Cores:   8,
+		Threads: 16,
+		Usage:   int(rand.Intn(30) + 40),
+	}
+}
+
+func generateADisk() *types.DiskInfo {
+	return &types.DiskInfo{
+		Total: 1024 * 1024 * 1024,
+		Free:  100 * 1024 * 1024,
+	}
+}
+
+func generateANet() *types.NetInfo {
+	return &types.NetInfo{
+		IP:        fmt.Sprintf("192.168.1.%d", rand.Intn(255)),
+		Mac:       fmt.Sprintf("%02x:%02x:%02x:%02x:%02x:%02x", 1, 2, 3, 4, 5, 6),
+		Bandwidth: rand.Intn(30) + 60,
+	}
+}
+
+func generateARam() *types.RamInfo {
+	return &types.RamInfo{
+		Total: 32 * 1024 * 1024 * 1024,
+		Free:  int64(rand.Intn(10) * 1024 * 1024 * 1024),
+	}
+}
+
+func generateAGpuRam() int64 {
+	return 1024 * 1024 * 1024 * int64(rand.Intn(3)*8+8) // 8, 16, 24
+}
+
+func generateAGpuModel() string {
+	m := rand.Intn(4)*10 + 3060 // 3060 ~ 3090
+	return fmt.Sprintf("Nvidia %d", m)
+}
+
+func generateAGpuPerformance() int {
+	return rand.Intn(100) + 500
+}
+
+func generateAIdleGpu(seq int) *types.GpuInfo {
+	ram := generateAGpuRam()
+	return &types.GpuInfo{
+		Seq:         seq,
+		UUID:        uuid.NewString(),
+		Model:       generateAGpuModel(),
+		Performance: generateAGpuPerformance(),
+		PowerRating: 100,
+		MemTotal:    ram,
+		MemFree:     ram,
+		Usage:       0,
+		Temp:        40,
+		PowerRt:     30,
+	}
+}
+
+func generateAUsageGpu(seq int) *types.GpuInfo {
+	ram := generateAGpuRam()
+	return &types.GpuInfo{
+		Seq:         seq,
+		UUID:        uuid.NewString(),
+		Model:       generateAGpuModel(),
+		Performance: generateAGpuPerformance(),
+		PowerRating: 100,
+		MemTotal:    ram,
+		MemFree:     ram * int64(rand.Intn(3)+3) / 10,
+		Usage:       rand.Intn(20) + 70,
+		Temp:        40,
+		PowerRt:     30,
+	}
+}
+
+func generateAHardware() *types.HardwareInfo {
+	return &types.HardwareInfo{
+		CPU: generateACpu(),
+		GPU: []*types.GpuInfo{
+			generateAIdleGpu(0),
+			generateAIdleGpu(1),
+			generateAUsageGpu(2),
+		},
+		RAM:  generateARam(),
+		DISK: generateADisk(),
+		NET:  generateANet(),
+	}
+}
+
+func generateAInstallModel() *types.InstalledModel {
+	return &types.InstalledModel{
+		ModelID:       getRandId(maxModelId),
+		DiskSize:      101,
+		InstalledTime: time.Now().Unix(),
+		LastRunTime:   time.Now().Unix(),
+	}
+}
+
+func generateARunningModel() *types.RunningModel {
+	return &types.RunningModel{
+		ModelID:       getRandId(maxModelId),
+		GpuSeq:        rand.Intn(3),
+		GpuRAM:        generateAGpuRam(),
+		StartedTime:   time.Now().Unix(),
+		LastWorkTime:  time.Now().Unix(),
+		TotalRunCount: rand.Intn(100),
+		ExecTime:      rand.Intn(100),
+	}
+}
+
+func generateAModel() *types.ModelInfo {
+	m := &types.ModelInfo{
+		InstalledModels: make([]*types.InstalledModel, 0, 1000),
+		RunningModels:   make([]*types.RunningModel, 0, 1000),
+	}
+	for i := 0; i < 500; i++ {
+		m.InstalledModels = append(m.InstalledModels, generateAInstallModel())
+		if len(m.RunningModels) < 500 {
+			m.RunningModels = append(m.RunningModels, generateARunningModel())
+		}
+	}
+	return m
+}
+
+func BenchmarkGenerateWorker(b *testing.B) {
+	for i := 0; i < b.N; i++ {
+		generateAWroker()
+	}
+}
+
+func BenchmarkDbWorker_InsertWorker(b *testing.B) {
+	client, err := ConnectMongoDB("mongodb://localhost:27017", "admin", "admin")
+	if err != nil {
+		log.Fatal(err)
+	}
+	db := NewDBWorker(client, database)
+	defer db.client.Disconnect(context.Background())
+	b.ResetTimer()
+	for i := 0; i < b.N; i++ {
+		b.StopTimer()
+		worker := generateAWroker()
+		b.StartTimer()
+		if _, err := db.InsertWorker(context.Background(), worker); err != nil {
+			panic(fmt.Sprintf("insert worker failed with err:%s", err))
+		}
+	}
+}
+
+func BenchmarkDbWorker_InsertWorker_Parallel(b *testing.B) {
+	client, err := ConnectMongoDB("mongodb://localhost:27017", "admin", "admin")
+	if err != nil {
+		log.Fatal(err)
+	}
+	db := NewDBWorker(client, database)
+	defer db.client.Disconnect(context.Background())
+	b.RunParallel(func(pb *testing.PB) {
+		for pb.Next() {
+			worker := generateAWroker()
+			if _, err := db.InsertWorker(context.Background(), worker); err != nil {
+				panic(fmt.Sprintf("insert worker failed with err:%s", err))
+			}
+		}
+	})
+}
+
+func BenchmarkDbWorker_UpdateHardware(b *testing.B) {
+	client, err := ConnectMongoDB("mongodb://localhost:27017", "admin", "admin")
+	if err != nil {
+		log.Fatal(err)
+	}
+	db := NewDBWorker(client, database)
+	defer db.client.Disconnect(context.Background())
+
+	b.ResetTimer()
+	for i := 0; i < b.N; i++ {
+		b.StopTimer()
+
+		idx := rand.Intn(len(idlist))
+		nhardware := generateAHardware()
+
+		b.StartTimer()
+		if err := db.UpdateHardware(context.Background(), idlist[idx], nhardware); err != nil {
+			panic(fmt.Sprintf("update worker failed with err:%s", err))
+		}
+	}
+}
+
+func BenchmarkDbWorker_UpdateHardware_Parallel(b *testing.B) {
+	client, err := ConnectMongoDB("mongodb://localhost:27017", "admin", "admin")
+	if err != nil {
+		log.Fatal(err)
+	}
+	db := NewDBWorker(client, database)
+	defer db.client.Disconnect(context.Background())
+
+	b.RunParallel(func(pb *testing.PB) {
+		for pb.Next() {
+			idx := rand.Intn(len(idlist))
+			nhardware := generateAHardware()
+			if err := db.UpdateHardware(context.Background(), idlist[idx], nhardware); err != nil {
+				panic(fmt.Sprintf("update worker failed with err:%s", err))
+			}
+		}
+	})
+}
+
+func BenchmarkDbWorker_UpdateModel(b *testing.B) {
+	client, err := ConnectMongoDB("mongodb://localhost:27017", "admin", "admin")
+	if err != nil {
+		log.Fatal(err)
+	}
+	b.ResetTimer()
+
+	db := NewDBWorker(client, database)
+	defer db.client.Disconnect(context.Background())
+	for i := 0; i < b.N; i++ {
+		idx := rand.Intn(len(idlist))
+		nresource := generateAModel()
+		if err := db.UpdateModel(context.Background(), idlist[idx], nresource); err != nil {
+			panic(fmt.Sprintf("update worker failed with err:%s", err))
+		}
+	}
+}
+
+func BenchmarkDbWorker_UpdateModel_Parallel(b *testing.B) {
+	client, err := ConnectMongoDB("mongodb://localhost:27017", "admin", "admin")
+	if err != nil {
+		log.Fatal(err)
+	}
+
+	db := NewDBWorker(client, database)
+	defer db.client.Disconnect(context.Background())
+	b.RunParallel(func(pb *testing.PB) {
+		for pb.Next() {
+			idx := rand.Intn(len(idlist))
+			nresource := generateAModel()
+			if err := db.UpdateModel(context.Background(), idlist[idx], nresource); err != nil {
+				panic(fmt.Sprintf("update worker failed with err:%s", err))
+			}
+		}
+	})
+}
+
+func BenchmarkDbWorker_UpdateNodeInfo(b *testing.B) {
+	client, err := ConnectMongoDB("mongodb://localhost:27017", "admin", "admin")
+	if err != nil {
+		log.Fatal(err)
+	}
+	b.ResetTimer()
+	nnodeinfo := generateANodeInfo()
+
+	db := NewDBWorker(client, database)
+	defer db.client.Disconnect(context.Background())
+	for i := 0; i < b.N; i++ {
+		idx := rand.Intn(len(idlist))
+		if err := db.UpdateNodeInfo(context.Background(), idlist[idx], nnodeinfo); err != nil {
+			panic(fmt.Sprintf("update worker failed with err:%s", err))
+		}
+	}
+}
+
+func BenchmarkDbWorker_UpdateNodeInfo_Parallel(b *testing.B) {
+	client, err := ConnectMongoDB("mongodb://localhost:27017", "admin", "admin")
+	if err != nil {
+		log.Fatal(err)
+	}
+	nnodeinfo := generateANodeInfo()
+	db := NewDBWorker(client, database)
+	defer db.client.Disconnect(context.Background())
+	b.RunParallel(func(pb *testing.PB) {
+		for pb.Next() {
+			idx := rand.Intn(len(idlist))
+			if err := db.UpdateNodeInfo(context.Background(), idlist[idx], nnodeinfo); err != nil {
+				panic(fmt.Sprintf("update worker failed with err:%s", err))
+			}
+		}
+	})
+}
+
+func BenchmarkDbWorker_FindWorkerByInstallModelAndSortByGpuRam(b *testing.B) {
+	client, err := ConnectMongoDB("mongodb://localhost:27017", "admin", "admin")
+	if err != nil {
+		log.Fatal(err)
+	}
+	db := NewDBWorker(client, database)
+	defer db.client.Disconnect(context.Background())
+	b.ResetTimer()
+	for i := 0; i < b.N; i++ {
+		installedModelId := getRandId(maxModelId)
+		performance := generateAGpuPerformance()
+		ram := generateAGpuRam()
+		if w, err := db.FindWorkerByInstallModelAndSortByGpuRam(context.Background(), installedModelId, performance, ram, 10); err != nil {
+			panic(fmt.Sprintf("find worker failed with err:%s", err))
+		} else if len(w) == 0 {
+			b.Logf("FindWorkerByInstallModelAndSortByGpuRam find %d with id %s\n", len(w), installedModelId)
+		}
+	}
+}
+
+func BenchmarkDbWorker_FindWorkerByInstallModelAndSortByGpuRam_Parallel(b *testing.B) {
+	client, err := ConnectMongoDB("mongodb://localhost:27017", "admin", "admin")
+	if err != nil {
+		log.Fatal(err)
+	}
+	db := NewDBWorker(client, database)
+	defer db.client.Disconnect(context.Background())
+	b.RunParallel(func(pb *testing.PB) {
+		for pb.Next() {
+			installedModelId := getRandId(maxModelId)
+			performance := generateAGpuPerformance()
+			ram := generateAGpuRam()
+			if w, err := db.FindWorkerByInstallModelAndSortByGpuRam(context.Background(), installedModelId, performance, ram, 10); err != nil {
+				panic(fmt.Sprintf("find worker failed with err:%s", err))
+			} else if len(w) == 0 {
+				b.Logf("FindWorkerByInstallModelAndSortByGpuRam find %d with id %s\n", len(w), installedModelId)
+			}
+		}
+	})
+}
+
+func BenchmarkDbWorker_FindWorkerByRunningModelAndSortByWaitTime(b *testing.B) {
+	client, err := ConnectMongoDB("mongodb://localhost:27017", "admin", "admin")
+	if err != nil {
+		log.Fatal(err)
+	}
+	db := NewDBWorker(client, database)
+	defer db.client.Disconnect(context.Background())
+	b.ResetTimer()
+	for i := 0; i < b.N; i++ {
+		runningModelId := getRandId(maxModelId)
+		if w, err := db.FindWorkerByRunningModelAndSortByWaitTime(context.Background(), runningModelId, 10); err != nil {
+			panic(fmt.Sprintf("find worker failed with err:%s", err))
+		} else if len(w) == 0 {
+			b.Logf("FindWorkerByRunningModelAndSortByWaitTime find %d with id %s\n", len(w), runningModelId)
+		}
+	}
+}
+
+func BenchmarkDbWorker_FindWorkerByRunningModelAndSortByWaitTime_Parallel(b *testing.B) {
+	client, err := ConnectMongoDB("mongodb://localhost:27017", "admin", "admin")
+	if err != nil {
+		log.Fatal(err)
+	}
+	db := NewDBWorker(client, database)
+	defer db.client.Disconnect(context.Background())
+	b.RunParallel(func(pb *testing.PB) {
+		for pb.Next() {
+			runningModelId := getRandId(maxModelId)
+			if w, err := db.FindWorkerByRunningModelAndSortByWaitTime(context.Background(), runningModelId, 10); err != nil {
+				panic(fmt.Sprintf("find worker failed with err:%s", err))
+			} else if len(w) == 0 {
+				b.Logf("FindWorkerByRunningModelAndSortByWaitTime find %d with id %s\n", len(w), runningModelId)
+			}
+		}
+	})
+}
+
+func BenchmarkDbWorkerRunning_FindWorkerByModelId(b *testing.B) {
+	client, err := ConnectMongoDB("mongodb://localhost:27017", "admin", "admin")
+	if err != nil {
+		log.Fatal(err)
+	}
+	db := NewDBWorkerRunning(client, database)
+	defer db.client.Disconnect(context.Background())
+	b.ResetTimer()
+	for i := 0; i < b.N; i++ {
+		modelId := getRandIdInt(maxModelId)
+		if w, err := db.FindWorkerByModelId(context.Background(), modelId, 10); err != nil {
+			panic(fmt.Sprintf("find worker failed with err:%s", err))
+		} else if len(w) == 0 {
+			b.Logf("FindWorkerByModelId find %d with id %d\n", len(w), modelId)
+		}
+	}
+}
+
+func BenchmarkDbWorkerRunning_FindWorkerByModelId_Parallel(b *testing.B) {
+	client, err := ConnectMongoDB("mongodb://localhost:27017", "admin", "admin")
+	if err != nil {
+		log.Fatal(err)
+	}
+	db := NewDBWorkerRunning(client, database)
+	defer db.client.Disconnect(context.Background())
+	b.RunParallel(func(pb *testing.PB) {
+		for pb.Next() {
+			modelId := getRandIdInt(maxModelId)
+			if w, err := db.FindWorkerByModelId(context.Background(), modelId, 10); err != nil {
+				panic(fmt.Sprintf("find worker failed with err:%s", err))
+			} else if len(w) == 0 {
+				b.Logf("FindWorkerByModelId find %d with id %d\n", len(w), modelId)
+			}
+		}
+	})
+}

docker-compose.yml

+version: "3.5"
+
+services:
+  redis:
+    container_name: "redis"
+    image: "redis:latest"
+    restart: always
+    networks:
+      - default
+    environment:
+      - TZ=Asia/Shanghai
+    command: /usr/local/bin/redis-server /etc/redis/redis.conf
+    ports:
+      - "6379:6379"
+    volumes:
+      - "/etc/localtime:/etc/localtime"
+  mongo:
+    image: mongo:latest
+    container_name: mongo
+    environment:
+      MONGO_INITDB_ROOT_USERNAME: admin
+      MONGO_INITDB_ROOT_PASSWORD: admin
+    ports:
+      - "0.0.0.0:27017:27017"
+    networks:
+      - MONGO
+    volumes:
+      - type: volume
+        source: MONGO_DATA
+        target: /data/db
+      - type: volume
+        source: MONGO_CONFIG
+        target: /data/configdb
+  mongo-express:
+    image: mongo-express:latest
+    container_name: mongo-express
+    environment:
+      ME_CONFIG_MONGODB_ADMINUSERNAME: admin
+      ME_CONFIG_MONGODB_ADMINPASSWORD: admin
+      ME_CONFIG_MONGODB_SERVER: mongo
+      ME_CONFIG_MONGODB_PORT: "27017"
+    ports:
+      - "0.0.0.0:8081:8081"
+    networks:
+      - MONGO
+    depends_on:
+      - mongo
+
+networks:
+  MONGO:
+    name: MONGO
+
+volumes:
+  MONGO_DATA:
+    name: MONGO_DATA
+  MONGO_CONFIG:
+    name: MONGO_CONFIG
\ No newline at end of file

go.mod

+module mogo
+
+go 1.21
+
+require (
+	github.com/google/uuid v1.6.0
+	github.com/odysseus/odysseus-protocol v0.0.0-00010101000000-000000000000
+	go.mongodb.org/mongo-driver v1.15.0
+)
+
+require (
+	github.com/gogo/protobuf v1.3.2 // indirect
+	github.com/golang/protobuf v1.5.3 // indirect
+	github.com/golang/snappy v0.0.1 // indirect
+	github.com/klauspost/compress v1.13.6 // indirect
+	github.com/montanaflynn/stats v0.0.0-20171201202039-1bf9dbcd8cbe // indirect
+	github.com/xdg-go/pbkdf2 v1.0.0 // indirect
+	github.com/xdg-go/scram v1.1.2 // indirect
+	github.com/xdg-go/stringprep v1.0.4 // indirect
+	github.com/youmark/pkcs8 v0.0.0-20181117223130-1be2e3e5546d // indirect
+	golang.org/x/crypto v0.17.0 // indirect
+	golang.org/x/net v0.16.0 // indirect
+	golang.org/x/sync v0.4.0 // indirect
+	golang.org/x/sys v0.15.0 // indirect
+	golang.org/x/text v0.14.0 // indirect
+	google.golang.org/genproto/googleapis/rpc v0.0.0-20231002182017-d307bd883b97 // indirect
+	google.golang.org/grpc v1.60.1 // indirect
+	google.golang.org/protobuf v1.32.0 // indirect
+)
+
+replace github.com/odysseus/odysseus-protocol => ../odysseus-protocol

go.sum

+github.com/davecgh/go-spew v1.1.1 h1:vj9j/u1bqnvCEfJOwUhtlOARqs3+rkHYY13jYWTU97c=
+github.com/davecgh/go-spew v1.1.1/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38=
+github.com/gogo/protobuf v1.3.2 h1:Ov1cvc58UF3b5XjBnZv7+opcTcQFZebYjWzi34vdm4Q=
+github.com/gogo/protobuf v1.3.2/go.mod h1:P1XiOD3dCwIKUDQYPy72D8LYyHL2YPYrpS2s69NZV8Q=
+github.com/golang/protobuf v1.5.0/go.mod h1:FsONVRAS9T7sI+LIUmWTfcYkHO4aIWwzhcaSAoJOfIk=
+github.com/golang/protobuf v1.5.3 h1:KhyjKVUg7Usr/dYsdSqoFveMYd5ko72D+zANwlG1mmg=
+github.com/golang/protobuf v1.5.3/go.mod h1:XVQd3VNwM+JqD3oG2Ue2ip4fOMUkwXdXDdiuN0vRsmY=
+github.com/golang/snappy v0.0.1 h1:Qgr9rKW7uDUkrbSmQeiDsGa8SjGyCOGtuasMWwvp2P4=
+github.com/golang/snappy v0.0.1/go.mod h1:/XxbfmMg8lxefKM7IXC3fBNl/7bRcc72aCRzEWrmP2Q=
+github.com/google/go-cmp v0.5.5/go.mod h1:v8dTdLbMG2kIc/vJvl+f65V22dbkXbowE6jgT/gNBxE=
+github.com/google/go-cmp v0.5.9 h1:O2Tfq5qg4qc4AmwVlvv0oLiVAGB7enBSJ2x2DqQFi38=
+github.com/google/go-cmp v0.5.9/go.mod h1:17dUlkBOakJ0+DkrSSNjCkIjxS6bF9zb3elmeNGIjoY=
+github.com/google/uuid v1.6.0 h1:NIvaJDMOsjHA8n1jAhLSgzrAzy1Hgr+hNrb57e+94F0=
+github.com/google/uuid v1.6.0/go.mod h1:TIyPZe4MgqvfeYDBFedMoGGpEw/LqOeaOT+nhxU+yHo=
+github.com/kisielk/errcheck v1.5.0/go.mod h1:pFxgyoBC7bSaBwPgfKdkLd5X25qrDl4LWUI2bnpBCr8=
+github.com/kisielk/gotool v1.0.0/go.mod h1:XhKaO+MFFWcvkIS/tQcRk01m1F5IRFswLeQ+oQHNcck=
+github.com/klauspost/compress v1.13.6 h1:P76CopJELS0TiO2mebmnzgWaajssP/EszplttgQxcgc=
+github.com/klauspost/compress v1.13.6/go.mod h1:/3/Vjq9QcHkK5uEr5lBEmyoZ1iFhe47etQ6QUkpK6sk=
+github.com/montanaflynn/stats v0.0.0-20171201202039-1bf9dbcd8cbe h1:iruDEfMl2E6fbMZ9s0scYfZQ84/6SPL6zC8ACM2oIL0=
+github.com/montanaflynn/stats v0.0.0-20171201202039-1bf9dbcd8cbe/go.mod h1:wL8QJuTMNUDYhXwkmfOly8iTdp5TEcJFWZD2D7SIkUc=
+github.com/xdg-go/pbkdf2 v1.0.0 h1:Su7DPu48wXMwC3bs7MCNG+z4FhcyEuz5dlvchbq0B0c=
+github.com/xdg-go/pbkdf2 v1.0.0/go.mod h1:jrpuAogTd400dnrH08LKmI/xc1MbPOebTwRqcT5RDeI=
+github.com/xdg-go/scram v1.1.2 h1:FHX5I5B4i4hKRVRBCFRxq1iQRej7WO3hhBuJf+UUySY=
+github.com/xdg-go/scram v1.1.2/go.mod h1:RT/sEzTbU5y00aCK8UOx6R7YryM0iF1N2MOmC3kKLN4=
+github.com/xdg-go/stringprep v1.0.4 h1:XLI/Ng3O1Atzq0oBs3TWm+5ZVgkq2aqdlvP9JtoZ6c8=
+github.com/xdg-go/stringprep v1.0.4/go.mod h1:mPGuuIYwz7CmR2bT9j4GbQqutWS1zV24gijq1dTyGkM=
+github.com/youmark/pkcs8 v0.0.0-20181117223130-1be2e3e5546d h1:splanxYIlg+5LfHAM6xpdFEAYOk8iySO56hMFq6uLyA=
+github.com/youmark/pkcs8 v0.0.0-20181117223130-1be2e3e5546d/go.mod h1:rHwXgn7JulP+udvsHwJoVG1YGAP6VLg4y9I5dyZdqmA=
+github.com/yuin/goldmark v1.1.27/go.mod h1:3hX8gzYuyVAZsxl0MRgGTJEmQBFcNTphYh9decYSb74=
+github.com/yuin/goldmark v1.2.1/go.mod h1:3hX8gzYuyVAZsxl0MRgGTJEmQBFcNTphYh9decYSb74=
+github.com/yuin/goldmark v1.4.13/go.mod h1:6yULJ656Px+3vBD8DxQVa3kxgyrAnzto9xy5taEt/CY=
+go.mongodb.org/mongo-driver v1.15.0 h1:rJCKC8eEliewXjZGf0ddURtl7tTVy1TK3bfl0gkUSLc=
+go.mongodb.org/mongo-driver v1.15.0/go.mod h1:Vzb0Mk/pa7e6cWw85R4F/endUC3u0U9jGcNU603k65c=
+golang.org/x/crypto v0.0.0-20190308221718-c2843e01d9a2/go.mod h1:djNgcEr1/C05ACkg1iLfiJU5Ep61QUkGW8qpdssI0+w=
+golang.org/x/crypto v0.0.0-20191011191535-87dc89f01550/go.mod h1:yigFU9vqHzYiE8UmvKecakEJjdnWj3jj499lnFckfCI=
+golang.org/x/crypto v0.0.0-20200622213623-75b288015ac9/go.mod h1:LzIPMQfyMNhhGPhUkYOs5KpL4U8rLKemX1yGLhDgUto=
+golang.org/x/crypto v0.0.0-20210921155107-089bfa567519/go.mod h1:GvvjBRRGRdwPK5ydBHafDWAxML/pGHZbMvKqRZ5+Abc=
+golang.org/x/crypto v0.17.0 h1:r8bRNjWL3GshPW3gkd+RpvzWrZAwPS49OmTGZ/uhM4k=
+golang.org/x/crypto v0.17.0/go.mod h1:gCAAfMLgwOJRpTjQ2zCCt2OcSfYMTeZVSRtQlPC7Nq4=
+golang.org/x/mod v0.2.0/go.mod h1:s0Qsj1ACt9ePp/hMypM3fl4fZqREWJwdYDEqhRiZZUA=
+golang.org/x/mod v0.3.0/go.mod h1:s0Qsj1ACt9ePp/hMypM3fl4fZqREWJwdYDEqhRiZZUA=
+golang.org/x/mod v0.6.0-dev.0.20220419223038-86c51ed26bb4/go.mod h1:jJ57K6gSWd91VN4djpZkiMVwK6gcyfeH4XE8wZrZaV4=
+golang.org/x/net v0.0.0-20190404232315-eb5bcb51f2a3/go.mod h1:t9HGtf8HONx5eT2rtn7q6eTqICYqUVnKs3thJo3Qplg=
+golang.org/x/net v0.0.0-20190620200207-3b0461eec859/go.mod h1:z5CRVTTTmAJ677TzLLGU+0bjPO0LkuOLi4/5GtJWs/s=
+golang.org/x/net v0.0.0-20200226121028-0de0cce0169b/go.mod h1:z5CRVTTTmAJ677TzLLGU+0bjPO0LkuOLi4/5GtJWs/s=
+golang.org/x/net v0.0.0-20201021035429-f5854403a974/go.mod h1:sp8m0HH+o8qH0wwXwYZr8TS3Oi6o0r6Gce1SSxlDquU=
+golang.org/x/net v0.0.0-20210226172049-e18ecbb05110/go.mod h1:m0MpNAwzfU5UDzcl9v0D8zg8gWTRqZa9RBIspLL5mdg=
+golang.org/x/net v0.0.0-20220722155237-a158d28d115b/go.mod h1:XRhObCWvk6IyKnWLug+ECip1KBveYUHfp+8e9klMJ9c=
+golang.org/x/net v0.16.0 h1:7eBu7KsSvFDtSXUIDbh3aqlK4DPsZ1rByC8PFfBThos=
+golang.org/x/net v0.16.0/go.mod h1:NxSsAGuq816PNPmqtQdLE42eU2Fs7NoRIZrHJAlaCOE=
+golang.org/x/sync v0.0.0-20190423024810-112230192c58/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM=
+golang.org/x/sync v0.0.0-20190911185100-cd5d95a43a6e/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM=
+golang.org/x/sync v0.0.0-20201020160332-67f06af15bc9/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM=
+golang.org/x/sync v0.0.0-20220722155255-886fb9371eb4/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM=
+golang.org/x/sync v0.4.0 h1:zxkM55ReGkDlKSM+Fu41A+zmbZuaPVbGMzvvdUPznYQ=
+golang.org/x/sync v0.4.0/go.mod h1:FU7BRWz2tNW+3quACPkgCx/L+uEAv1htQ0V83Z9Rj+Y=
+golang.org/x/sys v0.0.0-20190215142949-d0b11bdaac8a/go.mod h1:STP8DvDyc/dI5b8T5hshtkjS+E42TnysNCUPdjciGhY=
+golang.org/x/sys v0.0.0-20190412213103-97732733099d/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
+golang.org/x/sys v0.0.0-20200930185726-fdedc70b468f/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
+golang.org/x/sys v0.0.0-20201119102817-f84b799fce68/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
+golang.org/x/sys v0.0.0-20210615035016-665e8c7367d1/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
+golang.org/x/sys v0.0.0-20220520151302-bc2c85ada10a/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
+golang.org/x/sys v0.0.0-20220722155257-8c9f86f7a55f/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
+golang.org/x/sys v0.15.0 h1:h48lPFYpsTvQJZF4EKyI4aLHaev3CxivZmv7yZig9pc=
+golang.org/x/sys v0.15.0/go.mod h1:/VUhepiaJMQUp4+oa/7Zr1D23ma6VTLIYjOOTFZPUcA=
+golang.org/x/term v0.0.0-20201126162022-7de9c90e9dd1/go.mod h1:bj7SfCRtBDWHUb9snDiAeCFNEtKQo2Wmx5Cou7ajbmo=
+golang.org/x/term v0.0.0-20210927222741-03fcf44c2211/go.mod h1:jbD1KX2456YbFQfuXm/mYQcufACuNUgVhRMnK/tPxf8=
+golang.org/x/text v0.3.0/go.mod h1:NqM8EUOU14njkJ3fqMW+pc6Ldnwhi/IjpwHt7yyuwOQ=
+golang.org/x/text v0.3.3/go.mod h1:5Zoc/QRtKVWzQhOtBMvqHzDpF6irO9z98xDceosuGiQ=
+golang.org/x/text v0.3.7/go.mod h1:u+2+/6zg+i71rQMx5EYifcz6MCKuco9NR6JIITiCfzQ=
+golang.org/x/text v0.3.8/go.mod h1:E6s5w1FMmriuDzIBO73fBruAKo1PCIq6d2Q6DHfQ8WQ=
+golang.org/x/text v0.14.0 h1:ScX5w1eTa3QqT8oi6+ziP7dTV1S2+ALU0bI+0zXKWiQ=
+golang.org/x/text v0.14.0/go.mod h1:18ZOQIKpY8NJVqYksKHtTdi31H5itFRjB5/qKTNYzSU=
+golang.org/x/tools v0.0.0-20180917221912-90fa682c2a6e/go.mod h1:n7NCudcB/nEzxVGmLbDWY5pfWTLqBcC2KZ6jyYvM4mQ=
+golang.org/x/tools v0.0.0-20191119224855-298f0cb1881e/go.mod h1:b+2E5dAYhXwXZwtnZ6UAqBI28+e2cm9otk0dWdXHAEo=
+golang.org/x/tools v0.0.0-20200619180055-7c47624df98f/go.mod h1:EkVYQZoAsY45+roYkvgYkIh4xh/qjgUK9TdY2XT94GE=
+golang.org/x/tools v0.0.0-20210106214847-113979e3529a/go.mod h1:emZCQorbCU4vsT4fOWvOPXz4eW1wZW4PmDk9uLelYpA=
+golang.org/x/tools v0.1.12/go.mod h1:hNGJHUnrk76NpqgfD5Aqm5Crs+Hm0VOH/i9J2+nxYbc=
+golang.org/x/xerrors v0.0.0-20190717185122-a985d3407aa7/go.mod h1:I/5z698sn9Ka8TeJc9MKroUUfqBBauWjQqLJ2OPfmY0=
+golang.org/x/xerrors v0.0.0-20191011141410-1b5146add898/go.mod h1:I/5z698sn9Ka8TeJc9MKroUUfqBBauWjQqLJ2OPfmY0=
+golang.org/x/xerrors v0.0.0-20191204190536-9bdfabe68543/go.mod h1:I/5z698sn9Ka8TeJc9MKroUUfqBBauWjQqLJ2OPfmY0=
+golang.org/x/xerrors v0.0.0-20200804184101-5ec99f83aff1/go.mod h1:I/5z698sn9Ka8TeJc9MKroUUfqBBauWjQqLJ2OPfmY0=
+google.golang.org/genproto/googleapis/rpc v0.0.0-20231002182017-d307bd883b97 h1:6GQBEOdGkX6MMTLT9V+TjtIRZCw9VPD5Z+yHY9wMgS0=
+google.golang.org/genproto/googleapis/rpc v0.0.0-20231002182017-d307bd883b97/go.mod h1:v7nGkzlmW8P3n/bKmWBn2WpBjpOEx8Q6gMueudAmKfY=
+google.golang.org/grpc v1.60.1 h1:26+wFr+cNqSGFcOXcabYC0lUVJVRa2Sb2ortSK7VrEU=
+google.golang.org/grpc v1.60.1/go.mod h1:OlCHIeLYqSSsLi6i49B5QGdzaMZK9+M7LXN2FKz4eGM=
+google.golang.org/protobuf v1.26.0-rc.1/go.mod h1:jlhhOSvTdKEhbULTjvd4ARK9grFBp09yW+WbY/TyQbw=
+google.golang.org/protobuf v1.26.0/go.mod h1:9q0QmTI4eRPtz6boOQmLYwt+qCgq0jsYwAQnmE0givc=
+google.golang.org/protobuf v1.32.0 h1:pPC6BG5ex8PDFnkbrGU3EixyhKcQ2aDuBS36lqK/C7I=
+google.golang.org/protobuf v1.32.0/go.mod h1:c6P6GXX6sHbq/GpV6MGZEdwhWPcYBgnhAHhKbcUYpos=

main.go

+package main
+
+func main() {
+
+}

types/taskinfo.go

+package types
+
+type TaskTypeInfo struct {
+	Id                int32  `json:"id"` // 任务类型id
+	Name              string `json:"name"`
+	Desc              string `json:"desc"`  // 任务类型描述
+	Price             int64  `json:"price"` // 该任务类型的费用
+	PublicKey         string `json:"public_key"`
+	Complexity        int8   `json:"complexity"`
+	HardwareRequire   string `json:"hardware_require"`
+	ImageId           string `json:"image_id"`
+	ImageUrl          string `json:"image_url"`
+	ImageName         string `json:"image_name"`
+	SignUrl           string `json:"sign_url"`
+	Username          string `json:"username"`
+	Password          string `json:"password"`
+	Cmd               string `json:"cmd"`
+	Workload          int32  `json:"workload"`
+	ApiPath           string `json:"api_path"`
+	Type              int8   `json:"type"` // 类型 1=txt2img 2=txt2txt 3=txt2video
+	BaseModel         string `json:"base_model"`
+	Model             string `json:"model"`
+	Examples          string `json:"examples"`
+	ApiDocUrl         string `json:"api_doc_url"`
+	ApiDocContent     string `json:"api_doc_content"`
+	Codes             string `json:"codes"`
+	Tags              string `json:"tags"`
+	Kind              int8   `json:"kind"` // 任务种类 SystemTask = 0; ComputeTask = 1; CustomTask = 2; StandardTask = 3;
+	Category          int8   `json:"category"`
+	ResultFileExpires int32  `json:"result_file_expires"`
+	Version           string `json:"version"`
+	Form              string `json:"form"`
+	AccessStatus      int8   `json:"access_status"`    // 接入状体啊 1= 公开 2-= 私有
+	EstimatExeTime    int32  `json:"estimat_exe_time"` // 预计执行时长
+	Unit              string `json:"unit"`
+	PublishStatus     int8   `json:"publish_status"` // 发布状态 1= 发布 2= 取消发布
+	MaxExecTime       int32  `json:"max_exec_time"`  // 任务执行超时时间
+}

types/worker.go

+package types
+
+import (
+	omanager "github.com/odysseus/odysseus-protocol/gen/proto/go/nodemanager/v2"
+)
+
+type NodeInfo struct {
+	MinerPubkey    string `bson:"miner_pubkey" json:"miner_pubkey"`
+	BenefitAddress string `bson:"benefit_address" json:"benefit_address"`
+}
+
+func PbToNodeInfo(pb *omanager.NodeInfo) *NodeInfo {
+	return &NodeInfo{
+		MinerPubkey:    pb.MinerPubkey,
+		BenefitAddress: pb.BenefitAddress,
+	}
+}
+
+func (n *NodeInfo) ToPb() *omanager.NodeInfo {
+	return &omanager.NodeInfo{
+		MinerPubkey:    n.MinerPubkey,
+		BenefitAddress: n.BenefitAddress,
+	}
+}
+
+type InstalledModel struct {
+	ModelID       string `bson:"model_id" json:"model_id"`
+	DiskSize      int64  `bson:"disk_size" json:"disk_size"`
+	InstalledTime int64  `bson:"installed_time" json:"installed_time"`
+	LastRunTime   int64  `bson:"last_run_time" json:"last_run_time"`
+}
+
+func PbToInstalledModel(pb *omanager.InstalledModel) *InstalledModel {
+	return &InstalledModel{
+		ModelID:       pb.ModelId,
+		DiskSize:      pb.DiskSize,
+		InstalledTime: pb.InstalledTime,
+		LastRunTime:   pb.LastRunTime,
+	}
+}
+
+func (i *InstalledModel) ToPb() *omanager.InstalledModel {
+	return &omanager.InstalledModel{
+		ModelId:       i.ModelID,
+		DiskSize:      i.DiskSize,
+		InstalledTime: i.InstalledTime,
+		LastRunTime:   i.LastRunTime,
+	}
+}
+
+type RunningModel struct {
+	ModelID       string `bson:"model_id" json:"model_id"`
+	GpuSeq        int    `bson:"gpu_seq" json:"gpu_seq"`
+	GpuRAM        int64  `bson:"gpu_ram" json:"gpu_ram"`
+	StartedTime   int64  `bson:"started_time" json:"started_time"`
+	LastWorkTime  int64  `bson:"last_work_time" json:"last_work_time"`
+	TotalRunCount int    `bson:"total_run_count" json:"total_run_count"`
+	ExecTime      int    `bson:"exec_time" json:"exec_time"`
+}
+
+func PbToRunningModel(pb *omanager.RunningModel) *RunningModel {
+	return &RunningModel{
+		ModelID:       pb.ModelId,
+		GpuSeq:        int(pb.GpuSeq),
+		GpuRAM:        pb.GpuRam,
+		StartedTime:   pb.StartedTime,
+		LastWorkTime:  pb.LastWorkTime,
+		TotalRunCount: int(pb.TotalRunCount),
+		ExecTime:      int(pb.ExecTime),
+	}
+
+}
+
+func (r *RunningModel) ToPb() *omanager.RunningModel {
+	return &omanager.RunningModel{
+		ModelId:       r.ModelID,
+		GpuSeq:        int32(r.GpuSeq),
+		GpuRam:        r.GpuRAM,
+		StartedTime:   r.StartedTime,
+		LastWorkTime:  r.LastWorkTime,
+		TotalRunCount: int32(r.TotalRunCount),
+		ExecTime:      int32(r.ExecTime),
+	}
+}
+
+type ModelInfo struct {
+	InstalledModels []*InstalledModel `bson:"installed_models" json:"installed_models"`
+	RunningModels   []*RunningModel   `bson:"running_models" json:"running_models"`
+}
+
+func PbToModelInfo(pb *omanager.ModelsInfo) *ModelInfo {
+	installedModels := make([]*InstalledModel, 0, len(pb.InstalledModels))
+	for _, m := range pb.InstalledModels {
+		installedModels = append(installedModels, PbToInstalledModel(m))
+	}
+	runningModels := make([]*RunningModel, 0, len(pb.RunningModels))
+	for _, m := range pb.RunningModels {
+		runningModels = append(runningModels, PbToRunningModel(m))
+	}
+	return &ModelInfo{
+		InstalledModels: installedModels,
+		RunningModels:   runningModels,
+	}
+}
+
+func (m *ModelInfo) ToPb() *omanager.ModelsInfo {
+	installedModels := make([]*omanager.InstalledModel, 0, len(m.InstalledModels))
+	for _, m := range m.InstalledModels {
+		installedModels = append(installedModels, m.ToPb())
+	}
+	runningModels := make([]*omanager.RunningModel, 0, len(m.RunningModels))
+	for _, m := range m.RunningModels {
+		runningModels = append(runningModels, m.ToPb())
+	}
+	return &omanager.ModelsInfo{
+		InstalledModels: installedModels,
+		RunningModels:   runningModels,
+	}
+}
+
+type HardwareInfo struct {
+	CPU  *CpuInfo   `bson:"CPU" json:"CPU"`
+	GPU  []*GpuInfo `bson:"GPU" json:"GPU"`
+	RAM  *RamInfo   `bson:"RAM" json:"RAM"`
+	DISK *DiskInfo  `bson:"DISK" json:"DISK"`
+	NET  *NetInfo   `bson:"NET" json:"NET"`
+}
+
+func PbToHardwareInfo(pb *omanager.HardwareInfo) *HardwareInfo {
+	cpu := PbToCpuInfo(pb.CPU)
+	gpus := make([]*GpuInfo, 0)
+	for _, gpu := range pb.GPU {
+		gpus = append(gpus, PbToGpuInfo(gpu))
+	}
+	ram := PbToRamInfo(pb.RAM)
+	disk := PbToDiskInfo(pb.DISK)
+	net := PbToNetInfo(pb.NET)
+	return &HardwareInfo{
+		CPU:  cpu,
+		GPU:  gpus,
+		RAM:  ram,
+		DISK: disk,
+		NET:  net,
+	}
+}
+
+func (h *HardwareInfo) ToPb() *omanager.HardwareInfo {
+	cpu := h.CPU.ToPb()
+	gpus := make([]*omanager.GPUInfo, 0)
+	for _, gpu := range h.GPU {
+		gpus = append(gpus, gpu.ToPb())
+	}
+	ram := h.RAM.ToPb()
+	disk := h.DISK.ToPb()
+	net := h.NET.ToPb()
+
+	return &omanager.HardwareInfo{
+		CPU:  cpu,
+		GPU:  gpus,
+		RAM:  ram,
+		DISK: disk,
+		NET:  net,
+	}
+}
+
+type CpuInfo struct {
+	Model   string `bson:"model" json:"model "`
+	Number  int    `bson:"number" json:"number"`
+	Cores   int    `bson:"cores" json:"cores"`
+	Threads int    `bson:"threads" json:"threads"`
+	Usage   int    `bson:"usage" json:"usage"`
+}
+
+func PbToCpuInfo(pb *omanager.CPUInfo) *CpuInfo {
+	return &CpuInfo{
+		Model:   pb.Model,
+		Number:  int(pb.Number),
+		Cores:   int(pb.Cores),
+		Threads: int(pb.Threads),
+		Usage:   int(pb.Usage),
+	}
+}
+
+func (c *CpuInfo) ToPb() *omanager.CPUInfo {
+	return &omanager.CPUInfo{
+		Model:   c.Model,
+		Number:  int32(c.Number),
+		Cores:   int32(c.Cores),
+		Threads: int32(c.Threads),
+		Usage:   int32(c.Usage),
+	}
+}
+
+type GpuInfo struct {
+	Seq         int    `bson:"seq" json:"seq"`
+	UUID        string `bson:"uuid" json:"uuid"`
+	Model       string `bson:"model" json:"model "`
+	Performance int    `bson:"performance" json:"performance"`
+	PowerRating int    `bson:"power_rating" json:"power_rating"`
+	MemTotal    int64  `bson:"mem_total" json:"mem_total"`
+	MemFree     int64  `bson:"mem_free" json:"mem_free"`
+	Usage       int    `bson:"usage" json:"usage"`
+	Temp        int    `bson:"temp" json:"temp "`
+	PowerRt     int    `bson:"power_rt" json:"power_rt"`
+}
+
+func PbToGpuInfo(pb *omanager.GPUInfo) *GpuInfo {
+	return &GpuInfo{
+		Seq:         int(pb.Seq),
+		UUID:        pb.Uuid,
+		Model:       pb.Model,
+		Performance: int(pb.Performance),
+		PowerRating: int(pb.PowerRating),
+		MemTotal:    pb.MemTotal,
+		MemFree:     pb.MemFree,
+		Usage:       int(pb.Usage),
+		Temp:        int(pb.Temp),
+		PowerRt:     int(pb.PowerRt),
+	}
+}
+
+func (g *GpuInfo) ToPb() *omanager.GPUInfo {
+	return &omanager.GPUInfo{
+		Seq:         int32(g.Seq),
+		Uuid:        g.UUID,
+		Model:       g.Model,
+		Performance: int32(g.Performance),
+		PowerRating: int32(g.PowerRating),
+		MemTotal:    g.MemTotal,
+		MemFree:     g.MemFree,
+		Usage:       int32(g.Usage),
+		Temp:        int32(g.Temp),
+		PowerRt:     int32(g.PowerRt),
+	}
+}
+
+type RamInfo struct {
+	Total int64 `bson:"total" json:"total"`
+	Free  int64 `bson:"free" json:"free"`
+}
+
+func PbToRamInfo(pb *omanager.MemoryInfo) *RamInfo {
+	return &RamInfo{
+		Total: pb.Total,
+		Free:  pb.Free,
+	}
+
+}
+
+func (r *RamInfo) ToPb() *omanager.MemoryInfo {
+	return &omanager.MemoryInfo{
+		Total: r.Total,
+		Free:  r.Free,
+	}
+}
+
+type DiskInfo struct {
+	Total int64 `bson:"total" json:"total"`
+	Free  int64 `bson:"free" json:"free"`
+}
+
+func PbToDiskInfo(pb *omanager.DiskInfo) *DiskInfo {
+	return &DiskInfo{
+		Total: pb.Total,
+		Free:  pb.Free,
+	}
+}
+
+func (d *DiskInfo) ToPb() *omanager.DiskInfo {
+	return &omanager.DiskInfo{
+		Total: d.Total,
+		Free:  d.Free,
+	}
+}
+
+type NetInfo struct {
+	IP        string `bson:"ip" json:"ip"`
+	Mac       string `bson:"mac" json:"mac"`
+	Bandwidth int    `bson:"bandwidth" json:"bandwidth"`
+}
+
+func PbToNetInfo(pb *omanager.NetInfo) *NetInfo {
+	return &NetInfo{
+		IP:        pb.Ip,
+		Mac:       pb.Mac,
+		Bandwidth: int(pb.Bandwidth),
+	}
+}
+
+func (n *NetInfo) ToPb() *omanager.NetInfo {
+	return &omanager.NetInfo{
+		Ip:        n.IP,
+		Mac:       n.Mac,
+		Bandwidth: int32(n.Bandwidth),
+	}
+}