final build

Makefile

@@ -104,6 +104,7 @@ include gotools.mk
 
 .PHONY: all
 all: check-go-version native docker checks
+#all: check-go-version checks
 
 .PHONY: checks
 checks: basic-checks

common/deliver/deliver.go

@@ -52,6 +52,8 @@ type Chain interface {
 
 	// Forked returns a channel which closes when the backing consenter has forked
 	Forked() <-chan struct{}
+
+	ForkedBlock() <-chan *cb.Block
 }
 
 //go:generate counterfeiter -o mock/policy_checker.go -fake-name PolicyChecker . PolicyChecker
@@ -317,6 +319,15 @@ func (h *Handler) deliverBlocks(ctx context.Context, srv *Server, envelope *cb.E
 			return cb.Status_INTERNAL_SERVER_ERROR, errors.Wrapf(ctx.Err(), "context finished before block retrieved")
 		case <-forkedChan:
 			logger.Warningf("[channel: %s] Aborting deliver request for %s because of fork", chdr.ChannelId, addr)
+
+			// TODO: temporarily disabled until figuring out how to send the blocc to the peer from the orderer, i.e. GRPC above
+			//forkedBlock := <-chain.ForkedBlock()
+			//if forkedBlock == nil {
+			//	logger.Warningf("[channel: %s] Aborting deliver request for %s because of fork, but no forked block found", chdr.ChannelId, addr)
+			//} else {
+			//	logger.Debugf("Channel %s forked at block %d", chdr.ChannelId, forkedBlock.String())
+			//}
+
 			return cb.Status_FORKED, nil
 		case <-erroredChan:
 			// TODO, today, the only user of the errorChan is the orderer consensus implementations.  If the peer ever reports

core/deliverservice/deliveryclient.go

@@ -10,14 +10,15 @@ import (
 	"context"
 	"errors"
 	"fmt"
-	"github.com/hyperledger/fabric/gossip/common"
+	"os"
 	"sync"
 	"time"
 
 	"github.com/hyperledger/fabric-protos-go/orderer"
 	errors2 "github.com/hyperledger/fabric/common/errors"
 	"github.com/hyperledger/fabric/common/flogging"
 	"github.com/hyperledger/fabric/common/util"
+	"github.com/hyperledger/fabric/gossip/common"
 	"github.com/hyperledger/fabric/internal/pkg/comm"
 	"github.com/hyperledger/fabric/internal/pkg/identity"
 	"github.com/hyperledger/fabric/internal/pkg/peer/blocksprovider"
@@ -166,7 +167,12 @@ func (d *deliverServiceImpl) StartDeliverForChannel(chainID string, ledgerInfo b
 			if _, ok := err.(*errors2.ForkedTxError); ok {
 				// If a fork is detected, stop the delivery for the channel
 				logger.Errorf("Fork occurred for channel %s. "+
-					"All subsequent blocks may be compromised.", chainID, err)
+					"All subsequent blocks may be compromised.", chainID)
+				// If a fork is detected, write the fork information to storage
+				writeErr := writeForkInfoToFile(chainID)
+				if writeErr != nil {
+					logger.Errorf("Failed to write fork information: %s", writeErr)
+				}
 				err = d.StopDeliverForChannel(chainID)
 				if err != nil {
 					logger.Errorf("Fork occurred but Fabric failed to stop delivery for channel %s: %s. "+
@@ -186,6 +192,23 @@ func (d *deliverServiceImpl) StartDeliverForChannel(chainID string, ledgerInfo b
 	return nil
 }
 
+func writeForkInfoToFile(channelID string) error {
+	filename := fmt.Sprintf("/var/hyperledger/production/ledgersData/chains/chains/%s/fork_info.txt", channelID)
+
+	// Open the file for writing
+	file, err := os.OpenFile(filename, os.O_APPEND|os.O_CREATE|os.O_WRONLY, 0o644)
+	if err != nil {
+		return err
+	}
+	defer file.Close()
+
+	// Write the fork information to the file
+	// For now, just writing a simple message.
+	// TODO: write the entire block or other details.
+	_, err = file.WriteString(fmt.Sprintf("Fork detected for channel %s", channelID))
+	return err
+}
+
 // StopDeliverForChannel stops blocks delivery for channel by stopping channel block provider
 func (d *deliverServiceImpl) StopDeliverForChannel(chainID string) error {
 	d.lock.Lock()

core/peer/channel.go

@@ -162,6 +162,10 @@ func (c *Channel) Forked() <-chan struct{} {
 	return nil
 }
 
+func (c *Channel) ForkedBlock() <-chan *common.Block {
+	return nil
+}
+
 func capabilitiesSupportedOrPanic(res channelconfig.Resources) {
 	ac, ok := res.ApplicationConfig()
 	if !ok {

core/scc/bscc/bscc.go

@@ -1,7 +1,16 @@
+/*
+BLOCC Project
+SPDX-License-Identifier: Apache-2.0
+*/
+
 package bscc
 
 import (
+	"encoding/json"
 	"fmt"
+	"io/ioutil"
+	"os"
+
 	"github.com/hyperledger/fabric-chaincode-go/shim"
 	pb "github.com/hyperledger/fabric-protos-go/peer"
 	"github.com/hyperledger/fabric/bccsp"
@@ -11,8 +20,6 @@ import (
 	blocc "github.com/hyperledger/fabric/internal/peer/blocc/chaincode"
 	"github.com/hyperledger/fabric/protoutil"
 	"github.com/pkg/errors"
-	"io/ioutil"
-	"os"
 )
 
 func New(peerInstance *peer.Peer) *BSCC {
@@ -45,6 +52,7 @@ var bloccProtoLogger = flogging.MustGetLogger("bscc")
 const (
 	approveSensoryReading string = "ApproveSensoryReading"
 	simulateForkAttempt   string = "SimulateForkAttempt"
+	checkForkStatus       string = "CheckForkStatus"
 )
 
 // ------------------- Error handling ------------------- //
@@ -120,6 +128,9 @@ func (bscc *BSCC) Invoke(stub shim.ChaincodeStubInterface) pb.Response {
 	case simulateForkAttempt:
 		bloccProtoLogger.Warningf("Adding a fork block!")
 		return shim.Success(nil)
+	case checkForkStatus:
+		bloccProtoLogger.Infof("Checking fork status")
+		return bscc.CheckForkStatus(string(args[1]))
 	}
 
 	return shim.Error(fmt.Sprintf("Requested function %s not found.", fname))
@@ -208,3 +219,31 @@ func (bscc *BSCC) approveSensoryReading(address, rootCertFilePath string, event
 
 	return err
 }
+
+func (bscc *BSCC) CheckForkStatus(channelID string) pb.Response {
+	if channelID == "" {
+		return shim.Error("ChannelID not specified")
+	}
+
+	var err error
+	var isForked bool
+
+	// Define the filename based on the channel ID
+	filename := fmt.Sprintf("/var/hyperledger/production/ledgersData/chains/chains/%s/fork_info.txt", channelID)
+
+	// Check if the file exists
+	if _, err = os.Stat(filename); os.IsNotExist(err) {
+		isForked = false
+	} else {
+		isForked = true
+	}
+
+	jsonResponse, err := json.Marshal(isForked)
+	if err != nil {
+		errMsg := fmt.Sprintf("BLOCC: Failed to marshal the result to JSON, error %s", err)
+		bloccProtoLogger.Error(errMsg)
+		return shim.Error(errMsg)
+	}
+
+	return shim.Success(jsonResponse)
+}

core/scc/qscc/query.go

@@ -9,14 +9,14 @@ package qscc
 import (
 	"encoding/json"
 	"fmt"
-	"github.com/hyperledger/fabric/protoutil"
 	"strconv"
 
 	"github.com/hyperledger/fabric-chaincode-go/shim"
 	pb "github.com/hyperledger/fabric-protos-go/peer"
 	"github.com/hyperledger/fabric/common/flogging"
 	"github.com/hyperledger/fabric/core/aclmgmt"
 	"github.com/hyperledger/fabric/core/ledger"
+	"github.com/hyperledger/fabric/protoutil"
 )
 
 // LedgerGetter gets the PeerLedger associated with a channel.
@@ -251,7 +251,7 @@ func getApprovedTransactions(vledger ledger.PeerLedger, chaincodeName []byte) pb
 				return shim.Error(errMsg)
 			}
 
-			qscclogger.Debugf("BLOCC: block %d, approvingMspId=%s, approvedTxId=%s, temperature=%d, relativeHumidity=%d, timestamp=%d",
+			qscclogger.Debugf("BLOCC: block %d, approvingMspId=%s, approvedTxId=%s, temperature=%f, relativeHumidity=%f, timestamp=%d",
 				blockNum, mspId, approvedTxId, temperature, relativeHumidity, timestamp)
 
 			agreements[approvedTxId] = OutputEntry{
@@ -281,7 +281,6 @@ func getApprovedTransactions(vledger ledger.PeerLedger, chaincodeName []byte) pb
 	}
 
 	return shim.Success(jsonResponse)
-
 }
 
 func getTransactionByID(vledger ledger.PeerLedger, tid []byte) pb.Response {

internal/peer/blocc/chaincode/simulatefork.go

@@ -1,8 +1,15 @@
+/*
+BLOCC Project
+SPDX-License-Identifier: Apache-2.0
+*/
+
 package chaincode
 
 import (
 	"context"
 	"crypto/tls"
+	"time"
+
 	cb "github.com/hyperledger/fabric-protos-go/common"
 	pb "github.com/hyperledger/fabric-protos-go/peer"
 	"github.com/hyperledger/fabric/bccsp"
@@ -12,7 +19,6 @@ import (
 	"github.com/pkg/errors"
 	"github.com/spf13/cobra"
 	"github.com/spf13/viper"
-	"time"
 )
 
 type SimulateForkAttempt struct {

orderer/common/multichannel/util_test.go

@@ -27,6 +27,16 @@ type mockChainCluster struct {
 	*mockChain
 }
 
+func (c *mockChainCluster) Forked() <-chan struct{} {
+	// TODO implement me
+	panic("implement me")
+}
+
+func (c *mockChainCluster) ForkedBlock() <-chan *cb.Block {
+	// TODO implement me
+	panic("implement me")
+}
+
 func (c *mockChainCluster) StatusReport() (types.ConsensusRelation, types.Status) {
 	return types.ConsensusRelationConsenter, types.StatusActive
 }
@@ -39,6 +49,16 @@ type mockChain struct {
 	done     chan struct{}
 }
 
+func (mch *mockChain) Forked() <-chan struct{} {
+	// TODO implement me
+	panic("implement me")
+}
+
+func (mch *mockChain) ForkedBlock() <-chan *cb.Block {
+	// TODO implement me
+	panic("implement me")
+}
+
 func (mch *mockChain) Errored() <-chan struct{} {
 	return nil
 }

orderer/consensus/consensus.go

@@ -86,6 +86,8 @@ type Chain interface {
 	// Forked returns a channel which closes when the backing consenter has forked
 	Forked() <-chan struct{}
 
+	ForkedBlock() <-chan *cb.Block
+
 	// Start should allocate whatever resources are needed for staying up to date with the chain.
 	// Typically, this involves creating a thread which reads from the ordering source, passes those
 	// messages to a block cutter, and writes the resulting blocks to the ledger.