Add config sequence to batch (#241)

- add config sequence
- some refactoring and clean-up

Signed-off-by: Yoav Tock <tock@il.ibm.com>

Author: tock-ibm

node/ledger/assembler_ledger_test.go

@@ -314,9 +314,8 @@ func createBatchesAndOrdInfo(t *testing.T, num int) ([]types.Batch, []*state.Ord
 		seq := seqArray[sIdx][pIdx]
 		seqArray[sIdx][pIdx] = seq + 1
 
-		fb, err := node_ledger.NewFabricBatchFromRequests(
-			party, shard, types.BatchSequence(seq), batchedRequests, nil)
-		require.NoError(t, err)
+		fb := node_ledger.NewFabricBatchFromRequests(shard, party, types.BatchSequence(seq), batchedRequests, 0, nil)
+		require.NotNil(t, fb)
 
 		transactionCount += len(batchedRequests)
 

node/ledger/assembler_ledger_util_test.go

@@ -22,8 +22,8 @@ func TestAssemblerBlockMetadataToFromBytes(t *testing.T) {
 		[]byte("tx1-1"), []byte("tx2"),
 	}
 
-	fb, err := node_ledger.NewFabricBatchFromRequests(1, 2, 3, batchedRequests, []byte("bogus"))
-	assert.NoError(t, err)
+	fb := node_ledger.NewFabricBatchFromRequests(2, 1, 3, batchedRequests, 0, []byte("bogus"))
+	assert.NotNil(t, fb)
 
 	oi := &state.OrderingInformation{
 		BlockHeader: &state.BlockHeader{

node/ledger/batch_encoding.go

@@ -18,11 +18,14 @@ import (
 	"github.com/pkg/errors"
 )
 
-// BlockMetadataIndex_PartyShard is one location after the last entry that Fabric uses, which evaluates to 5.
-// It includes the primary PartyID and ShardID.
-var BlockMetadataIndex_PartyShard = len(common.BlockMetadataIndex_name)
+// BlockMetadataIndex_PartyShardConfigSequence is the location where we encode the ShardID, primary PartyID, and config sequence.
+// We reuse the location of the orderer metadata.
+const BlockMetadataIndex_PartyShardConfigSequence = common.BlockMetadataIndex_ORDERER
 
-// FabricBatch is a types.Batch encoded in a Fabric block
+// The size of the partyShardConfigSequenceSize metadata: shard uint16 + party uint16 + config sequence uint64
+const partyShardConfigSequenceSize = 2 + 2 + 8
+
+// FabricBatch is a types.Batch encoded in a Fabric block.
 type FabricBatch common.Block
 
 func (b *FabricBatch) Digest() []byte {
@@ -35,48 +38,63 @@ func (b *FabricBatch) Requests() types.BatchedRequests {
 
 // Primary returns the PartyID if encoded correctly, or 0.
 func (b *FabricBatch) Primary() types.PartyID {
-	m := (*common.Block)(b).GetMetadata().GetMetadata()
-	if len(m) <= BlockMetadataIndex_PartyShard {
-		return 0
-	}
-
-	buff := m[BlockMetadataIndex_PartyShard]
-	if len(buff) < 4 {
+	buff := ordererMetadata((*common.Block)(b).GetMetadata().GetMetadata())
+	if len(buff) == 0 {
 		return 0
 	}
 
-	return types.PartyID(binary.BigEndian.Uint16(buff[:2]))
+	return types.PartyID(binary.BigEndian.Uint16(buff[2:4]))
 }
 
 // Shard returns the ShardID if encoded correctly, or 0.
 func (b *FabricBatch) Shard() types.ShardID {
-	m := (*common.Block)(b).GetMetadata().GetMetadata()
-	if len(m) <= BlockMetadataIndex_PartyShard {
+	buff := ordererMetadata((*common.Block)(b).GetMetadata().GetMetadata())
+	if len(buff) == 0 {
 		return 0
 	}
 
-	buff := m[BlockMetadataIndex_PartyShard]
-	if len(buff) < 4 {
+	return types.ShardID(binary.BigEndian.Uint16(buff[0:2]))
+}
+
+// ConfigSequence returns the ConfigSequence if encoded correctly, or 0.
+func (b *FabricBatch) ConfigSequence() types.ConfigSequence {
+	buff := ordererMetadata((*common.Block)(b).GetMetadata().GetMetadata())
+	if len(buff) == 0 {
 		return 0
 	}
 
-	return types.ShardID(binary.BigEndian.Uint16(buff[2:]))
+	return types.ConfigSequence(binary.BigEndian.Uint64(buff[4:]))
+}
+
+func ordererMetadata(m [][]byte) []byte {
+	if len(m) <= int(BlockMetadataIndex_PartyShardConfigSequence) {
+		return nil
+	}
+
+	buff := m[BlockMetadataIndex_PartyShardConfigSequence]
+	if len(buff) < partyShardConfigSequenceSize {
+		return nil
+	}
+
+	return buff
 }
 
 func (b *FabricBatch) Seq() types.BatchSequence {
 	return types.BatchSequence((*common.Block)(b).GetHeader().GetNumber())
 }
 
 func NewFabricBatchFromRequests(
-	partyID types.PartyID,
 	shardID types.ShardID,
+	partyID types.PartyID,
 	seq types.BatchSequence,
 	batchedRequests types.BatchedRequests,
+	configSeq types.ConfigSequence,
 	prevHash []byte,
-) (*FabricBatch, error) { // TODO remove the error
-	buff := make([]byte, 4)
-	binary.BigEndian.PutUint16(buff[:2], uint16(partyID))
-	binary.BigEndian.PutUint16(buff[2:], uint16(shardID))
+) *FabricBatch {
+	buff := make([]byte, partyShardConfigSequenceSize)
+	binary.BigEndian.PutUint16(buff[:2], uint16(shardID))
+	binary.BigEndian.PutUint16(buff[2:4], uint16(partyID))
+	binary.BigEndian.PutUint64(buff[4:], uint64(configSeq))
 
 	block := &common.Block{
 		Header: &common.BlockHeader{
@@ -88,11 +106,11 @@ func NewFabricBatchFromRequests(
 			Data: batchedRequests,
 		},
 		Metadata: &common.BlockMetadata{
-			Metadata: [][]byte{{}, {}, {}, {}, {}, buff},
+			Metadata: [][]byte{{}, {}, {}, buff, {}},
 		},
 	}
 
-	return (*FabricBatch)(block), nil
+	return (*FabricBatch)(block)
 }
 
 func NewFabricBatchFromBlock(block *common.Block) (*FabricBatch, error) {
@@ -110,13 +128,13 @@ func NewFabricBatchFromBlock(block *common.Block) (*FabricBatch, error) {
 	}
 
 	m := block.GetMetadata().GetMetadata()
-	if len(m) <= BlockMetadataIndex_PartyShard {
-		return nil, errors.New("missing shard party metadata")
+	if len(m) <= int(BlockMetadataIndex_PartyShardConfigSequence) {
+		return nil, errors.New("missing orderer metadata")
 	}
 
-	buff := m[BlockMetadataIndex_PartyShard]
-	if len(buff) < 4 {
-		return nil, errors.New("bad shard party metadata")
+	buff := m[BlockMetadataIndex_PartyShardConfigSequence]
+	if len(buff) < partyShardConfigSequenceSize {
+		return nil, errors.New("bad orderer metadata")
 	}
 
 	batch := (*FabricBatch)(block)

node/ledger/batch_encoding_test.go

@@ -7,14 +7,14 @@ SPDX-License-Identifier: Apache-2.0
 package ledger_test
 
 import (
+	"bytes"
 	"testing"
 
 	"github.com/hyperledger/fabric-protos-go-apiv2/common"
-	"github.com/stretchr/testify/assert"
-
 	"github.com/hyperledger/fabric-x-orderer/common/types"
+	"github.com/hyperledger/fabric-x-orderer/node/consensus/state"
 	"github.com/hyperledger/fabric-x-orderer/node/ledger"
-
+	"github.com/stretchr/testify/assert"
 	"github.com/stretchr/testify/require"
 )
 
@@ -120,29 +120,38 @@ func TestNewFabricBatchFromBlock(t *testing.T) {
 			expectedErr: "empty block metadata",
 		},
 		{
-			name: "missing shard party metadata 2",
+			name: "missing orderer metadata",
 			block: &common.Block{
 				Header:   header,
 				Data:     data,
-				Metadata: &common.BlockMetadata{Metadata: [][]byte{{}, {}, {}, {}, {}}},
+				Metadata: &common.BlockMetadata{Metadata: [][]byte{{}, {}, {}}},
 			},
-			expectedErr: "missing shard party metadata",
+			expectedErr: "missing orderer metadata",
 		},
 		{
-			name: "bad shard party metadata",
+			name: "bad orderer metadata",
 			block: &common.Block{
 				Header:   header,
 				Data:     data,
 				Metadata: &common.BlockMetadata{Metadata: [][]byte{{}, {}, {}, {}, {}, {}}},
 			},
-			expectedErr: "bad shard party metadata",
+			expectedErr: "bad orderer metadata",
+		},
+		{
+			name: "bad orderer metadata 2",
+			block: &common.Block{
+				Header:   header,
+				Data:     data,
+				Metadata: &common.BlockMetadata{Metadata: [][]byte{{}, {}, {}, {0x01}, {}, {}}},
+			},
+			expectedErr: "bad orderer metadata",
 		},
 		{
 			name: "good",
 			block: &common.Block{
 				Header:   header,
 				Data:     data,
-				Metadata: &common.BlockMetadata{Metadata: [][]byte{{}, {}, {}, {}, {}, {0x01, 0x02, 0x03, 0x04}}},
+				Metadata: &common.BlockMetadata{Metadata: [][]byte{{}, {}, {}, {0x01, 0x02, 0x03, 0x04, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x05}, {}}},
 			},
 			expectedErr: "",
 		},
@@ -156,11 +165,29 @@ func TestNewFabricBatchFromBlock(t *testing.T) {
 				assert.NotNil(t, fb)
 				assert.NoError(t, err)
 				assert.Equal(t, types.BatchSequence(7), fb.Seq())
-				assert.Equal(t, types.PartyID(0x102), fb.Primary())
-				assert.Equal(t, types.ShardID(0x304), fb.Shard())
+				assert.Equal(t, types.ShardID(0x102), fb.Shard())
+				assert.Equal(t, types.PartyID(0x304), fb.Primary())
+				assert.Equal(t, types.ConfigSequence(0x05), fb.ConfigSequence())
 				assert.Len(t, fb.Requests(), 2)
 				assert.Equal(t, header.DataHash, fb.Digest())
 			}
 		})
 	}
 }
+
+func TestNewFabricBatchFromRequests(t *testing.T) {
+	bReqs := types.BatchedRequests([][]byte{{0x08}, {0x09}})
+	fb := ledger.NewFabricBatchFromRequests(2, 3, 4, bReqs, 5, []byte{0x06})
+	require.NotNil(t, fb)
+	require.Equal(t, types.ShardID(2), fb.Shard())
+	require.Equal(t, types.PartyID(3), fb.Primary())
+	require.Equal(t, types.BatchSequence(4), fb.Seq())
+	require.True(t, bytes.Equal(bReqs.Digest(), fb.Digest()))
+	require.Equal(t, types.ConfigSequence(5), fb.ConfigSequence())
+	require.Equal(t, bReqs, fb.Requests())
+
+	require.True(t, bytes.Equal([]byte{0x06}, fb.Header.GetPreviousHash()))
+
+	require.Equal(t, "Sh,Pr,Sq,Dg: <2,3,4,f99be8ba3f263229e64cd89aded97556d208a7650bfd06be5979fbf748f94cbe>", types.BatchIDToString(fb))
+	require.True(t, types.BatchIDEqual(fb, state.NewAvailableBatch(3, 2, 4, bReqs.Digest())))
+}

node/ledger/batch_ledger_part.go

@@ -71,7 +71,7 @@ func newBatchLedgerPart(
 func (b *BatchLedgerPart) Append(seq types.BatchSequence, batchedRequests types.BatchedRequests) {
 	b.logger.Debugf("Party %d, Shard: %d, is appending batch with sequence %d of size %d bytes, from Primary: %d", b.partyID, b.shardID, seq, batchedRequests.SizeBytes(), b.primaryPartyID)
 
-	block, _ := NewFabricBatchFromRequests(b.primaryPartyID, b.shardID, seq, batchedRequests, b.prevHash)
+	block := NewFabricBatchFromRequests(b.shardID, b.primaryPartyID, seq, batchedRequests, 0, b.prevHash)
 
 	// Note: We do this only because we reuse the Fabric ledger, we don't really need a hash chain here.
 	b.prevHash = protoutil.BlockHeaderHash(block.Header)