support/storage: Add GetLatestLedgerSequence method to Archive interface

exp/services/ledgerexporter/internal/config.go

@@ -124,8 +124,8 @@ func (config *Config) ValidateAndSetLedgerRange(ctx context.Context, archive his
 		return errors.New("invalid end value, must be greater than start")
 	}
 
-	latestNetworkLedger, err := datastore.GetLatestLedgerSequenceFromHistoryArchives(archive)
-	latestNetworkLedger = latestNetworkLedger + (datastore.GetHistoryArchivesCheckPointFrequency() * 2)
+	latestNetworkLedger, err := archive.GetLatestLedgerSequence()
+	latestNetworkLedger = latestNetworkLedger + (archive.GetCheckpointManager().GetCheckpointFrequency() * 2)
 
 	if err != nil {
 		return errors.Wrap(err, "Failed to retrieve the latest ledger sequence from history archives.")
@@ -189,7 +189,7 @@ func (config *Config) GenerateCaptiveCoreConfig(coreBinFromPath string) (ledgerb
 		BinaryPath:          config.StellarCoreConfig.StellarCoreBinaryPath,
 		NetworkPassphrase:   params.NetworkPassphrase,
 		HistoryArchiveURLs:  params.HistoryArchiveURLs,
-		CheckpointFrequency: datastore.GetHistoryArchivesCheckPointFrequency(),
+		CheckpointFrequency: historyarchive.DefaultCheckpointFrequency,
 		Log:                 logger.WithField("subservice", "stellar-core"),
 		Toml:                captiveCoreToml,
 		UserAgent:           "ledger-exporter",

exp/services/ledgerexporter/internal/config_test.go

@@ -5,19 +5,20 @@ import (
 	"fmt"
 	"testing"
 
+	"github.com/stellar/go/historyarchive"
 	"github.com/stellar/go/network"
-	"github.com/stellar/go/support/datastore"
 
 	"github.com/stretchr/testify/require"
-
-	"github.com/stellar/go/historyarchive"
 )
 
 func TestNewConfig(t *testing.T) {
 	ctx := context.Background()
 
 	mockArchive := &historyarchive.MockArchive{}
-	mockArchive.On("GetRootHAS").Return(historyarchive.HistoryArchiveState{CurrentLedger: 5}, nil).Once()
+	mockArchive.On("GetLatestLedgerSequence").Return(uint32(5), nil).Once()
+	mockArchive.On("GetCheckpointManager").
+		Return(historyarchive.NewCheckpointManager(
+			historyarchive.DefaultCheckpointFrequency)).Once()
 
 	config, err := NewConfig(
 		RuntimeSettings{StartLedger: 2, EndLedger: 3, ConfigFilePath: "test/test.toml", Mode: Append}, nil)
@@ -198,7 +199,7 @@ func TestInvalidCaptiveCoreTomlPath(t *testing.T) {
 
 func TestValidateStartAndEndLedger(t *testing.T) {
 	latestNetworkLedger := uint32(20000)
-	latestNetworkLedgerPadding := datastore.GetHistoryArchivesCheckPointFrequency() * 2
+	latestNetworkLedgerPadding := historyarchive.DefaultCheckpointFrequency * 2
 
 	tests := []struct {
 		name        string
@@ -282,7 +283,10 @@ func TestValidateStartAndEndLedger(t *testing.T) {
 
 	ctx := context.Background()
 	mockArchive := &historyarchive.MockArchive{}
-	mockArchive.On("GetRootHAS").Return(historyarchive.HistoryArchiveState{CurrentLedger: latestNetworkLedger}, nil)
+	mockArchive.On("GetLatestLedgerSequence").Return(latestNetworkLedger, nil)
+	mockArchive.On("GetCheckpointManager").
+		Return(historyarchive.NewCheckpointManager(
+			historyarchive.DefaultCheckpointFrequency))
 
 	mockedHasCtr := 0
 	for _, tt := range tests {
@@ -302,7 +306,7 @@ func TestValidateStartAndEndLedger(t *testing.T) {
 			}
 		})
 	}
-	mockArchive.AssertNumberOfCalls(t, "GetRootHAS", mockedHasCtr)
+	mockArchive.AssertExpectations(t)
 }
 
 func TestAdjustedLedgerRangeBoundedMode(t *testing.T) {
@@ -358,7 +362,10 @@ func TestAdjustedLedgerRangeBoundedMode(t *testing.T) {
 
 	ctx := context.Background()
 	mockArchive := &historyarchive.MockArchive{}
-	mockArchive.On("GetRootHAS").Return(historyarchive.HistoryArchiveState{CurrentLedger: 500}, nil).Times(len(tests))
+	mockArchive.On("GetLatestLedgerSequence").Return(uint32(500), nil)
+	mockArchive.On("GetCheckpointManager").
+		Return(historyarchive.NewCheckpointManager(
+			historyarchive.DefaultCheckpointFrequency))
 
 	for _, tt := range tests {
 		t.Run(tt.name, func(t *testing.T) {
@@ -421,7 +428,10 @@ func TestAdjustedLedgerRangeUnBoundedMode(t *testing.T) {
 	ctx := context.Background()
 
 	mockArchive := &historyarchive.MockArchive{}
-	mockArchive.On("GetRootHAS").Return(historyarchive.HistoryArchiveState{CurrentLedger: 500}, nil).Times(len(tests))
+	mockArchive.On("GetLatestLedgerSequence").Return(uint32(500), nil)
+	mockArchive.On("GetCheckpointManager").
+		Return(historyarchive.NewCheckpointManager(
+			historyarchive.DefaultCheckpointFrequency))
 
 	for _, tt := range tests {
 		t.Run(tt.name, func(t *testing.T) {

historyarchive/archive.go

@@ -71,6 +71,7 @@ type ArchiveInterface interface {
 	GetLedgerHeader(chk uint32) (xdr.LedgerHeaderHistoryEntry, error)
 	GetRootHAS() (HistoryArchiveState, error)
 	GetLedgers(start, end uint32) (map[uint32]*Ledger, error)
+	GetLatestLedgerSequence() (uint32, error)
 	GetCheckpointHAS(chk uint32) (HistoryArchiveState, error)
 	PutCheckpointHAS(chk uint32, has HistoryArchiveState, opts *CommandOptions) error
 	PutRootHAS(has HistoryArchiveState, opts *CommandOptions) error
@@ -176,6 +177,16 @@ func (a *Archive) PutPathHAS(path string, has HistoryArchiveState, opts *Command
 	return a.backend.PutFile(path, io.NopCloser(bytes.NewReader(buf)))
 }
 
+func (a *Archive) GetLatestLedgerSequence() (uint32, error) {
+	has, err := a.GetRootHAS()
+	if err != nil {
+		log.Error("Error getting root HAS from archive", err)
+		return 0, errors.Wrap(err, "failed to retrieve the latest ledger sequence from history archive")
+	}
+
+	return has.CurrentLedger, nil
+}
+
 func (a *Archive) BucketExists(bucket Hash) (bool, error) {
 	return a.cachedExists(BucketPath(bucket))
 }

historyarchive/archive_pool.go

@@ -204,6 +204,16 @@ func (pa *ArchivePool) GetCheckpointHAS(chk uint32) (HistoryArchiveState, error)
 	})
 }
 
+func (pa *ArchivePool) GetLatestLedgerSequence() (uint32, error) {
+	has, err := pa.GetRootHAS()
+	if err != nil {
+		log.Error("Error getting root HAS from archive", err)
+		return 0, errors.Wrap(err, "failed to retrieve the latest ledger sequence from history archive")
+	}
+
+	return has.CurrentLedger, nil
+}
+
 func (pa *ArchivePool) PutCheckpointHAS(chk uint32, has HistoryArchiveState, opts *CommandOptions) error {
 	return pa.runRoundRobin(func(ai ArchiveInterface) error {
 		return ai.PutCheckpointHAS(chk, has, opts)

historyarchive/mocks.go

@@ -10,6 +10,11 @@ type MockArchive struct {
 	mock.Mock
 }
 
+func (m *MockArchive) GetLatestLedgerSequence() (uint32, error) {
+	a := m.Called()
+	return a.Get(0).(uint32), a.Error(1)
+}
+
 func (m *MockArchive) GetCheckpointManager() CheckpointManager {
 	a := m.Called()
 	return a.Get(0).(CheckpointManager)

support/datastore/resumablemanager_test.go

@@ -282,8 +282,12 @@ func TestResumability(t *testing.T) {
 	for _, tt := range tests {
 		t.Run(tt.name, func(t *testing.T) {
 			mockArchive := &historyarchive.MockArchive{}
-			mockArchive.On("GetRootHAS").Return(historyarchive.HistoryArchiveState{CurrentLedger: tt.latestLedger}, tt.archiveError).Once()
-
+			mockArchive.On("GetLatestLedgerSequence").Return(tt.latestLedger, tt.archiveError).Once()
+			if tt.archiveError == nil {
+				mockArchive.On("GetCheckpointManager").
+					Return(historyarchive.NewCheckpointManager(
+						historyarchive.DefaultCheckpointFrequency)).Once()
+			}
 			mockDataStore := &MockDataStore{}
 			tt.registerMockCalls(mockDataStore)
 

support/datastore/resumeablemanager.go

@@ -62,12 +62,12 @@ func (rm resumableManagerService) FindStart(ctx context.Context, start, end uint
 	networkLatest := uint32(0)
 	if end < 1 {
 		var latestErr error
-		networkLatest, latestErr = GetLatestLedgerSequenceFromHistoryArchives(rm.archive)
+		networkLatest, latestErr = rm.archive.GetLatestLedgerSequence()
 		if latestErr != nil {
 			err := errors.Wrap(latestErr, "Resumability of requested export ledger range, was not able to get latest ledger from network")
 			return 0, false, err
 		}
-		networkLatest = networkLatest + (GetHistoryArchivesCheckPointFrequency() * 2)
+		networkLatest = networkLatest + (rm.archive.GetCheckpointManager().GetCheckpointFrequency() * 2)
 		log.Infof("Resumability computed effective latest network ledger including padding of checkpoint frequency to be %d", networkLatest)
 
 		if start > networkLatest {