Feat/sovereign

cmd/elasticindexer/flags.go

@@ -47,4 +47,9 @@ var (
 		Name:  "disable-ansi-color",
 		Usage: "Boolean option for disabling ANSI colors in the logging system.",
 	}
+	// sovereign defines a flag that specifies if the es instance should run for a sovereign chain
+	sovereign = cli.BoolFlag{
+		Name:  "sovereign",
+		Usage: "If set to true, will use sovereign run type components",
+	}
 )

cmd/elasticindexer/main.go

@@ -11,13 +11,14 @@ import (
 	"github.com/multiversx/mx-chain-core-go/core/check"
 	"github.com/multiversx/mx-chain-core-go/core/closing"
 	"github.com/multiversx/mx-chain-core-go/data/outport"
+	logger "github.com/multiversx/mx-chain-logger-go"
+	"github.com/multiversx/mx-chain-logger-go/file"
+	"github.com/urfave/cli"
+
 	"github.com/multiversx/mx-chain-es-indexer-go/config"
 	"github.com/multiversx/mx-chain-es-indexer-go/factory"
 	"github.com/multiversx/mx-chain-es-indexer-go/metrics"
 	"github.com/multiversx/mx-chain-es-indexer-go/process/wsindexer"
-	logger "github.com/multiversx/mx-chain-logger-go"
-	"github.com/multiversx/mx-chain-logger-go/file"
-	"github.com/urfave/cli"
 )
 
 var (
@@ -63,6 +64,7 @@ func main() {
 		logLevel,
 		logSaveFile,
 		disableAnsiColor,
+		sovereign,
 	}
 	app.Authors = []cli.Author{
 		{
@@ -86,6 +88,7 @@ func startIndexer(ctx *cli.Context) error {
 	if err != nil {
 		return fmt.Errorf("%w while loading the config file", err)
 	}
+	cfg.Sovereign = ctx.GlobalBool(sovereign.Name)
 
 	clusterCfg, err := loadClusterConfig(ctx.GlobalString(configurationPreferencesFile.Name))
 	if err != nil {

config/config.go

@@ -29,6 +29,7 @@ type Config struct {
 			LogsPath             string `toml:"logs-path"`
 		} `toml:"logs"`
 	} `toml:"config"`
+	Sovereign bool
 }
 
 // ClusterConfig will hold the config for the Elasticsearch cluster

factory/runType/errors.go

@@ -0,0 +1,7 @@
+package runType
+
+import (
+	"errors"
+)
+
+var errNilRunTypeComponents = errors.New("nil run type components")

factory/runType/interface.go

@@ -0,0 +1,36 @@
+package runType
+
+import (
+	"github.com/multiversx/mx-chain-es-indexer-go/process/elasticproc/transactions"
+)
+
+// RunTypeComponentsCreator is the interface for creating run type components
+type RunTypeComponentsCreator interface {
+	Create() *runTypeComponents
+	IsInterfaceNil() bool
+}
+
+// ComponentHandler defines the actions common to all component handlers
+type ComponentHandler interface {
+	Create() error
+	Close() error
+	CheckSubcomponents() error
+	String() string
+}
+
+// RunTypeComponentsHandler defines the run type components handler actions
+type RunTypeComponentsHandler interface {
+	ComponentHandler
+	RunTypeComponentsHolder
+}
+
+// RunTypeComponentsHolder holds the run type components
+type RunTypeComponentsHolder interface {
+	TxHashExtractorCreator() transactions.TxHashExtractor
+	RewardTxDataCreator() transactions.RewardTxDataHandler
+	Create() error
+	Close() error
+	CheckSubcomponents() error
+	String() string
+	IsInterfaceNil() bool
+}

factory/runType/runTypeComponents.go

@@ -0,0 +1,20 @@
+package runType
+
+import (
+	"github.com/multiversx/mx-chain-es-indexer-go/process/elasticproc/transactions"
+)
+
+type runTypeComponents struct {
+	txHashExtractor transactions.TxHashExtractor
+	rewardTxData    transactions.RewardTxDataHandler
+}
+
+// Close does nothing
+func (rtc *runTypeComponents) Close() error {
+	return nil
+}
+
+// IsInterfaceNil returns true if there is no value under the interface
+func (rtc *runTypeComponents) IsInterfaceNil() bool {
+	return rtc == nil
+}

factory/runType/runTypeComponentsFactory.go

@@ -0,0 +1,25 @@
+package runType
+
+import (
+	"github.com/multiversx/mx-chain-es-indexer-go/process/elasticproc/transactions"
+)
+
+type runTypeComponentsFactory struct{}
+
+// NewRunTypeComponentsFactory will return a new instance of run type components factory
+func NewRunTypeComponentsFactory() *runTypeComponentsFactory {
+	return &runTypeComponentsFactory{}
+}
+
+// Create will create the run type components
+func (rtcf *runTypeComponentsFactory) Create() *runTypeComponents {
+	return &runTypeComponents{
+		txHashExtractor: transactions.NewTxHashExtractor(),
+		rewardTxData:    transactions.NewRewardTxData(),
+	}
+}
+
+// IsInterfaceNil returns true if there is no value under the interface
+func (rtcf *runTypeComponentsFactory) IsInterfaceNil() bool {
+	return rtcf == nil
+}

factory/runType/runTypeComponentsHandler.go

@@ -0,0 +1,113 @@
+package runType
+
+import (
+	"sync"
+
+	"github.com/multiversx/mx-chain-core-go/core/check"
+
+	"github.com/multiversx/mx-chain-es-indexer-go/process/elasticproc/transactions"
+)
+
+const runTypeComponentsName = "managedRunTypeComponents"
+
+var _ ComponentHandler = (*managedRunTypeComponents)(nil)
+var _ RunTypeComponentsHandler = (*managedRunTypeComponents)(nil)
+var _ RunTypeComponentsHolder = (*managedRunTypeComponents)(nil)
+
+type managedRunTypeComponents struct {
+	*runTypeComponents
+	factory                  RunTypeComponentsCreator
+	mutRunTypeCoreComponents sync.RWMutex
+}
+
+// NewManagedRunTypeComponents returns a news instance of managed runType core components
+func NewManagedRunTypeComponents(rtc RunTypeComponentsCreator) (*managedRunTypeComponents, error) {
+	if rtc == nil {
+		return nil, errNilRunTypeComponents
+	}
+
+	return &managedRunTypeComponents{
+		runTypeComponents: nil,
+		factory:           rtc,
+	}, nil
+}
+
+// Create will create the managed components
+func (mrtc *managedRunTypeComponents) Create() error {
+	rtc := mrtc.factory.Create()
+
+	mrtc.mutRunTypeCoreComponents.Lock()
+	mrtc.runTypeComponents = rtc
+	mrtc.mutRunTypeCoreComponents.Unlock()
+
+	return nil
+}
+
+// Close will close all underlying subcomponents
+func (mrtc *managedRunTypeComponents) Close() error {
+	mrtc.mutRunTypeCoreComponents.Lock()
+	defer mrtc.mutRunTypeCoreComponents.Unlock()
+
+	if check.IfNil(mrtc.runTypeComponents) {
+		return nil
+	}
+
+	err := mrtc.runTypeComponents.Close()
+	if err != nil {
+		return err
+	}
+	mrtc.runTypeComponents = nil
+
+	return nil
+}
+
+// CheckSubcomponents verifies all subcomponents
+func (mrtc *managedRunTypeComponents) CheckSubcomponents() error {
+	mrtc.mutRunTypeCoreComponents.RLock()
+	defer mrtc.mutRunTypeCoreComponents.RUnlock()
+
+	if check.IfNil(mrtc.runTypeComponents) {
+		return errNilRunTypeComponents
+	}
+	if check.IfNil(mrtc.txHashExtractor) {
+		return transactions.ErrNilTxHashExtractor
+	}
+	if check.IfNil(mrtc.rewardTxData) {
+		return transactions.ErrNilRewardTxDataHandler
+	}
+	return nil
+}
+
+// TxHashExtractorCreator returns tx hash extractor
+func (mrtc *managedRunTypeComponents) TxHashExtractorCreator() transactions.TxHashExtractor {
+	mrtc.mutRunTypeCoreComponents.Lock()
+	defer mrtc.mutRunTypeCoreComponents.Unlock()
+
+	if check.IfNil(mrtc.runTypeComponents) {
+		return nil
+	}
+
+	return mrtc.runTypeComponents.txHashExtractor
+}
+
+// RewardTxDataCreator return reward tx handler
+func (mrtc *managedRunTypeComponents) RewardTxDataCreator() transactions.RewardTxDataHandler {
+	mrtc.mutRunTypeCoreComponents.Lock()
+	defer mrtc.mutRunTypeCoreComponents.Unlock()
+
+	if check.IfNil(mrtc.runTypeComponents) {
+		return nil
+	}
+
+	return mrtc.runTypeComponents.rewardTxData
+}
+
+// IsInterfaceNil returns true if the interface is nil
+func (mrtc *managedRunTypeComponents) IsInterfaceNil() bool {
+	return mrtc == nil
+}
+
+// String returns the name of the component
+func (mrtc *managedRunTypeComponents) String() string {
+	return runTypeComponentsName
+}

factory/runType/runTypeComponentsHandler_test.go

@@ -0,0 +1,80 @@
+package runType
+
+import (
+	"testing"
+
+	"github.com/stretchr/testify/require"
+)
+
+func createComponents() (RunTypeComponentsHandler, error) {
+	rtcf := NewRunTypeComponentsFactory()
+	return NewManagedRunTypeComponents(rtcf)
+}
+
+func TestNewManagedRunTypeComponents(t *testing.T) {
+	t.Parallel()
+
+	t.Run("should error", func(t *testing.T) {
+		managedRunTypeComponents, err := NewManagedRunTypeComponents(nil)
+		require.ErrorIs(t, err, errNilRunTypeComponents)
+		require.Nil(t, managedRunTypeComponents)
+	})
+	t.Run("should work", func(t *testing.T) {
+		rtcf := NewRunTypeComponentsFactory()
+		managedRunTypeComponents, err := NewManagedRunTypeComponents(rtcf)
+		require.NoError(t, err)
+		require.False(t, managedRunTypeComponents.IsInterfaceNil())
+	})
+}
+
+func TestManagedRunTypeComponents_Create(t *testing.T) {
+	t.Parallel()
+
+	t.Run("should work with getters", func(t *testing.T) {
+		t.Parallel()
+
+		managedRunTypeComponents, err := createComponents()
+		require.NoError(t, err)
+
+		require.Nil(t, managedRunTypeComponents.TxHashExtractorCreator())
+		require.Nil(t, managedRunTypeComponents.RewardTxDataCreator())
+
+		err = managedRunTypeComponents.Create()
+		require.NoError(t, err)
+
+		require.NotNil(t, managedRunTypeComponents.TxHashExtractorCreator())
+		require.NotNil(t, managedRunTypeComponents.RewardTxDataCreator())
+
+		require.Equal(t, runTypeComponentsName, managedRunTypeComponents.String())
+		require.NoError(t, managedRunTypeComponents.Close())
+	})
+}
+
+func TestManagedRunTypeComponents_Close(t *testing.T) {
+	t.Parallel()
+
+	managedRunTypeComponents, _ := createComponents()
+	require.NoError(t, managedRunTypeComponents.Close())
+
+	err := managedRunTypeComponents.Create()
+	require.NoError(t, err)
+
+	require.NoError(t, managedRunTypeComponents.Close())
+}
+
+func TestManagedRunTypeComponents_CheckSubcomponents(t *testing.T) {
+	t.Parallel()
+
+	managedRunTypeComponents, _ := createComponents()
+	err := managedRunTypeComponents.CheckSubcomponents()
+	require.Equal(t, errNilRunTypeComponents, err)
+
+	err = managedRunTypeComponents.Create()
+	require.NoError(t, err)
+
+	//TODO check for nil each subcomponent - MX-15371
+	err = managedRunTypeComponents.CheckSubcomponents()
+	require.NoError(t, err)
+
+	require.NoError(t, managedRunTypeComponents.Close())
+}

factory/runType/runTypeComponents_test.go

@@ -0,0 +1,38 @@
+package runType
+
+import (
+	"testing"
+
+	"github.com/stretchr/testify/require"
+)
+
+func TestNewRunTypeComponentsFactory(t *testing.T) {
+	t.Parallel()
+
+	t.Run("should work", func(t *testing.T) {
+		rtc := NewRunTypeComponentsFactory()
+		require.NotNil(t, rtc)
+	})
+}
+
+func TestRunTypeComponentsFactory_Create(t *testing.T) {
+	t.Parallel()
+
+	rtcf := NewRunTypeComponentsFactory()
+	require.NotNil(t, rtcf)
+
+	rtc := rtcf.Create()
+	require.NotNil(t, rtc)
+}
+
+func TestRunTypeComponentsFactory_Close(t *testing.T) {
+	t.Parallel()
+
+	rtcf := NewRunTypeComponentsFactory()
+	require.NotNil(t, rtcf)
+
+	rtc := rtcf.Create()
+	require.NotNil(t, rtc)
+
+	require.NoError(t, rtc.Close())
+}