rename of NodeSyncError data constructors

Author: Cmdv

cardano-db-sync/src/Cardano/DbSync/Api.hs

@@ -383,15 +383,15 @@ mkSyncEnvFromConfig trce connString backend syncOptions genCfg syncNodeParams ra
   case genCfg of
     GenesisCardano _ bCfg sCfg _
       | unProtocolMagicId (Byron.configProtocolMagicId bCfg) /= Shelley.sgNetworkMagic (scConfig sCfg) ->
-          pure . Left . NECardanoConfig $
+          pure . Left . SNErrCardanoConfig $
             mconcat
               [ "ProtocolMagicId "
               , DB.textShow (unProtocolMagicId $ Byron.configProtocolMagicId bCfg)
               , " /= "
               , DB.textShow (Shelley.sgNetworkMagic $ scConfig sCfg)
               ]
       | Byron.gdStartTime (Byron.configGenesisData bCfg) /= Shelley.sgSystemStart (scConfig sCfg) ->
-          pure . Left . NECardanoConfig $
+          pure . Left . SNErrCardanoConfig $
             mconcat
               [ "SystemStart "
               , DB.textShow (Byron.gdStartTime $ Byron.configGenesisData bCfg)

cardano-db-sync/src/Cardano/DbSync/Cache/Epoch.hs

@@ -71,7 +71,7 @@ writeEpochBlockDiffToCache ::
   ReaderT SqlBackend m (Either SyncNodeError ())
 writeEpochBlockDiffToCache cache epCurrent =
   case cache of
-    UninitiatedCache -> pure $ Left $ NEError "writeEpochBlockDiffToCache: Cache is UninitiatedCache"
+    UninitiatedCache -> pure $ Left $ SNErrDefault "writeEpochBlockDiffToCache: Cache is UninitiatedCache"
     Cache ci -> do
       cE <- liftIO $ readTVarIO (cEpoch ci)
       case (ceMapEpoch cE, ceEpochBlockDiff cE) of
@@ -93,12 +93,12 @@ writeToMapEpochCache syncEnv cache latestEpoch = do
           HasLedger hle -> getSecurityParameter $ leProtocolInfo hle
           NoLedger nle -> getSecurityParameter $ nleProtocolInfo nle
   case cache of
-    UninitiatedCache -> pure $ Left $ NEError "writeToMapEpochCache: Cache is UninitiatedCache"
+    UninitiatedCache -> pure $ Left $ SNErrDefault "writeToMapEpochCache: Cache is UninitiatedCache"
     Cache ci -> do
       -- get EpochBlockDiff so we can use the BlockId we stored when inserting blocks
       epochInternalCE <- readEpochBlockDiffFromCache cache
       case epochInternalCE of
-        Nothing -> pure $ Left $ NEError "writeToMapEpochCache: No epochInternalEpochCache"
+        Nothing -> pure $ Left $ SNErrDefault "writeToMapEpochCache: No epochInternalEpochCache"
         Just ei -> do
           cE <- liftIO $ readTVarIO (cEpoch ci)
           let currentBlockId = ebdBlockId ei

cardano-db-sync/src/Cardano/DbSync/Config/Alonzo.hs

@@ -26,7 +26,7 @@ readAlonzoGenesisConfig ::
   ExceptT SyncNodeError IO AlonzoGenesis
 readAlonzoGenesisConfig enc = do
   let file = unGenesisFile $ dncAlonzoGenesisFile enc
-  firstExceptT (NEAlonzoConfig file . renderAlonzoGenesisError) $
+  firstExceptT (SNErrAlonzoConfig file . renderAlonzoGenesisError) $
     readGenesis (GenesisFile file) Nothing
 
 data AlonzoGenesisError

cardano-db-sync/src/Cardano/DbSync/Config/Byron.hs

@@ -1,6 +1,5 @@
 {-# LANGUAGE FlexibleInstances #-}
 {-# LANGUAGE MultiParamTypeClasses #-}
-{-# LANGUAGE OverloadedStrings #-}
 {-# LANGUAGE RankNTypes #-}
 
 module Cardano.DbSync.Config.Byron (
@@ -20,8 +19,8 @@ readByronGenesisConfig ::
 readByronGenesisConfig enc = do
   let file = unGenesisFile $ dncByronGenesisFile enc
   genHash <-
-    firstExceptT NEError
+    firstExceptT SNErrDefault
       . hoistEither
       $ decodeAbstractHash (unGenesisHashByron $ dncByronGenesisHash enc)
-  firstExceptT (NEByronConfig file) $
+  firstExceptT (SNErrByronConfig file) $
     Byron.mkConfigFromFile (dncRequiresNetworkMagic enc) file genHash

cardano-db-sync/src/Cardano/DbSync/Config/Shelley.hs

@@ -38,7 +38,7 @@ readShelleyGenesisConfig ::
   ExceptT SyncNodeError IO ShelleyConfig
 readShelleyGenesisConfig enc = do
   let file = unGenesisFile $ dncShelleyGenesisFile enc
-  firstExceptT (NEShelleyConfig file . renderShelleyGenesisError) $
+  firstExceptT (SNErrShelleyConfig file . renderShelleyGenesisError) $
     readGenesis (GenesisFile file) Nothing
 
 -- -------------------------------------------------------------------------------------------------

cardano-db-sync/src/Cardano/DbSync/Epoch.hs

@@ -227,7 +227,7 @@ handleEpochCachingWhenSyncing syncEnv cache newestEpochFromMap epochBlockDiffCac
       newEpoch <- DB.queryCalcEpochEntry $ ebdEpochNo currentEpC
       writeToMapEpochCache syncEnv cache newEpoch
     -- There will always be a EpochBlockDiff at this point in time
-    (_, _) -> pure $ Left $ NEError "handleEpochCachingWhenSyncing: No caches available to update cache"
+    (_, _) -> pure $ Left $ SNErrDefault "handleEpochCachingWhenSyncing: No caches available to update cache"
 
 -----------------------------------------------------------------------------------------------------
 -- Helper functions

cardano-db-sync/src/Cardano/DbSync/Era/Byron/Insert.hs

@@ -277,7 +277,7 @@ insertByronTx syncEnv blkId tx blockIndex = do
     annotateTx :: SyncNodeError -> SyncNodeError
     annotateTx ee =
       case ee of
-        NEInvariant loc ei -> NEInvariant loc (annotateInvariantTx (Byron.taTx tx) ei)
+        SNErrInvariant loc ei -> SNErrInvariant loc (annotateInvariantTx (Byron.taTx tx) ei)
         _other -> ee
 
 insertTxOut ::
@@ -331,13 +331,13 @@ resolveTxInputs txIn@(Byron.TxInUtxo txHash index) = do
 
 calculateTxFee :: Byron.Tx -> [(Byron.TxIn, DB.TxId, DB.TxOutId, DbLovelace)] -> Either SyncNodeError ValueFee
 calculateTxFee tx resolvedInputs = do
-  outval <- first (\e -> NEError $ "calculateTxFee: " <> textShow e) output
+  outval <- first (\e -> SNErrDefault $ "calculateTxFee: " <> textShow e) output
   when (null resolvedInputs) $
     Left $
-      NEError "calculateTxFee: List of transaction inputs is zero."
+      SNErrDefault "calculateTxFee: List of transaction inputs is zero."
   let inval = sum $ map (unDbLovelace . forth4) resolvedInputs
   if inval < outval
-    then Left $ NEInvariant "calculateTxFee" $ EInvInOut inval outval
+    then Left $ SNErrInvariant "calculateTxFee" $ EInvInOut inval outval
     else Right $ ValueFee (DbLovelace outval) (DbLovelace $ inval - outval)
   where
     output :: Either Byron.LovelaceError Word64

cardano-db-sync/src/Cardano/DbSync/Era/Shelley/Genesis.hs

@@ -65,8 +65,8 @@ insertValidateGenesisDist syncEnv networkName cfg shelleyInitiation = do
   -- Setting this to True will log all 'Persistent' operations which is great
   -- for debugging, but otherwise *way* too chatty.
   when (not shelleyInitiation && (hasInitialFunds || hasStakes)) $ do
-    liftIO $ logError tracer $ show NEIgnoreShelleyInitiation
-    throwError NEIgnoreShelleyInitiation
+    liftIO $ logError tracer $ show SNErrIgnoreShelleyInitiation
+    throwError SNErrIgnoreShelleyInitiation
   if False
     then newExceptT $ DB.runDbIohkLogging (envBackend syncEnv) tracer (insertAction hasConsumed prunes)
     else newExceptT $ DB.runDbIohkNoLogging (envBackend syncEnv) (insertAction hasConsumed prunes)

cardano-db-sync/src/Cardano/DbSync/Era/Util.hs

@@ -20,7 +20,7 @@ import qualified Data.Text.Encoding.Error as Text
 
 liftLookupFail :: Monad m => Text -> m (Either DB.LookupFail a) -> ExceptT SyncNodeError m a
 liftLookupFail loc =
-  firstExceptT (\lf -> NEError $ mconcat [loc, " ", show lf]) . newExceptT
+  firstExceptT (\lf -> SNErrDefault $ mconcat [loc, " ", show lf]) . newExceptT
 
 safeDecodeUtf8 :: ByteString -> IO (Either Text.UnicodeException Text)
 safeDecodeUtf8 bs

cardano-db-sync/src/Cardano/DbSync/Error.hs

@@ -17,6 +17,7 @@ module Cardano.DbSync.Error (
   hasAbortOnPanicEnv,
 ) where
 
+import Cardano.BM.Trace (Trace, logError)
 import qualified Cardano.Chain.Genesis as Byron
 import qualified Cardano.Chain.UTxO as Byron
 import qualified Cardano.Crypto as Crypto (serializeCborHash)
@@ -25,37 +26,38 @@ import Cardano.DbSync.Util
 import Cardano.Prelude
 import Control.Monad.Trans.Except.Extra (left)
 import qualified Data.ByteString.Base16 as Base16
+import Data.String (String)
 import qualified Data.Text as Text
 import qualified Data.Text.Encoding as Text
+import GHC.IO.Exception (userError)
 import qualified GHC.Show as GShow
-import qualified Text.Show as Text
 import System.Environment (lookupEnv)
 import System.Posix.Process (exitImmediately)
-import Cardano.BM.Trace (Trace, logError)
-import GHC.IO.Exception (userError)
+import qualified Text.Show as Text
 
 data SyncInvariant
   = EInvInOut !Word64 !Word64
   | EInvTxInOut !Byron.Tx !Word64 !Word64
 
 data SyncNodeError
-  = NEError !Text
-  | NEInvariant !Text !SyncInvariant
-  | NEBlockMismatch !Word64 !ByteString !ByteString
-  | NEIgnoreShelleyInitiation
-  | NEByronConfig !FilePath !Byron.ConfigurationError
-  | NEShelleyConfig !FilePath !Text
-  | NEAlonzoConfig !FilePath !Text
-  | NECardanoConfig !Text
+  = SNErrDefault !Text
+  | SNErrInvariant !Text !SyncInvariant
+  | SNEErrBlockMismatch !Word64 !ByteString !ByteString
+  | SNErrIgnoreShelleyInitiation
+  | SNErrByronConfig !FilePath !Byron.ConfigurationError
+  | SNErrShelleyConfig !FilePath !Text
+  | SNErrAlonzoConfig !FilePath !Text
+  | SNErrCardanoConfig !Text
+  | SNErrInsertGenesis !String
 
 instance Exception SyncNodeError
 
 instance Show SyncNodeError where
   show =
     \case
-      NEError t -> "Error: " <> Text.show t
-      NEInvariant loc i -> Text.show loc <> ": " <> Text.show (renderSyncInvariant i)
-      NEBlockMismatch blkNo hashDb hashBlk ->
+      SNErrDefault t -> "Error: " <> Text.show t
+      SNErrInvariant loc i -> Text.show loc <> ": " <> Text.show (renderSyncInvariant i)
+      SNEErrBlockMismatch blkNo hashDb hashBlk ->
         mconcat
           [ "Block mismatch for block number "
           , show blkNo
@@ -64,38 +66,39 @@ instance Show SyncNodeError where
           , " but chain provided "
           , Text.show $ bsBase16Encode hashBlk
           ]
-      NEIgnoreShelleyInitiation ->
+      SNErrIgnoreShelleyInitiation ->
         mconcat
           [ "Node configs that don't fork to Shelley directly and initiate"
           , " funds or stakes in Shelley Genesis are not supported."
           ]
-      NEByronConfig fp ce ->
+      SNErrByronConfig fp ce ->
         mconcat
           [ "Failed reading Byron genesis file "
           , Text.show $ textShow fp
           , ": "
           , Text.show $ textShow ce
           ]
-      NEShelleyConfig fp txt ->
+      SNErrShelleyConfig fp txt ->
         mconcat
           [ "Failed reading Shelley genesis file "
           , Text.show $ textShow fp
           , ": "
           , show txt
           ]
-      NEAlonzoConfig fp txt ->
+      SNErrAlonzoConfig fp txt ->
         mconcat
           [ "Failed reading Alonzo genesis file "
           , Text.show $ textShow fp
           , ": "
           , show txt
           ]
-      NECardanoConfig err ->
+      SNErrCardanoConfig err ->
         mconcat
           [ "With Cardano protocol, Byron/Shelley config mismatch:\n"
           , "   "
           , show err
           ]
+      SNErrInsertGenesis err -> "Error InsertGenesis: " <> err
 
 annotateInvariantTx :: Byron.Tx -> SyncInvariant -> SyncInvariant
 annotateInvariantTx tx ei =
@@ -104,10 +107,10 @@ annotateInvariantTx tx ei =
     _other -> ei
 
 dbSyncNodeError :: Monad m => Text -> ExceptT SyncNodeError m a
-dbSyncNodeError = left . NEError
+dbSyncNodeError = left . SNErrDefault
 
 dbSyncInvariant :: Monad m => Text -> SyncInvariant -> ExceptT SyncNodeError m a
-dbSyncInvariant loc = left . NEInvariant loc
+dbSyncInvariant loc = left . SNErrInvariant loc
 
 renderSyncInvariant :: SyncInvariant -> Text
 renderSyncInvariant ei =