run type components implementation

factory/interface.go

@@ -0,0 +1,24 @@
+package factory
+
+// 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 {
+	Create() error
+	Close() error
+	CheckSubcomponents() error
+	String() string
+	IsInterfaceNil() bool
+}

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,7 @@
+package runType
+
+// RunTypeComponentsCreator is the interface for creating run type components
+type RunTypeComponentsCreator interface {
+	Create() *runTypeComponents
+	IsInterfaceNil() bool
+}

factory/runType/runTypeComponents.go

@@ -0,0 +1,13 @@
+package runType
+
+type runTypeComponents struct{}
+
+// 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,18 @@
+package runType
+
+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{}
+}
+
+// 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,83 @@
+package runType
+
+import (
+	"sync"
+
+	"github.com/multiversx/mx-chain-core-go/core/check"
+
+	"github.com/multiversx/mx-chain-es-indexer-go/factory"
+)
+
+const runTypeComponentsName = "managedRunTypeComponents"
+
+var _ factory.ComponentHandler = (*managedRunTypeComponents)(nil)
+var _ factory.RunTypeComponentsHandler = (*managedRunTypeComponents)(nil)
+var _ factory.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
+	}
+	return nil
+}
+
+// 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,76 @@
+package runType
+
+import (
+	"testing"
+
+	"github.com/stretchr/testify/require"
+
+	"github.com/multiversx/mx-chain-es-indexer-go/factory"
+)
+
+func createComponents() (factory.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)
+
+		err = managedRunTypeComponents.Create()
+		require.NoError(t, err)
+
+		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())
+}

factory/runType/sovereignRunTypeComponentsFactory.go

@@ -0,0 +1,18 @@
+package runType
+
+type sovereignRunTypeComponentsFactory struct{}
+
+// NewSovereignRunTypeComponentsFactory will return a new instance of sovereign run type components factory
+func NewSovereignRunTypeComponentsFactory() *sovereignRunTypeComponentsFactory {
+	return &sovereignRunTypeComponentsFactory{}
+}
+
+// Create will create the run type components
+func (srtcf *sovereignRunTypeComponentsFactory) Create() *runTypeComponents {
+	return &runTypeComponents{}
+}
+
+// IsInterfaceNil returns true if there is no value under the interface
+func (srtcf *sovereignRunTypeComponentsFactory) IsInterfaceNil() bool {
+	return srtcf == nil
+}

factory/runType/sovereignRunTypeComponentsFactory_test.go

@@ -0,0 +1,19 @@
+package runType
+
+import (
+	"testing"
+
+	"github.com/stretchr/testify/require"
+)
+
+func TestSovereignRunTypeComponentsFactory_CreateAndClose(t *testing.T) {
+	t.Parallel()
+
+	srtcf := NewSovereignRunTypeComponentsFactory()
+	require.NotNil(t, srtcf)
+
+	srtc := srtcf.Create()
+	require.NotNil(t, srtc)
+
+	require.NoError(t, srtc.Close())
+}