ETCM-1058 Add new Consensus, by just moving the code in BlockImport

Author: Leonor Boga

src/main/scala/io/iohk/ethereum/blockchain/sync/regular/BlockImportResult.scala

@@ -0,0 +1,25 @@
+package io.iohk.ethereum.blockchain.sync.regular
+
+import io.iohk.ethereum.domain.{Block, ChainWeight}
+import io.iohk.ethereum.ledger.BlockData
+import io.iohk.ethereum.mpt.MerklePatriciaTrie.MissingNodeException
+
+sealed trait BlockImportResult
+
+case class BlockImportedToTop(blockImportData: List[BlockData]) extends BlockImportResult
+
+case object BlockEnqueued extends BlockImportResult
+
+case object DuplicateBlock extends BlockImportResult
+
+case class ChainReorganised(
+    oldBranch: List[Block],
+    newBranch: List[Block],
+    weights: List[ChainWeight]
+) extends BlockImportResult
+
+case class BlockImportFailed(error: String) extends BlockImportResult
+
+case class BlockImportFailedDueToMissingNode(reason: MissingNodeException) extends BlockImportResult
+
+case object UnknownParent extends BlockImportResult

src/main/scala/io/iohk/ethereum/blockchain/sync/regular/BlockImporter.scala

@@ -7,19 +7,17 @@ import akka.actor.ActorRef
 import akka.actor.NotInfluenceReceiveTimeout
 import akka.actor.Props
 import akka.actor.ReceiveTimeout
-
 import cats.data.NonEmptyList
 import cats.implicits._
-
 import monix.eval.Task
 import monix.execution.Scheduler
 
 import scala.concurrent.duration._
-
 import io.iohk.ethereum.blockchain.sync.Blacklist.BlacklistReason
 import io.iohk.ethereum.blockchain.sync.regular.BlockBroadcast.BlockToBroadcast
 import io.iohk.ethereum.blockchain.sync.regular.BlockBroadcasterActor.BroadcastBlocks
 import io.iohk.ethereum.blockchain.sync.regular.RegularSync.ProgressProtocol
+import io.iohk.ethereum.consensus.Consensus
 import io.iohk.ethereum.crypto.kec256
 import io.iohk.ethereum.db.storage.StateStorage
 import io.iohk.ethereum.domain._
@@ -37,8 +35,7 @@ import io.iohk.ethereum.utils.FunctorOps._
 
 class BlockImporter(
     fetcher: ActorRef,
-    blockImport: BlockImport,
-    blockchain: Blockchain,
+    consensus: Consensus,
     blockchainReader: BlockchainReader,
     stateStorage: StateStorage,
     branchResolution: BranchResolution,
@@ -50,6 +47,7 @@ class BlockImporter(
     configBuilder: BlockchainConfigBuilder
 ) extends Actor
     with ActorLogging {
+
   import BlockImporter._
   import configBuilder._
 
@@ -199,8 +197,8 @@ class BlockImporter(
       Task.now((importedBlocks, None))
     } else {
       val restOfBlocks = blocks.tail
-      blockImport
-        .importBlock(blocks.head)
+      consensus
+        .evaluateBranchBlock(blocks.head)
         .flatMap {
           case BlockImportedToTop(_) =>
             tryImportBlocks(restOfBlocks, blocks.head :: importedBlocks)
@@ -238,7 +236,7 @@ class BlockImporter(
     def doLog(entry: ImportMessages.LogEntry): Unit = log.log(entry._1, entry._2)
     importWith(
       Task(doLog(importMessages.preImport()))
-        .flatMap(_ => blockImport.importBlock(block))
+        .flatMap(_ => consensus.evaluateBranchBlock(block))
         .tap((importMessages.messageForImportResult _).andThen(doLog))
         .tap {
           case BlockImportedToTop(importedBlocksData) =>
@@ -330,8 +328,7 @@ object BlockImporter {
   // scalastyle:off parameter.number
   def props(
       fetcher: ActorRef,
-      blockImport: BlockImport,
-      blockchain: Blockchain,
+      consensus: Consensus,
       blockchainReader: BlockchainReader,
       stateStorage: StateStorage,
       branchResolution: BranchResolution,
@@ -345,8 +342,7 @@ object BlockImporter {
     Props(
       new BlockImporter(
         fetcher,
-        blockImport,
-        blockchain,
+        consensus,
         blockchainReader,
         stateStorage,
         branchResolution,

src/main/scala/io/iohk/ethereum/consensus/Consensus.scala

@@ -0,0 +1,68 @@
+package io.iohk.ethereum.consensus
+
+import io.iohk.ethereum.blockchain.sync.regular.BlockImportResult
+import io.iohk.ethereum.domain.Block
+import io.iohk.ethereum.utils.BlockchainConfig
+import monix.eval.Task
+import monix.execution.Scheduler
+
+/** This file documents the original interface that was designed at ETCM-1018
+  * but implements a different one to be used as a stepping stone to the new architecture
+  * still in progress
+  */
+trait Consensus {
+  def evaluateBranchBlock(
+      block: Block
+  )(implicit blockExecutionScheduler: Scheduler, blockchainConfig: BlockchainConfig): Task[BlockImportResult]
+
+  /** Original interface from ETCM-1018, for temporary documentation purposes
+    */
+  /** Answer which branch is best
+    * @return branch.Branch
+    */
+//  def getBestBranch(): branch.Branch = blockchainReader.getBestBranch()
+
+  /** @param branch
+    * This methods received a Branch that was updated by ChainManagement.
+    * When a Branch is updated we need to compare the weight of the current best branch with the
+    * updated one.
+    * If the current best branch is still the best then nothing needs to be done.
+    * If the updated branch is heavier than an attempt to set the updated branch as best branch is done by
+    * executing the blocks in the updated branch to see if it is a valid branch.
+    * If it is not a valid branch then ExecutingSync has to be informed, otherwise update state with new best branch.
+    */
+//  def evaluateBranch(branch: UpdatedBranch): Either[BlockExecutionError, Boolean] =
+//    if (extendsBestBranch()) {
+//      // just validate the latest block
+//      Right(true)
+//    } else {
+//      if (isHeavierThanBestBranch(branch)) {
+//        // create a queue of (branchTip, CancelableFuture)
+//        // if any branch is being executed at the moment while a better one comes is then call the cancellation hook
+//        attemptToSetNewBestBranch(branch) match {
+//          case Right(result) => // save pointer to new best branch
+//            Right(true)
+//          case Left(error) => Left(error)
+//        }
+//      } else {
+//        // nothing
+//        Right(true)
+//      }
+//    }
+
+//  private def extendsBestBranch(): Boolean = ???
+
+  /** Compares the weight of the updatedBranch with the weight of the current best branch
+    * @param updatedBranch
+    * @return true if updatedBranch is heavier than current best branch, false otherwise
+    */
+//  private def isHeavierThanBestBranch(updatedBranch: UpdatedBranch): Boolean = ???
+
+  /** Tries to set a new best branch by executing all blocks in the branch, from the HCB to the branch tip.
+    * We assume the pre validation of the blocks of the branch was done already
+    * @param branch
+    * @return  Either[BlockExecutionError, Boolean]
+    */
+//  private def attemptToSetNewBestBranch(branch: UpdatedBranch): Either[BlockExecutionError, Boolean] = ???
+
+}