backfiller refactoring; explicity errs; golint

pkg/super_node/backfiller.go

@@ -52,15 +52,19 @@ type BackFillService struct {
 }
 
 // NewBackFillService returns a new BackFillInterface
-func NewBackFillService(ipfsPublisher ipfs.IPLDPublisher, db *postgres.DB, archivalNodeRpcClient core.RpcClient, freq time.Duration) BackFillInterface {
+func NewBackFillService(ipfsPath string, db *postgres.DB, archivalNodeRPCClient core.RpcClient, freq time.Duration) (BackFillInterface, error) {
+	publisher, err := ipfs.NewIPLDPublisher(ipfsPath)
+	if err != nil {
+		return nil, err
+	}
 	return &BackFillService{
 		Repository:        NewCIDRepository(db),
 		Converter:         ipfs.NewPayloadConverter(params.MainnetChainConfig),
-		Publisher:         ipfsPublisher,
+		Publisher:         publisher,
 		Retriever:         NewCIDRetriever(db),
-		StateDiffFetcher:  fetcher.NewStateDiffFetcher(archivalNodeRpcClient),
+		StateDiffFetcher:  fetcher.NewStateDiffFetcher(archivalNodeRPCClient),
 		GapCheckFrequency: freq,
-	}
+	}, nil
 }
 
 // FillGaps periodically checks for and fills in gaps in the super node db
@@ -103,6 +107,7 @@ func (bfs *BackFillService) FillGaps(wg *sync.WaitGroup, quitChan <-chan bool) {
 			}
 		}
 	}()
+	log.Info("fillGaps goroutine successfully spun up")
 }
 
 func (bfs *BackFillService) fillGaps(gap [2]int64) {

pkg/super_node/filterer.go

@@ -44,25 +44,25 @@ func NewResponseFilterer() *Filterer {
 // FilterResponse is used to filter through eth data to extract and package requested data into a Payload
 func (s *Filterer) FilterResponse(streamFilters config.Subscription, payload ipfs.IPLDPayload) (streamer.SuperNodePayload, error) {
 	response := new(streamer.SuperNodePayload)
-	err := s.filterHeaders(streamFilters, response, payload)
-	if err != nil {
-		return streamer.SuperNodePayload{}, err
+	headersErr := s.filterHeaders(streamFilters, response, payload)
+	if headersErr != nil {
+		return streamer.SuperNodePayload{}, headersErr
 	}
-	txHashes, err := s.filterTransactions(streamFilters, response, payload)
-	if err != nil {
-		return streamer.SuperNodePayload{}, err
+	txHashes, trxsErr := s.filterTransactions(streamFilters, response, payload)
+	if trxsErr != nil {
+		return streamer.SuperNodePayload{}, trxsErr
 	}
-	err = s.filerReceipts(streamFilters, response, payload, txHashes)
-	if err != nil {
-		return streamer.SuperNodePayload{}, err
+	rctsErr := s.filerReceipts(streamFilters, response, payload, txHashes)
+	if rctsErr != nil {
+		return streamer.SuperNodePayload{}, rctsErr
 	}
-	err = s.filterState(streamFilters, response, payload)
-	if err != nil {
-		return streamer.SuperNodePayload{}, err
+	stateErr := s.filterState(streamFilters, response, payload)
+	if stateErr != nil {
+		return streamer.SuperNodePayload{}, stateErr
 	}
-	err = s.filterStorage(streamFilters, response, payload)
-	if err != nil {
-		return streamer.SuperNodePayload{}, err
+	storageErr := s.filterStorage(streamFilters, response, payload)
+	if storageErr != nil {
+		return streamer.SuperNodePayload{}, storageErr
 	}
 	response.BlockNumber = payload.BlockNumber
 	return *response, nil
@@ -170,12 +170,12 @@ func checkReceipts(rct *types.Receipt, wantedTopics, actualTopics, wantedContrac
 			if wantedContract == actualContract {
 				if len(wantedTopics) == 0 {
 					return true
-				} else { // Or if we have contracts and topics to filter on we only keep receipts that satisfy both conditions
-					for _, wantedTopic := range wantedTopics {
-						for _, actualTopic := range actualTopics {
-							if wantedTopic == actualTopic {
-								return true
-							}
+				}
+				// Or if we have contracts and topics to filter on we only keep receipts that satisfy both conditions
+				for _, wantedTopic := range wantedTopics {
+					for _, actualTopic := range actualTopics {
+						if wantedTopic == actualTopic {
+							return true
 						}
 					}
 				}

pkg/super_node/repository.go

@@ -44,43 +44,43 @@ func NewCIDRepository(db *postgres.DB) *Repository {
 
 // Index indexes a cidPayload in Postgres
 func (repo *Repository) Index(cidPayload *ipfs.CIDPayload) error {
-	tx, err := repo.db.Beginx()
-	if err != nil {
-		return err
+	tx, beginErr := repo.db.Beginx()
+	if beginErr != nil {
+		return beginErr
 	}
-	headerID, err := repo.indexHeaderCID(tx, cidPayload.HeaderCID, cidPayload.BlockNumber, cidPayload.BlockHash.Hex())
-	if err != nil {
+	headerID, headerErr := repo.indexHeaderCID(tx, cidPayload.HeaderCID, cidPayload.BlockNumber, cidPayload.BlockHash.Hex())
+	if headerErr != nil {
 		rollbackErr := tx.Rollback()
 		if rollbackErr != nil {
 			log.Error(rollbackErr)
 		}
-		return err
+		return headerErr
 	}
 	for uncleHash, cid := range cidPayload.UncleCIDs {
-		err = repo.indexUncleCID(tx, cid, cidPayload.BlockNumber, uncleHash.Hex())
-		if err != nil {
+		uncleErr := repo.indexUncleCID(tx, cid, cidPayload.BlockNumber, uncleHash.Hex())
+		if uncleErr != nil {
 			rollbackErr := tx.Rollback()
 			if rollbackErr != nil {
 				log.Error(rollbackErr)
 			}
-			return err
+			return uncleErr
 		}
 	}
-	err = repo.indexTransactionAndReceiptCIDs(tx, cidPayload, headerID)
-	if err != nil {
+	trxAndRctErr := repo.indexTransactionAndReceiptCIDs(tx, cidPayload, headerID)
+	if trxAndRctErr != nil {
 		rollbackErr := tx.Rollback()
 		if rollbackErr != nil {
 			log.Error(rollbackErr)
 		}
-		return err
+		return trxAndRctErr
 	}
-	err = repo.indexStateAndStorageCIDs(tx, cidPayload, headerID)
-	if err != nil {
+	stateAndStorageErr := repo.indexStateAndStorageCIDs(tx, cidPayload, headerID)
+	if stateAndStorageErr != nil {
 		rollbackErr := tx.Rollback()
 		if rollbackErr != nil {
 			log.Error(rollbackErr)
 		}
-		return err
+		return stateAndStorageErr
 	}
 	return tx.Commit()
 }
@@ -104,18 +104,18 @@ func (repo *Repository) indexUncleCID(tx *sqlx.Tx, cid, blockNumber, hash string
 func (repo *Repository) indexTransactionAndReceiptCIDs(tx *sqlx.Tx, payload *ipfs.CIDPayload, headerID int64) error {
 	for hash, trxCidMeta := range payload.TransactionCIDs {
 		var txID int64
-		err := tx.QueryRowx(`INSERT INTO public.transaction_cids (header_id, tx_hash, cid, dst, src) VALUES ($1, $2, $3, $4, $5) 
+		queryErr := tx.QueryRowx(`INSERT INTO public.transaction_cids (header_id, tx_hash, cid, dst, src) VALUES ($1, $2, $3, $4, $5) 
 									ON CONFLICT (header_id, tx_hash) DO UPDATE SET (cid, dst, src) = ($3, $4, $5)
 									RETURNING id`,
 			headerID, hash.Hex(), trxCidMeta.CID, trxCidMeta.Dst, trxCidMeta.Src).Scan(&txID)
-		if err != nil {
-			return err
+		if queryErr != nil {
+			return queryErr
 		}
 		receiptCidMeta, ok := payload.ReceiptCIDs[hash]
 		if ok {
-			err = repo.indexReceiptCID(tx, receiptCidMeta, txID)
-			if err != nil {
-				return err
+			rctErr := repo.indexReceiptCID(tx, receiptCidMeta, txID)
+			if rctErr != nil {
+				return rctErr
 			}
 		}
 	}
@@ -131,17 +131,17 @@ func (repo *Repository) indexReceiptCID(tx *sqlx.Tx, cidMeta *ipfs.ReceiptMetaDa
 func (repo *Repository) indexStateAndStorageCIDs(tx *sqlx.Tx, payload *ipfs.CIDPayload, headerID int64) error {
 	for accountKey, stateCID := range payload.StateNodeCIDs {
 		var stateID int64
-		err := tx.QueryRowx(`INSERT INTO public.state_cids (header_id, state_key, cid, leaf) VALUES ($1, $2, $3, $4)
+		queryErr := tx.QueryRowx(`INSERT INTO public.state_cids (header_id, state_key, cid, leaf) VALUES ($1, $2, $3, $4)
 									ON CONFLICT (header_id, state_key) DO UPDATE SET (cid, leaf) = ($3, $4)
 									RETURNING id`,
 			headerID, accountKey.Hex(), stateCID.CID, stateCID.Leaf).Scan(&stateID)
-		if err != nil {
-			return err
+		if queryErr != nil {
+			return queryErr
 		}
 		for _, storageCID := range payload.StorageNodeCIDs[accountKey] {
-			err = repo.indexStorageCID(tx, storageCID, stateID)
-			if err != nil {
-				return err
+			storageErr := repo.indexStorageCID(tx, storageCID, stateID)
+			if storageErr != nil {
+				return storageErr
 			}
 		}
 	}

pkg/super_node/retriever.go

@@ -48,13 +48,14 @@ func NewCIDRetriever(db *postgres.DB) *EthCIDRetriever {
 	}
 }
 
+// RetrieveFirstBlockNumber is used to retrieve the first block number in the db
 func (ecr *EthCIDRetriever) RetrieveFirstBlockNumber() (int64, error) {
 	var blockNumber int64
 	err := ecr.db.Get(&blockNumber, "SELECT block_number FROM header_cids ORDER BY block_number ASC LIMIT 1")
 	return blockNumber, err
 }
 
-// GetLastBlockNumber is used to retrieve the latest block number in the cache
+// RetrieveLastBlockNumber is used to retrieve the latest block number in the db
 func (ecr *EthCIDRetriever) RetrieveLastBlockNumber() (int64, error) {
 	var blockNumber int64
 	err := ecr.db.Get(&blockNumber, "SELECT block_number FROM header_cids ORDER BY block_number DESC LIMIT 1 ")
@@ -64,10 +65,9 @@ func (ecr *EthCIDRetriever) RetrieveLastBlockNumber() (int64, error) {
 // RetrieveCIDs is used to retrieve all of the CIDs which conform to the passed StreamFilters
 func (ecr *EthCIDRetriever) RetrieveCIDs(streamFilters config.Subscription, blockNumber int64) (*ipfs.CIDWrapper, error) {
 	log.Debug("retrieving cids")
-	var err error
-	tx, err := ecr.db.Beginx()
-	if err != nil {
-		return nil, err
+	tx, beginErr := ecr.db.Beginx()
+	if beginErr != nil {
+		return nil, beginErr
 	}
 	// THIS IS SUPER EXPENSIVE HAVING TO CYCLE THROUGH EACH BLOCK, NEED BETTER WAY TO FETCH CIDS
 	// WHILE STILL MAINTAINING RELATION INFO ABOUT WHAT BLOCK THE CIDS BELONG TO
@@ -76,24 +76,26 @@ func (ecr *EthCIDRetriever) RetrieveCIDs(streamFilters config.Subscription, bloc
 
 	// Retrieve cached header CIDs
 	if !streamFilters.HeaderFilter.Off {
-		cw.Headers, err = ecr.retrieveHeaderCIDs(tx, streamFilters, blockNumber)
-		if err != nil {
+		var headersErr error
+		cw.Headers, headersErr = ecr.retrieveHeaderCIDs(tx, streamFilters, blockNumber)
+		if headersErr != nil {
 			rollbackErr := tx.Rollback()
 			if rollbackErr != nil {
 				log.Error(rollbackErr)
 			}
 			log.Error("header cid retrieval error")
-			return nil, err
+			return nil, headersErr
 		}
 		if !streamFilters.HeaderFilter.FinalOnly {
-			cw.Uncles, err = ecr.retrieveUncleCIDs(tx, streamFilters, blockNumber)
-			if err != nil {
+			var unclesErr error
+			cw.Uncles, unclesErr = ecr.retrieveUncleCIDs(tx, streamFilters, blockNumber)
+			if unclesErr != nil {
 				rollbackErr := tx.Rollback()
 				if rollbackErr != nil {
 					log.Error(rollbackErr)
 				}
 				log.Error("uncle cid retrieval error")
-				return nil, err
+				return nil, unclesErr
 			}
 		}
 	}
@@ -101,53 +103,57 @@ func (ecr *EthCIDRetriever) RetrieveCIDs(streamFilters config.Subscription, bloc
 	// Retrieve cached trx CIDs
 	var trxIds []int64
 	if !streamFilters.TrxFilter.Off {
-		cw.Transactions, trxIds, err = ecr.retrieveTrxCIDs(tx, streamFilters, blockNumber)
-		if err != nil {
+		var trxsErr error
+		cw.Transactions, trxIds, trxsErr = ecr.retrieveTrxCIDs(tx, streamFilters, blockNumber)
+		if trxsErr != nil {
 			rollbackErr := tx.Rollback()
 			if rollbackErr != nil {
 				log.Error(rollbackErr)
 			}
 			log.Error("transaction cid retrieval error")
-			return nil, err
+			return nil, trxsErr
 		}
 	}
 
 	// Retrieve cached receipt CIDs
 	if !streamFilters.ReceiptFilter.Off {
-		cw.Receipts, err = ecr.retrieveRctCIDs(tx, streamFilters, blockNumber, trxIds)
-		if err != nil {
+		var rctsErr error
+		cw.Receipts, rctsErr = ecr.retrieveRctCIDs(tx, streamFilters, blockNumber, trxIds)
+		if rctsErr != nil {
 			rollbackErr := tx.Rollback()
 			if rollbackErr != nil {
 				log.Error(rollbackErr)
 			}
 			log.Error("receipt cid retrieval error")
-			return nil, err
+			return nil, rctsErr
 		}
 	}
 
 	// Retrieve cached state CIDs
 	if !streamFilters.StateFilter.Off {
-		cw.StateNodes, err = ecr.retrieveStateCIDs(tx, streamFilters, blockNumber)
-		if err != nil {
+		var stateErr error
+		cw.StateNodes, stateErr = ecr.retrieveStateCIDs(tx, streamFilters, blockNumber)
+		if stateErr != nil {
 			rollbackErr := tx.Rollback()
 			if rollbackErr != nil {
 				log.Error(rollbackErr)
 			}
 			log.Error("state cid retrieval error")
-			return nil, err
+			return nil, stateErr
 		}
 	}
 
 	// Retrieve cached storage CIDs
 	if !streamFilters.StorageFilter.Off {
-		cw.StorageNodes, err = ecr.retrieveStorageCIDs(tx, streamFilters, blockNumber)
-		if err != nil {
+		var storageErr error
+		cw.StorageNodes, storageErr = ecr.retrieveStorageCIDs(tx, streamFilters, blockNumber)
+		if storageErr != nil {
 			rollbackErr := tx.Rollback()
 			if rollbackErr != nil {
 				log.Error(rollbackErr)
 			}
 			log.Error("storage cid retrieval error")
-			return nil, err
+			return nil, storageErr
 		}
 	}
 
@@ -310,6 +316,7 @@ type gap struct {
 	Stop  int64 `db:"stop"`
 }
 
+// RetrieveGapsInData is used to find the the block numbers at which we are missing data in the db
 func (ecr *EthCIDRetriever) RetrieveGapsInData() ([][2]int64, error) {
 	pgStr := `SELECT header_cids.block_number + 1 AS start, min(fr.block_number) - 1 AS stop FROM header_cids
 				LEFT JOIN header_cids r on header_cids.block_number = r.block_number - 1

pkg/super_node/service.go

@@ -49,16 +49,13 @@ type NodeInterface interface {
 	// Main event loop for syncAndPublish processes
 	SyncAndPublish(wg *sync.WaitGroup, forwardPayloadChan chan<- ipfs.IPLDPayload, forwardQuitchan chan<- bool) error
 	// Main event loop for handling client pub-sub
-	ScreenAndServe(screenAndServePayload <-chan ipfs.IPLDPayload, screenAndServeQuit <-chan bool)
+	ScreenAndServe(wg *sync.WaitGroup, screenAndServePayload <-chan ipfs.IPLDPayload, screenAndServeQuit <-chan bool)
 	// Method to subscribe to receive state diff processing output
 	Subscribe(id rpc.ID, sub chan<- streamer.SuperNodePayload, quitChan chan<- bool, streamFilters config.Subscription)
 	// Method to unsubscribe from state diff processing
 	Unsubscribe(id rpc.ID)
 	// Method to access the Geth node info for this service
 	Node() core.Node
-	// Method used to retrieve the underlying IPFS publisher for this service, so that is can be used for backfilling
-	// This is needed because it's not possible to initialize two ipfs nodes at the same path
-	GetPublisher() ipfs.IPLDPublisher
 }
 
 // Service is the underlying struct for the super node
@@ -92,18 +89,22 @@ type Service struct {
 	// Number of workers
 	WorkerPoolSize int
 	// Info for the Geth node that this super node is working with
-	gethNode core.Node
+	GethNode core.Node
 }
 
 // NewSuperNode creates a new super_node.Interface using an underlying super_node.Service struct
 func NewSuperNode(ipfsPath string, db *postgres.DB, rpcClient core.RpcClient, qc chan bool, workers int, node core.Node) (NodeInterface, error) {
-	publisher, err := ipfs.NewIPLDPublisher(ipfsPath)
-	if err != nil {
-		return nil, err
+	ipfsInitErr := ipfs.InitIPFSPlugins()
+	if ipfsInitErr != nil {
+		return nil, ipfsInitErr
 	}
-	ipldFetcher, err := ipfs.NewIPLDFetcher(ipfsPath)
-	if err != nil {
-		return nil, err
+	publisher, newPublisherErr := ipfs.NewIPLDPublisher(ipfsPath)
+	if newPublisherErr != nil {
+		return nil, newPublisherErr
+	}
+	ipldFetcher, newFetcherErr := ipfs.NewIPLDFetcher(ipfsPath)
+	if newFetcherErr != nil {
+		return nil, newFetcherErr
 	}
 	return &Service{
 		Streamer:          streamer.NewStateDiffStreamer(rpcClient),
@@ -119,7 +120,7 @@ func NewSuperNode(ipfsPath string, db *postgres.DB, rpcClient core.RpcClient, qc
 		Subscriptions:     make(map[common.Hash]map[rpc.ID]Subscription),
 		SubscriptionTypes: make(map[common.Hash]config.Subscription),
 		WorkerPoolSize:    workers,
-		gethNode:          node,
+		GethNode:          node,
 	}, nil
 }
 
@@ -144,9 +145,9 @@ func (sap *Service) APIs() []rpc.API {
 // This continues on no matter if or how many subscribers there are, it then forwards the data to the ScreenAndServe() loop
 // which filters and sends relevant data to client subscriptions, if there are any
 func (sap *Service) SyncAndPublish(wg *sync.WaitGroup, screenAndServePayload chan<- ipfs.IPLDPayload, screenAndServeQuit chan<- bool) error {
-	sub, err := sap.Streamer.Stream(sap.PayloadChan)
-	if err != nil {
-		return err
+	sub, streamErr := sap.Streamer.Stream(sap.PayloadChan)
+	if streamErr != nil {
+		return streamErr
 	}
 	wg.Add(1)
 
@@ -158,14 +159,13 @@ func (sap *Service) SyncAndPublish(wg *sync.WaitGroup, screenAndServePayload cha
 	for i := 0; i < sap.WorkerPoolSize; i++ {
 		sap.publishAndIndex(i, publishAndIndexPayload, publishAndIndexQuit)
 	}
-
 	go func() {
 		for {
 			select {
 			case payload := <-sap.PayloadChan:
-				ipldPayload, err := sap.Converter.Convert(payload)
-				if err != nil {
-					log.Error(err)
+				ipldPayload, convertErr := sap.Converter.Convert(payload)
+				if convertErr != nil {
+					log.Error(convertErr)
 					continue
 				}
 				// If we have a ScreenAndServe process running, forward the payload to it
@@ -178,8 +178,8 @@ func (sap *Service) SyncAndPublish(wg *sync.WaitGroup, screenAndServePayload cha
 				case publishAndIndexPayload <- *ipldPayload:
 				default:
 				}
-			case err = <-sub.Err():
-				log.Error(err)
+			case subErr := <-sub.Err():
+				log.Error(subErr)
 			case <-sap.QuitChan:
 				// If we have a ScreenAndServe process running, forward the quit signal to it
 				select {
@@ -199,7 +199,7 @@ func (sap *Service) SyncAndPublish(wg *sync.WaitGroup, screenAndServePayload cha
 			}
 		}
 	}()
-
+	log.Info("syncAndPublish goroutine successfully spun up")
 	return nil
 }
 
@@ -208,14 +208,14 @@ func (sap *Service) publishAndIndex(id int, publishAndIndexPayload <-chan ipfs.I
 		for {
 			select {
 			case payload := <-publishAndIndexPayload:
-				cidPayload, err := sap.Publisher.Publish(&payload)
-				if err != nil {
-					log.Errorf("worker %d error: %v", id, err)
+				cidPayload, publishErr := sap.Publisher.Publish(&payload)
+				if publishErr != nil {
+					log.Errorf("worker %d error: %v", id, publishErr)
 					continue
 				}
-				err = sap.Repository.Index(cidPayload)
-				if err != nil {
-					log.Errorf("worker %d error: %v", id, err)
+				indexErr := sap.Repository.Index(cidPayload)
+				if indexErr != nil {
+					log.Errorf("worker %d error: %v", id, indexErr)
 				}
 			case <-publishAndIndexQuit:
 				log.Infof("quiting publishAndIndex worker %d", id)
@@ -223,25 +223,29 @@ func (sap *Service) publishAndIndex(id int, publishAndIndexPayload <-chan ipfs.I
 			}
 		}
 	}()
+	log.Info("publishAndIndex goroutine successfully spun up")
 }
 
 // ScreenAndServe is the loop used to screen data streamed from the state diffing eth node
 // and send the appropriate portions of it to a requesting client subscription, according to their subscription configuration
-func (sap *Service) ScreenAndServe(screenAndServePayload <-chan ipfs.IPLDPayload, screenAndServeQuit <-chan bool) {
+func (sap *Service) ScreenAndServe(wg *sync.WaitGroup, screenAndServePayload <-chan ipfs.IPLDPayload, screenAndServeQuit <-chan bool) {
+	wg.Add(1)
 	go func() {
 		for {
 			select {
 			case payload := <-screenAndServePayload:
-				err := sap.sendResponse(payload)
-				if err != nil {
-					log.Error(err)
+				sendErr := sap.sendResponse(payload)
+				if sendErr != nil {
+					log.Error(sendErr)
 				}
 			case <-screenAndServeQuit:
 				log.Info("quiting ScreenAndServe process")
+				wg.Done()
 				return
 			}
 		}
 	}()
+	log.Info("screenAndServe goroutine successfully spun up")
 }
 
 func (sap *Service) sendResponse(payload ipfs.IPLDPayload) error {
@@ -253,9 +257,9 @@ func (sap *Service) sendResponse(payload ipfs.IPLDPayload) error {
 			log.Errorf("subscription configuration for subscription type %s not available", ty.Hex())
 			continue
 		}
-		response, err := sap.Filterer.FilterResponse(subConfig, payload)
-		if err != nil {
-			log.Error(err)
+		response, filterErr := sap.Filterer.FilterResponse(subConfig, payload)
+		if filterErr != nil {
+			log.Error(filterErr)
 			continue
 		}
 		for id, sub := range subs {
@@ -276,9 +280,9 @@ func (sap *Service) Subscribe(id rpc.ID, sub chan<- streamer.SuperNodePayload, q
 	log.Info("Subscribing to the super node service")
 	// Subscription type is defined as the hash of its content
 	// Group subscriptions by type and screen payloads once for subs of the same type
-	by, err := rlp.EncodeToBytes(streamFilters)
-	if err != nil {
-		log.Error(err)
+	by, encodeErr := rlp.EncodeToBytes(streamFilters)
+	if encodeErr != nil {
+		log.Error(encodeErr)
 	}
 	subscriptionHash := crypto.Keccak256(by)
 	subscriptionType := common.BytesToHash(subscriptionHash)
@@ -307,20 +311,21 @@ func (sap *Service) backFill(sub Subscription, id rpc.ID, con config.Subscriptio
 	// Retrieve cached CIDs relevant to this subscriber
 	var endingBlock int64
 	var startingBlock int64
-	var err error
-	startingBlock, err = sap.Retriever.RetrieveFirstBlockNumber()
-	if err != nil {
+	var retrieveFirstBlockErr error
+	var retrieveLastBlockErr error
+	startingBlock, retrieveFirstBlockErr = sap.Retriever.RetrieveFirstBlockNumber()
+	if retrieveFirstBlockErr != nil {
 		sub.PayloadChan <- streamer.SuperNodePayload{
-			ErrMsg: "unable to set block range start; error: " + err.Error(),
+			ErrMsg: "unable to set block range start; error: " + retrieveFirstBlockErr.Error(),
 		}
 	}
 	if startingBlock < con.StartingBlock.Int64() {
 		startingBlock = con.StartingBlock.Int64()
 	}
-	endingBlock, err = sap.Retriever.RetrieveLastBlockNumber()
-	if err != nil {
+	endingBlock, retrieveLastBlockErr = sap.Retriever.RetrieveLastBlockNumber()
+	if retrieveLastBlockErr != nil {
 		sub.PayloadChan <- streamer.SuperNodePayload{
-			ErrMsg: "unable to set block range end; error: " + err.Error(),
+			ErrMsg: "unable to set block range end; error: " + retrieveLastBlockErr.Error(),
 		}
 	}
 	if endingBlock > con.EndingBlock.Int64() && con.EndingBlock.Int64() > 0 && con.EndingBlock.Int64() > startingBlock {
@@ -333,32 +338,25 @@ func (sap *Service) backFill(sub Subscription, id rpc.ID, con config.Subscriptio
 	// TODO: separate backfill into a different rpc subscription method altogether?
 	go func() {
 		for i := startingBlock; i <= endingBlock; i++ {
-			cidWrapper, err := sap.Retriever.RetrieveCIDs(con, i)
-			if err != nil {
+			cidWrapper, retrieveCIDsErr := sap.Retriever.RetrieveCIDs(con, i)
+			if retrieveCIDsErr != nil {
 				sub.PayloadChan <- streamer.SuperNodePayload{
-					ErrMsg: "CID retrieval error: " + err.Error(),
+					ErrMsg: "CID retrieval error: " + retrieveCIDsErr.Error(),
 				}
 				continue
 			}
 			if ipfs.EmptyCIDWrapper(*cidWrapper) {
 				continue
 			}
-			blocksWrapper, err := sap.IPLDFetcher.FetchCIDs(*cidWrapper)
-			if err != nil {
-				log.Error(err)
+			blocksWrapper, fetchIPLDsErr := sap.IPLDFetcher.FetchIPLDs(*cidWrapper)
+			if fetchIPLDsErr != nil {
+				log.Error(fetchIPLDsErr)
 				sub.PayloadChan <- streamer.SuperNodePayload{
-					ErrMsg: "IPLD fetching error: " + err.Error(),
-				}
-				continue
-			}
-			backFillIplds, err := sap.Resolver.ResolveIPLDs(*blocksWrapper)
-			if err != nil {
-				log.Error(err)
-				sub.PayloadChan <- streamer.SuperNodePayload{
-					ErrMsg: "IPLD resolving error: " + err.Error(),
+					ErrMsg: "IPLD fetching error: " + fetchIPLDsErr.Error(),
 				}
 				continue
 			}
+			backFillIplds := sap.Resolver.ResolveIPLDs(*blocksWrapper)
 			select {
 			case sub.PayloadChan <- backFillIplds:
 				log.Infof("sending super node back-fill payload to subscription %s", id)
@@ -393,7 +391,7 @@ func (sap *Service) Start(*p2p.Server) error {
 	if err := sap.SyncAndPublish(wg, payloadChan, quitChan); err != nil {
 		return err
 	}
-	sap.ScreenAndServe(payloadChan, quitChan)
+	sap.ScreenAndServe(wg, payloadChan, quitChan)
 	return nil
 }
 
@@ -406,7 +404,7 @@ func (sap *Service) Stop() error {
 
 // Node returns the Geth node info for this service
 func (sap *Service) Node() core.Node {
-	return sap.gethNode
+	return sap.GethNode
 }
 
 // close is used to close all listening subscriptions
@@ -426,7 +424,3 @@ func (sap *Service) close() {
 	}
 	sap.Unlock()
 }
-
-func (sap *Service) GetPublisher() ipfs.IPLDPublisher {
-	return sap.Publisher
-}

pkg/super_node/test_helpers.go

@@ -26,6 +26,7 @@ import (
 	"github.com/vulcanize/vulcanizedb/pkg/datastore/postgres"
 )
 
+// SetupDB is use to setup a db for super node tests
 func SetupDB() (*postgres.DB, error) {
 	return postgres.NewDB(config.Database{
 		Hostname: "localhost",
@@ -34,6 +35,7 @@ func SetupDB() (*postgres.DB, error) {
 	}, core.Node{})
 }
 
+// TearDownDB is used to tear down the super node dbs after tests
 func TearDownDB(db *postgres.DB) {
 	tx, err := db.Beginx()
 	Expect(err).NotTo(HaveOccurred())
@@ -55,6 +57,7 @@ func TearDownDB(db *postgres.DB) {
 	Expect(err).NotTo(HaveOccurred())
 }
 
+// ListContainsString used to check if a list of strings contains a particular string
 func ListContainsString(sss []string, s string) bool {
 	for _, str := range sss {
 		if s == str {
@@ -64,6 +67,7 @@ func ListContainsString(sss []string, s string) bool {
 	return false
 }
 
+// ListContainsBytes used to check if a list of byte arrays contains a particular byte array
 func ListContainsBytes(bbb [][]byte, b []byte) bool {
 	for _, by := range bbb {
 		if bytes.Equal(by, b) {