Added viper tarantool 3 configuration provider

providers/static/provider.go

@@ -4,8 +4,6 @@ import (
 	"context"
 	"fmt"
 
-	"github.com/google/uuid"
-
 	vshardrouter "github.com/tarantool/go-vshard-router"
 )
 
@@ -34,11 +32,6 @@ func (p *Provider) Validate() error {
 		if rs.Name == "" {
 			return fmt.Errorf("one of replicaset name is empty")
 		}
-
-		// check replicaset uuid
-		if rs.UUID == uuid.Nil {
-			return fmt.Errorf("one of replicaset uuid is empty")
-		}
 	}
 
 	return nil

providers/viper/moonlibs/config.go

@@ -0,0 +1,25 @@
+package moonlibs
+
+// ----- Moonlibs configuration -----
+
+// Config is a representation of the topology configuration for tarantool version below 3.
+type Config struct {
+	Topology SourceTopologyConfig `json:"topology"`
+}
+
+type SourceTopologyConfig struct {
+	Clusters  map[string]ClusterInfo  `json:"clusters,omitempty" yaml:"clusters" `
+	Instances map[string]InstanceInfo `json:"instances,omitempty" yaml:"instances"`
+}
+
+type ClusterInfo struct {
+	ReplicasetUUID string `yaml:"replicaset_uuid" mapstructure:"replicaset_uuid"`
+}
+
+type InstanceInfo struct {
+	Cluster string
+	Box     struct {
+		Listen       string `json:"listen,omitempty" yaml:"listen" mapstructure:"listen"`
+		InstanceUUID string `yaml:"instance_uuid" mapstructure:"instance_uuid" json:"instanceUUID,omitempty"`
+	}
+}

providers/viper/moonlibs/convert.go

@@ -0,0 +1,55 @@
+package moonlibs
+
+import (
+	"log"
+
+	"github.com/google/uuid"
+	vshardrouter "github.com/tarantool/go-vshard-router"
+)
+
+func (cfg *Config) Convert() map[vshardrouter.ReplicasetInfo][]vshardrouter.InstanceInfo {
+	if cfg.Topology.Instances == nil {
+		panic("instances is nil")
+	}
+
+	if cfg.Topology.Clusters == nil {
+		panic("clusters is nil")
+	}
+
+	// готовим конфиг для vshard-router`а
+	vshardRouterTopology := make(map[vshardrouter.ReplicasetInfo][]vshardrouter.InstanceInfo)
+
+	for rsName, rs := range cfg.Topology.Clusters {
+		rsUUID, err := uuid.Parse(rs.ReplicasetUUID)
+		if err != nil {
+			panic("Can't parse replicaset uuid: %s")
+		}
+
+		rsInstances := make([]vshardrouter.InstanceInfo, 0)
+
+		for _, instInfo := range cfg.Topology.Instances {
+			if instInfo.Cluster != rsName {
+				continue
+			}
+
+			instUUID, err := uuid.Parse(instInfo.Box.InstanceUUID)
+			if err != nil {
+				log.Printf("Can't parse replicaset uuid: %s", err)
+
+				panic(err)
+			}
+
+			rsInstances = append(rsInstances, vshardrouter.InstanceInfo{
+				Addr: instInfo.Box.Listen,
+				UUID: instUUID,
+			})
+		}
+
+		vshardRouterTopology[vshardrouter.ReplicasetInfo{
+			Name: rsName,
+			UUID: rsUUID,
+		}] = rsInstances
+	}
+
+	return vshardRouterTopology
+}

providers/viper/provider.go

@@ -3,87 +3,70 @@ package viper
 import (
 	"context"
 	"fmt"
-	"log"
-	"os"
 
 	"github.com/google/uuid"
 	srcviper "github.com/spf13/viper"
-
 	vshardrouter "github.com/tarantool/go-vshard-router"
+	"github.com/tarantool/go-vshard-router/providers/viper/moonlibs"
+	"github.com/tarantool/go-vshard-router/providers/viper/tarantool3"
 )
 
 // Check that provider implements TopologyProvider interface
 var _ vshardrouter.TopologyProvider = (*Provider)(nil)
 
 type Provider struct {
+	ctx context.Context
+
 	v  *srcviper.Viper
 	rs map[vshardrouter.ReplicasetInfo][]vshardrouter.InstanceInfo
 }
 
-func NewProvider(v *srcviper.Viper) *Provider {
+type ConfigType int
+
+const (
+	ConfigTypeMoonlibs ConfigType = iota
+	ConfigTypeTarantool3
+)
+
+type Convertable interface {
+	Convert() map[vshardrouter.ReplicasetInfo][]vshardrouter.InstanceInfo
+}
+
+func NewProvider(ctx context.Context, v *srcviper.Viper, cfgType ConfigType) *Provider {
 	if v == nil {
 		panic("viper entity is nil")
 	}
 
-	cfg := &TopologyConfig{}
-	err := v.Unmarshal(cfg)
-	if err != nil {
-		panic(err)
-	}
+	var cfg Convertable
 
-	if cfg.Topology.Instances == nil {
-		panic("instances is nil")
+	switch cfgType {
+	case ConfigTypeMoonlibs:
+		cfg = &moonlibs.Config{}
+	case ConfigTypeTarantool3:
+		cfg = &tarantool3.Config{}
+	default:
+		panic("unknown config type")
 	}
 
-	if cfg.Topology.Clusters == nil {
-		panic("clusters is nil")
+	err := v.Unmarshal(cfg)
+	if err != nil {
+		panic(err)
 	}
 
-	// готовим конфиг для vshard-router`а
-	vshardRouterTopology := make(map[vshardrouter.ReplicasetInfo][]vshardrouter.InstanceInfo)
-
-	for rsName, rs := range cfg.Topology.Clusters {
-		rsUUID, err := uuid.Parse(rs.ReplicasetUUID)
-		if err != nil {
-			log.Printf("Can't parse replicaset uuid: %s", err)
-
-			os.Exit(2)
-		}
-
-		rsInstances := make([]vshardrouter.InstanceInfo, 0)
+	resultMap := cfg.Convert()
 
-		for _, instInfo := range cfg.Topology.Instances {
-			if instInfo.Cluster != rsName {
-				continue
-			}
-
-			instUUID, err := uuid.Parse(instInfo.Box.InstanceUUID)
-			if err != nil {
-				log.Printf("Can't parse replicaset uuid: %s", err)
-
-				panic(err)
-			}
-
-			rsInstances = append(rsInstances, vshardrouter.InstanceInfo{
-				Addr: instInfo.Box.Listen,
-				UUID: instUUID,
-			})
-		}
-
-		vshardRouterTopology[vshardrouter.ReplicasetInfo{
-			Name: rsName,
-			UUID: rsUUID,
-		}] = rsInstances
-	}
-
-	return &Provider{v: v, rs: vshardRouterTopology}
+	return &Provider{ctx: ctx, v: v, rs: resultMap}
 }
 
 func (p *Provider) WatchChanges() *Provider {
 	// todo
 	return p
 }
 
+func (p *Provider) Topology() map[vshardrouter.ReplicasetInfo][]vshardrouter.InstanceInfo {
+	return p.rs
+}
+
 func (p *Provider) Validate() error {
 	if len(p.rs) < 1 {
 		return fmt.Errorf("replicasets are empty")
@@ -109,24 +92,3 @@ func (p *Provider) Init(c vshardrouter.TopologyController) error {
 }
 
 func (p *Provider) Close() {}
-
-type ClusterInfo struct {
-	ReplicasetUUID string `yaml:"replicaset_uuid" mapstructure:"replicaset_uuid"`
-}
-
-type InstanceInfo struct {
-	Cluster string
-	Box     struct {
-		Listen       string `json:"listen,omitempty" yaml:"listen" mapstructure:"listen"`
-		InstanceUUID string `yaml:"instance_uuid" mapstructure:"instance_uuid" json:"instanceUUID,omitempty"`
-	}
-}
-
-type TopologyConfig struct {
-	Topology SourceTopologyConfig `json:"topology"`
-}
-
-type SourceTopologyConfig struct {
-	Clusters  map[string]ClusterInfo  `json:"clusters,omitempty" yaml:"clusters" `
-	Instances map[string]InstanceInfo `json:"instances,omitempty" yaml:"instances"`
-}

providers/viper/provider_test.go

@@ -1,6 +1,7 @@
 package viper_test
 
 import (
+	"context"
 	"testing"
 
 	"github.com/spf13/viper"
@@ -15,29 +16,31 @@ func TestProvider_Close(t *testing.T) {
 
 func TestNewProviderNilPanic(t *testing.T) {
 	require.Panics(t, func() {
-		vprovider.NewProvider(nil)
+		vprovider.NewProvider(context.TODO(), nil, vprovider.ConfigTypeMoonlibs)
 	})
 }
 
 func TestNewProviderDirect(t *testing.T) {
+	ctx := context.TODO()
 	v := viper.New()
 
-	v.AddConfigPath("test/")
+	v.AddConfigPath("testdata/")
 	v.SetConfigName("config-direct")
 	v.SetConfigType("yaml")
 
 	err := v.ReadInConfig()
 	require.NoError(t, err)
 
-	provider := vprovider.NewProvider(v)
+	provider := vprovider.NewProvider(ctx, v, vprovider.ConfigTypeMoonlibs)
 
-	require.NotNil(t, provider)
+	anyProviderValidation(t, provider)
 }
 
 func TestNewProviderSub(t *testing.T) {
+	ctx := context.TODO()
 	v := viper.New()
 
-	v.AddConfigPath("test/")
+	v.AddConfigPath("testdata/")
 	v.SetConfigName("config-sub")
 	v.SetConfigType("yaml")
 
@@ -46,7 +49,39 @@ func TestNewProviderSub(t *testing.T) {
 
 	v = v.Sub("supbpath")
 
-	provider := vprovider.NewProvider(v)
+	provider := vprovider.NewProvider(ctx, v, vprovider.ConfigTypeMoonlibs)
+
+	anyProviderValidation(t, provider)
+}
+
+func TestNewProviderTarantool3(t *testing.T) {
+	ctx := context.TODO()
+	v := viper.New()
+
+	v.AddConfigPath("testdata/")
+	v.SetConfigName("config-tarantool3")
+	v.SetConfigType("yaml")
 
+	err := v.ReadInConfig()
+	require.NoError(t, err)
+
+	provider := vprovider.NewProvider(ctx, v, vprovider.ConfigTypeTarantool3)
+
+	anyProviderValidation(t, provider)
+}
+
+func anyProviderValidation(t testing.TB, provider *vprovider.Provider) {
+	// not empty
 	require.NotNil(t, provider)
+
+	topology := provider.Topology()
+	// topology not empty
+	require.NotNil(t, topology)
+	// topology more than 0
+	require.True(t, len(topology) > 0)
+
+	// there are no empty replicates
+	for _, instances := range topology {
+		require.NotEmpty(t, instances)
+	}
 }

providers/viper/tarantool3/config.go

@@ -0,0 +1,57 @@
+package tarantool3
+
+// ----- Tarantool 3 configuration -----
+
+// Config - configuration for all groups
+type Config struct {
+	Groups Group `yaml:"groups"`
+}
+
+// Group is a structure for each group configuration
+type Group struct {
+	Storages *Storages `yaml:"storages,omitempty"`
+}
+
+// Storages configuration
+type Storages struct {
+	App         App                   `yaml:"app"`
+	Sharding    Sharding              `yaml:"sharding"`
+	Replication Replication           `yaml:"replication"`
+	Replicasets map[string]Replicaset `yaml:"replicasets"`
+}
+
+// App - general information about the module
+type App struct {
+	Module string `yaml:"module"`
+}
+
+// Sharding configuration
+type Sharding struct {
+	Roles []string `yaml:"roles"`
+}
+
+// Replication configuration
+type Replication struct {
+	Failover string `yaml:"failover"`
+}
+
+// Replicaset configuration
+type Replicaset struct {
+	Leader    string              `yaml:"leader"`
+	Instances map[string]Instance `yaml:"instances"`
+}
+
+// Instance in the Replicaset
+type Instance struct {
+	IProto IProto `yaml:"iproto"`
+}
+
+// IProto configuration
+type IProto struct {
+	Listen []Listen `yaml:"listen"`
+}
+
+// Listen configuration (URI for connection)
+type Listen struct {
+	URI string `yaml:"uri"`
+}