Fix manifest rollback

common/constant/blockchainSync.go

@@ -11,7 +11,7 @@ const (
 	PeerGetBlocksLimit               uint32        = 1440
 	CommonMilestoneBlockIdsLimit     int32         = 10
 	SafeBlockGap                                   = MinRollbackBlocks / 2
-	// @iltoga change this to 2 for testing snapshots
+	// @iltoga change this to 2 for testing snapshots to maintain functionality keep this value above PriorityStrategyBuildScrambleNodesGap
 	MinRollbackBlocks              uint32 = 720 // production 720
 	MaxCommonMilestoneRequestTrial        = MinRollbackBlocks/uint32(CommonMilestoneBlockIdsLimit) + 1
 	MinimumPeersBlocksToDownload   int32  = 2

common/database/migration.go

@@ -269,9 +269,10 @@ func (m *Migration) Init() error {
 				"full_file_hash" BLOB,			-- hash of the (snapshot) file content
 				"file_chunk_hashes" BLOB,		-- sorted sequence file chunks hashes referenced by the spine_block_manifest
 				"manifest_reference_height" INTEGER NOT NULL,	-- height at which the snapshot was taken on the (main)chain
+				"manifest_spine_block_height" INTEGER NOT NULL,	-- height at which the snapshot was taken on the (main)chain
 				"chain_type" INTEGER NOT NULL,		-- chain type this spine_block_manifest reference to
 				"manifest_type" INTEGER NOT NULL,	-- type of spine_block_manifest (as of now only snapshot)
-				"manifest_timestamp" INTEGER NOT NULL,	-- timestamp that marks the end of file chunks processing
+				"expiration_timestamp" INTEGER NOT NULL,	-- timestamp that marks the end of file chunks processing
 				PRIMARY KEY("id")
 				UNIQUE("id")
 			)
@@ -345,6 +346,12 @@ func (m *Migration) Init() error {
 			`
 			CREATE INDEX "published_receipt_datum_hash_idx" ON "published_receipt" ("datum_hash")
 			`,
+			`
+			CREATE INDEX "spine_block_manifest_spine_block_height_idx" ON "spine_block_manifest" ("manifest_spine_block_height")
+			`,
+			`
+			CREATE INDEX "spine_block_manifest_reference_height_idx" ON "spine_block_manifest" ("manifest_reference_height")
+			`,
 		}
 		return nil
 	}

common/query/query.go

@@ -35,12 +35,12 @@ func GetDerivedQuery(ct chaintype.ChainType) (derivedQuery []DerivedQuery) {
 			NewPendingTransactionQuery(),
 			NewPendingSignatureQuery(),
 			NewMultisignatureInfoQuery(),
-			NewSpineBlockManifestQuery(),
 		}
 		derivedQuery = append(derivedQuery, mainchainDerivedQuery...)
 	case *chaintype.SpineChain:
 		spinechainDerivedQuery := []DerivedQuery{
 			NewSpinePublicKeyQuery(),
+			NewSpineBlockManifestQuery(),
 		}
 		derivedQuery = append(derivedQuery, spinechainDerivedQuery...)
 	}

common/query/query_test.go

@@ -36,7 +36,6 @@ func TestGetDerivedQuery(t *testing.T) {
 				NewPendingTransactionQuery(),
 				NewPendingSignatureQuery(),
 				NewMultisignatureInfoQuery(),
-				NewSpineBlockManifestQuery(),
 			},
 		},
 		{
@@ -45,6 +44,7 @@ func TestGetDerivedQuery(t *testing.T) {
 			want: []DerivedQuery{
 				NewBlockQuery(spinechain),
 				NewSpinePublicKeyQuery(),
+				NewSpineBlockManifestQuery(),
 			},
 		},
 	}

common/query/spineBlockManifestQuery.go

@@ -3,7 +3,6 @@ package query
 import (
 	"database/sql"
 	"fmt"
-	"github.com/zoobc/zoobc-core/common/constant"
 	"strings"
 
 	"github.com/zoobc/zoobc-core/common/chaintype"
@@ -15,6 +14,8 @@ type (
 	SpineBlockManifestQueryInterface interface {
 		InsertSpineBlockManifest(spineBlockManifest *model.SpineBlockManifest) (str string, args []interface{})
 		GetSpineBlockManifestTimeInterval(fromTimestamp, toTimestamp int64) string
+		GetManifestBySpineBlockHeight(spineBlockHeight uint32) string
+		GetManifestsFromSpineBlockHeight(spineBlockHeight uint32) string
 		GetLastSpineBlockManifest(ct chaintype.ChainType, mbType model.SpineBlockManifestType) string
 		ExtractModel(mb *model.SpineBlockManifest) []interface{}
 		BuildModel(spineBlockManifests []*model.SpineBlockManifest, rows *sql.Rows) ([]*model.SpineBlockManifest, error)
@@ -34,9 +35,10 @@ func NewSpineBlockManifestQuery() *SpineBlockManifestQuery {
 			"full_file_hash",
 			"file_chunk_hashes",
 			"manifest_reference_height",
+			"manifest_spine_block_height",
 			"chain_type",
 			"manifest_type",
-			"manifest_timestamp",
+			"expiration_timestamp",
 		},
 		TableName: "spine_block_manifest",
 	}
@@ -72,19 +74,34 @@ func (mbl *SpineBlockManifestQuery) GetLastSpineBlockManifest(ct chaintype.Chain
 // GetSpineBlockManifestTimeInterval retrieve all spineBlockManifests within a time frame
 // Note: it is used to get all entities that have expired between spine blocks
 func (mbl *SpineBlockManifestQuery) GetSpineBlockManifestTimeInterval(fromTimestamp, toTimestamp int64) string {
-	query := fmt.Sprintf("SELECT %s FROM %s WHERE manifest_timestamp > %d AND manifest_timestamp <= %d "+
+	query := fmt.Sprintf("SELECT %s FROM %s WHERE expiration_timestamp > %d AND expiration_timestamp <= %d "+
 		"ORDER BY manifest_type, chain_type, manifest_reference_height",
 		strings.Join(mbl.Fields, ", "), mbl.getTableName(), fromTimestamp, toTimestamp)
 	return query
 }
 
+// GetManifestBySpineBlockHeight retrieve manifests of binded to a spineblock height
+func (mbl *SpineBlockManifestQuery) GetManifestBySpineBlockHeight(spineBlockHeight uint32) string {
+	query := fmt.Sprintf("SELECT %s FROM %s WHERE manifest_spine_block_height = %d "+
+		"ORDER BY manifest_type, chain_type, manifest_reference_height",
+		strings.Join(mbl.Fields, ", "), mbl.getTableName(), spineBlockHeight)
+	return query
+}
+
+func (mbl *SpineBlockManifestQuery) GetManifestsFromSpineBlockHeight(spineBlockHeight uint32) string {
+	query := fmt.Sprintf("SELECT %s FROM %s WHERE manifest_spine_block_height > %d ",
+		strings.Join(mbl.Fields, ", "), mbl.getTableName(), spineBlockHeight)
+	return query
+}
+
 // ExtractModel extract the model struct fields to the order of SpineBlockManifestQuery.Fields
 func (mbl *SpineBlockManifestQuery) ExtractModel(mb *model.SpineBlockManifest) []interface{} {
 	return []interface{}{
 		mb.ID,
 		mb.FullFileHash,
 		mb.FileChunkHashes,
-		mb.SpineBlockManifestHeight,
+		mb.ManifestReferenceHeight,
+		mb.ManifestSpineBlockHeight,
 		mb.ChainType,
 		mb.SpineBlockManifestType,
 		mb.ExpirationTimestamp,
@@ -106,7 +123,8 @@ func (mbl *SpineBlockManifestQuery) BuildModel(
 			&mb.ID,
 			&mb.FullFileHash,
 			&mb.FileChunkHashes,
-			&mb.SpineBlockManifestHeight,
+			&mb.ManifestReferenceHeight,
+			&mb.ManifestSpineBlockHeight,
 			&mb.ChainType,
 			&mb.SpineBlockManifestType,
 			&mb.ExpirationTimestamp,
@@ -125,7 +143,8 @@ func (mbl *SpineBlockManifestQuery) Scan(mb *model.SpineBlockManifest, row *sql.
 		&mb.ID,
 		&mb.FullFileHash,
 		&mb.FileChunkHashes,
-		&mb.SpineBlockManifestHeight,
+		&mb.ManifestReferenceHeight,
+		&mb.ManifestSpineBlockHeight,
 		&mb.ChainType,
 		&mb.SpineBlockManifestType,
 		&mb.ExpirationTimestamp,
@@ -142,8 +161,8 @@ func (mbl *SpineBlockManifestQuery) Scan(mb *model.SpineBlockManifest, row *sql.
 func (mbl *SpineBlockManifestQuery) Rollback(height uint32) (multiQueries [][]interface{}) {
 	return [][]interface{}{
 		{
-			fmt.Sprintf("DELETE FROM %s WHERE manifest_reference_height > ?", mbl.getTableName()),
-			height - constant.MinRollbackBlocks,
+			fmt.Sprintf("DELETE FROM %s WHERE manifest_spine_block_height > ?", mbl.getTableName()),
+			height,
 		},
 	}
 }

common/query/spineBlockManifestQuery_test.go

@@ -18,8 +18,8 @@ func TestSpineBlockManifestQuery_InsertSpineBlockManifest(t *testing.T) {
 	}
 
 	mb1 := &model.SpineBlockManifest{
-		FullFileHash:             make([]byte, 64), // sha3-512
-		SpineBlockManifestHeight: 720,
+		FullFileHash:            make([]byte, 64), // sha3-512
+		ManifestReferenceHeight: 720,
 	}
 	tests := []struct {
 		name   string
@@ -37,8 +37,8 @@ func TestSpineBlockManifestQuery_InsertSpineBlockManifest(t *testing.T) {
 				spineBlockManifest: mb1,
 			},
 			want: "INSERT OR REPLACE INTO spine_block_manifest (id,full_file_hash,file_chunk_hashes,manifest_reference_height," +
-				"chain_type,manifest_type," +
-				"manifest_timestamp) VALUES(? , ?, ?, ?, ?, ?, ?)",
+				"manifest_spine_block_height,chain_type,manifest_type," +
+				"expiration_timestamp) VALUES(? , ?, ?, ?, ?, ?, ?, ?)",
 		},
 	}
 	for _, tt := range tests {
@@ -79,9 +79,9 @@ func TestSpineBlockManifestQuery_GetLastSpineBlockManifest(t *testing.T) {
 				ct:     &chaintype.MainChain{},
 				mbType: model.SpineBlockManifestType_Snapshot,
 			},
-			want: "SELECT id, full_file_hash, file_chunk_hashes, manifest_reference_height, chain_type, manifest_type, " +
-				"manifest_timestamp FROM spine_block_manifest WHERE chain_type = 0 AND manifest_type = 0 ORDER BY manifest_reference_height" +
-				" DESC LIMIT 1",
+			want: "SELECT id, full_file_hash, file_chunk_hashes, manifest_reference_height, manifest_spine_block_height, " +
+				"chain_type, manifest_type, expiration_timestamp FROM spine_block_manifest WHERE chain_type = 0 AND " +
+				"manifest_type = 0 ORDER BY manifest_reference_height DESC LIMIT 1",
 		},
 	}
 	for _, tt := range tests {
@@ -122,9 +122,9 @@ func TestSpineBlockManifestQuery_GetSpineBlockManifestsInTimeInterval(t *testing
 				fromTimestamp: 10,
 				toTimestamp:   20,
 			},
-			want: "SELECT id, full_file_hash, file_chunk_hashes, manifest_reference_height, chain_type, manifest_type, " +
-				"manifest_timestamp FROM spine_block_manifest WHERE manifest_timestamp > 10 AND manifest_timestamp <= 20 ORDER" +
-				" BY manifest_type, chain_type, manifest_reference_height",
+			want: "SELECT id, full_file_hash, file_chunk_hashes, manifest_reference_height, manifest_spine_block_height, " +
+				"chain_type, manifest_type, expiration_timestamp FROM spine_block_manifest WHERE expiration_timestamp > 10 " +
+				"AND expiration_timestamp <= 20 ORDER BY manifest_type, chain_type, manifest_reference_height",
 		},
 	}
 	for _, tt := range tests {

core/blockchainsync/blockchainOrchestratorService.go

@@ -103,14 +103,14 @@ func (bos *BlockchainOrchestratorService) DownloadSnapshot(ct chaintype.ChainTyp
 		}
 		bos.Logger.Infof("found a Snapshot Spine Block Manifest for chaintype %s, "+
 			"at height is %d. Start downloading...\n", ct.GetName(),
-			lastSpineBlockManifest.SpineBlockManifestHeight)
+			lastSpineBlockManifest.ManifestReferenceHeight)
 		snapshotFileInfo, err := bos.FileDownloader.DownloadSnapshot(ct, lastSpineBlockManifest)
 		if err != nil {
 			bos.Logger.Warning(err)
 			return err
 		} else if err := bos.MainchainSnapshotBlockServices.ImportSnapshotFile(snapshotFileInfo); err != nil {
 			bos.Logger.Warningf("error importing snapshot file for chaintype %s at height %d: %s\n", ct.GetName(),
-				lastSpineBlockManifest.SpineBlockManifestHeight, err.Error())
+				lastSpineBlockManifest.ManifestReferenceHeight, err.Error())
 			return err
 		}