complete the getmetadata method

Author: noel2004

coordinator/internal/logic/provertask/batch_prover_task.go

@@ -194,12 +194,37 @@ func (bp *BatchProverTask) Assign(ctx *gin.Context, getTaskParameter *coordinato
 	return taskMsg, nil
 }
 
-func (bp *BatchProverTask) GetTaskMetaData(taskID string) (string, error) {
+func (bp *BatchProverTask) GetTaskMetaData(ctx *gin.Context, proverTask *orm.ProverTask, hardForkName string) (string, error) {
+	taskID := proverTask.TaskID
 	if cached := bp.taskCache.Query(taskID); cached != nil {
 		return cached.MetaData, nil
 	}
 
-	return "", fmt.Errorf("can not re-acquire the metadata for specified task, see coordinator log for the reason")
+	// for most case we simply query metadata from cache, but if the task is not in cache, we need quite a few
+	// effort to resume the cached universal task
+	batchTask, err := bp.batchOrm.GetBatchByHash(ctx.Copy(), taskID)
+	if err != nil {
+		log.Error("failed to get chunk by hash", "task_id", taskID, "err", err)
+		return "", ErrCoordinatorInternalFailure
+	}
+	taskMsg, err := bp.formatProverTask(ctx.Copy(), proverTask, batchTask, hardForkName)
+	if err != nil {
+		log.Error("re-format prover task failure", "task_id", taskID, "err", err)
+		return "", ErrCoordinatorInternalFailure
+	}
+
+	taskMsg, err = bp.applyUniversal(taskMsg)
+	if err != nil {
+		log.Error("Generate universal prover task failure", "task_id", taskID, "type", "chunk")
+		return "", ErrCoordinatorInternalFailure
+	}
+
+	if cached := bp.taskCache.Query(taskID); cached == nil {
+		log.Error("Still can not obtain metadata, something wrong?", "task_id", taskID, "type", "chunk")
+		return "", ErrCoordinatorInternalFailure
+	} else {
+		return cached.MetaData, nil
+	}
 }
 
 func (bp *BatchProverTask) formatProverTask(ctx context.Context, task *orm.ProverTask, batch *orm.Batch, hardForkName string) (*coordinatorType.GetTaskSchema, error) {

coordinator/internal/logic/provertask/bundle_prover_task.go

@@ -192,12 +192,32 @@ func (bp *BundleProverTask) Assign(ctx *gin.Context, getTaskParameter *coordinat
 	return taskMsg, nil
 }
 
-func (bp *BundleProverTask) GetTaskMetaData(taskID string) (string, error) {
+func (bp *BundleProverTask) GetTaskMetaData(ctx *gin.Context, proverTask *orm.ProverTask, hardForkName string) (string, error) {
+	taskID := proverTask.TaskID
 	if cached := bp.taskCache.Query(taskID); cached != nil {
 		return cached.MetaData, nil
 	}
 
-	return "", fmt.Errorf("can not re-acquire the metadata for specified task, see coordinator log for the reason")
+	// for most case we simply query metadata from cache, but if the task is not in cache, we need quite a few
+	// effort to resume the cached universal task
+	taskMsg, err := bp.formatProverTask(ctx.Copy(), proverTask, hardForkName)
+	if err != nil {
+		log.Error("re-format prover task failure", "task_id", taskID, "err", err)
+		return "", ErrCoordinatorInternalFailure
+	}
+
+	taskMsg, err = bp.applyUniversal(taskMsg)
+	if err != nil {
+		log.Error("Generate universal prover task failure", "task_id", taskID, "type", "chunk")
+		return "", ErrCoordinatorInternalFailure
+	}
+
+	if cached := bp.taskCache.Query(taskID); cached == nil {
+		log.Error("Still can not obtain metadata, something wrong?", "task_id", taskID, "type", "chunk")
+		return "", ErrCoordinatorInternalFailure
+	} else {
+		return cached.MetaData, nil
+	}
 }
 
 func (bp *BundleProverTask) formatProverTask(ctx context.Context, task *orm.ProverTask, hardForkName string) (*coordinatorType.GetTaskSchema, error) {

coordinator/internal/logic/provertask/chunk_prover_task.go

@@ -189,12 +189,37 @@ func (cp *ChunkProverTask) Assign(ctx *gin.Context, getTaskParameter *coordinato
 	return taskMsg, nil
 }
 
-func (cp *ChunkProverTask) GetTaskMetaData(taskID string) (string, error) {
+func (cp *ChunkProverTask) GetTaskMetaData(ctx *gin.Context, proverTask *orm.ProverTask, hardForkName string) (string, error) {
+	taskID := proverTask.TaskID
 	if cached := cp.taskCache.Query(taskID); cached != nil {
 		return cached.MetaData, nil
 	}
 
-	return "", fmt.Errorf("can not re-acquire the metadata for specified task, see coordinator log for the reason")
+	// for most case we simply query metadata from cache, but if the task is not in cache, we need quite a few
+	// effort to resume the cached universal task
+	chunkTask, err := cp.chunkOrm.GetChunkByHash(ctx.Copy(), taskID)
+	if err != nil {
+		log.Error("failed to get chunk by hash", "task_id", taskID, "err", err)
+		return "", ErrCoordinatorInternalFailure
+	}
+	taskMsg, err := cp.formatProverTask(ctx.Copy(), proverTask, chunkTask, hardForkName)
+	if err != nil {
+		log.Error("re-format prover task failure", "task_id", taskID, "err", err)
+		return "", ErrCoordinatorInternalFailure
+	}
+
+	taskMsg, err = cp.applyUniversal(taskMsg)
+	if err != nil {
+		log.Error("Generate universal prover task failure", "task_id", taskID, "type", "chunk")
+		return "", ErrCoordinatorInternalFailure
+	}
+
+	if cached := cp.taskCache.Query(taskID); cached == nil {
+		log.Error("Still can not obtain metadata, something wrong?", "task_id", taskID, "type", "chunk")
+		return "", ErrCoordinatorInternalFailure
+	} else {
+		return cached.MetaData, nil
+	}
 }
 
 func (cp *ChunkProverTask) formatProverTask(ctx context.Context, task *orm.ProverTask, chunk *orm.Chunk, hardForkName string) (*coordinatorType.GetTaskSchema, error) {

coordinator/internal/logic/provertask/prover_task.go

@@ -34,7 +34,7 @@ var (
 // ProverTask the interface of a collector who send data to prover
 type ProverTask interface {
 	Assign(ctx *gin.Context, getTaskParameter *coordinatorType.GetTaskParameter) (*coordinatorType.GetTaskSchema, error)
-	GetTaskMetaData(taskID string) (string, error)
+	GetTaskMetaData(ctx *gin.Context, task *orm.ProverTask, HardForkName string) (string, error)
 }
 
 // BaseProverTask a base prover task which contain series functions

coordinator/internal/logic/submitproof/proof_receiver.go

@@ -179,11 +179,11 @@ func (m *ProofReceiverLogic) HandleZkProof(ctx *gin.Context, proofParameter coor
 		var err error
 		switch message.ProofType(proofParameter.TaskType) {
 		case message.ProofTypeChunk:
-			metadata, err = m.ChunkTask.GetTaskMetaData(proofParameter.TaskID)
+			metadata, err = m.ChunkTask.GetTaskMetaData(ctx.Copy(), proverTask, hardForkName)
 		case message.ProofTypeBatch:
-			metadata, err = m.BatchTask.GetTaskMetaData(proofParameter.TaskID)
+			metadata, err = m.BatchTask.GetTaskMetaData(ctx.Copy(), proverTask, hardForkName)
 		case message.ProofTypeBundle:
-			metadata, err = m.BundleTask.GetTaskMetaData(proofParameter.TaskID)
+			metadata, err = m.BundleTask.GetTaskMetaData(ctx.Copy(), proverTask, hardForkName)
 		}
 
 		if err != nil {