Mono repo -> Master (#22553)

Combines the following repositories into one:

https://github.com/mattermost/mattermost-server
https://github.com/mattermost/mattermost-webapp
https://github.com/mattermost/focalboard
https://github.com/mattermost/mattermost-plugin-playbooks

server/channels/app/featureflag/feature_flags_sync.go

@@ -0,0 +1,111 @@
+// Copyright (c) 2015-present Mattermost, Inc. All Rights Reserved.
+// See LICENSE.txt for license information.
+
+package featureflag
+
+import (
+	"math"
+	"reflect"
+	"strconv"
+	"strings"
+
+	"github.com/pkg/errors"
+	"github.com/splitio/go-client/v6/splitio/client"
+	"github.com/splitio/go-client/v6/splitio/conf"
+
+	"github.com/mattermost/mattermost-server/v6/model"
+	"github.com/mattermost/mattermost-server/v6/server/platform/shared/mlog"
+)
+
+type SyncParams struct {
+	ServerID            string
+	SplitKey            string
+	SyncIntervalSeconds int
+	Log                 *mlog.Logger
+	Attributes          map[string]any
+}
+
+type Synchronizer struct {
+	SyncParams
+
+	client  *client.SplitClient
+	stop    chan struct{}
+	stopped chan struct{}
+}
+
+var featureNames = getStructFields(model.FeatureFlags{})
+
+func NewSynchronizer(params SyncParams) (*Synchronizer, error) {
+	cfg := conf.Default()
+	if params.Log != nil {
+		cfg.Logger = &splitLogger{wrappedLog: params.Log.With(mlog.String("service", "split"))}
+	} else {
+		cfg.LoggerConfig.LogLevel = math.MinInt32
+	}
+	factory, err := client.NewSplitFactory(params.SplitKey, cfg)
+	if err != nil {
+		return nil, errors.Wrap(err, "unable to create split factory")
+	}
+
+	return &Synchronizer{
+		SyncParams: params,
+		client:     factory.Client(),
+		stop:       make(chan struct{}),
+		stopped:    make(chan struct{}),
+	}, nil
+}
+
+// EnsureReady blocks until the synchronizer is ready to update feature flag values
+func (f *Synchronizer) EnsureReady() error {
+	if err := f.client.BlockUntilReady(10); err != nil {
+		return errors.Wrap(err, "split.io client could not initialize")
+	}
+
+	return nil
+}
+
+func (f *Synchronizer) UpdateFeatureFlagValues(base model.FeatureFlags) model.FeatureFlags {
+	featuresMap := f.client.Treatments(f.ServerID, featureNames, f.Attributes)
+	ffm := featureFlagsFromMap(featuresMap, base)
+	return ffm
+}
+
+func (f *Synchronizer) Close() {
+	f.client.Destroy()
+}
+
+// featureFlagsFromMap sets the feature flags from a map[string]string.
+// It starts with baseFeatureFlags and only sets values that are
+// given by the upstream management system.
+// Makes the assumption that all feature flags are strings or booleans.
+// Strings are converted to booleans by considering case insensitive "on" or any value considered by strconv.ParseBool as true and any other value as false.
+func featureFlagsFromMap(featuresMap map[string]string, baseFeatureFlags model.FeatureFlags) model.FeatureFlags {
+	refStruct := reflect.ValueOf(&baseFeatureFlags).Elem()
+	for fieldName, fieldValue := range featuresMap {
+		refField := refStruct.FieldByName(fieldName)
+		// "control" is returned by split.io if the treatment is not found, in this case we should use the default value.
+		if !refField.IsValid() || !refField.CanSet() || fieldValue == "control" {
+			continue
+		}
+
+		switch refField.Type().Kind() {
+		case reflect.Bool:
+			parsedBoolValue, _ := strconv.ParseBool(fieldValue)
+			refField.Set(reflect.ValueOf(strings.ToLower(fieldValue) == "on" || parsedBoolValue))
+		default:
+			refField.Set(reflect.ValueOf(fieldValue))
+		}
+
+	}
+	return baseFeatureFlags
+}
+
+func getStructFields(s any) []string {
+	structType := reflect.TypeOf(s)
+	fieldNames := make([]string, 0, structType.NumField())
+	for i := 0; i < structType.NumField(); i++ {
+		fieldNames = append(fieldNames, structType.Field(i).Name)
+	}
+
+	return fieldNames
+}

server/channels/app/featureflag/feature_flags_sync_test.go

@@ -0,0 +1,111 @@
+// Copyright (c) 2015-present Mattermost, Inc. All Rights Reserved.
+// See LICENSE.txt for license information.
+
+package featureflag
+
+import (
+	"testing"
+
+	"github.com/stretchr/testify/require"
+
+	"github.com/mattermost/mattermost-server/v6/model"
+)
+
+func TestGetStructFields(t *testing.T) {
+	type testStruct struct {
+		FieldOne       string
+		SecondField    bool
+		SomeOtherField int
+	}
+
+	fields := getStructFields(testStruct{})
+	require.Equal(t,
+		[]string{
+			"FieldOne",
+			"SecondField",
+			"SomeOtherField",
+		},
+		fields,
+	)
+
+	featureFlagsFields := getStructFields(model.FeatureFlags{})
+	require.Contains(t, featureFlagsFields, "TestFeature")
+}
+
+func TestFeatureFlagsFromMap(t *testing.T) {
+	for name, tc := range map[string]struct {
+		FeatureMap        map[string]string
+		Base              model.FeatureFlags
+		ExpectedTestValue string
+	}{
+		"empty": {
+			FeatureMap:        map[string]string{},
+			Base:              model.FeatureFlags{},
+			ExpectedTestValue: "",
+		},
+		"no base value": {
+			FeatureMap:        map[string]string{"TestFeature": "expectedvalue"},
+			Base:              model.FeatureFlags{},
+			ExpectedTestValue: "expectedvalue",
+		},
+		"only base value": {
+			FeatureMap:        map[string]string{},
+			Base:              model.FeatureFlags{TestFeature: "somebasevalue"},
+			ExpectedTestValue: "somebasevalue",
+		},
+		"override base value": {
+			FeatureMap:        map[string]string{"TestFeature": "overridevalue"},
+			Base:              model.FeatureFlags{TestFeature: "somebasevalue"},
+			ExpectedTestValue: "overridevalue",
+		},
+		"override base value with extras": {
+			FeatureMap:        map[string]string{"TestFeature": "overridevalue", "SomeOldFlag": "oldvalue"},
+			Base:              model.FeatureFlags{TestFeature: "somebasevalue"},
+			ExpectedTestValue: "overridevalue",
+		},
+		"all values do not exist": {
+			FeatureMap:        map[string]string{"SomeOldFlag": "oldvalue"},
+			Base:              model.FeatureFlags{},
+			ExpectedTestValue: "",
+		},
+		"bool on": {
+			FeatureMap:        map[string]string{"TestBoolFeature": "on"},
+			Base:              model.FeatureFlags{TestBoolFeature: true},
+			ExpectedTestValue: "",
+		},
+		"bool true": {
+			FeatureMap:        map[string]string{"TestBoolFeature": "true"},
+			Base:              model.FeatureFlags{TestBoolFeature: true},
+			ExpectedTestValue: "",
+		},
+		"bool True": {
+			FeatureMap:        map[string]string{"TestBoolFeature": "True"},
+			Base:              model.FeatureFlags{TestBoolFeature: true},
+			ExpectedTestValue: "",
+		},
+		"bool 1": {
+			FeatureMap:        map[string]string{"TestBoolFeature": "1"},
+			Base:              model.FeatureFlags{TestBoolFeature: true},
+			ExpectedTestValue: "",
+		},
+		"bool off": {
+			FeatureMap:        map[string]string{"TestBoolFeature": "off"},
+			Base:              model.FeatureFlags{},
+			ExpectedTestValue: "",
+		},
+		"bool false": {
+			FeatureMap:        map[string]string{"TestBoolFeature": "false"},
+			Base:              model.FeatureFlags{},
+			ExpectedTestValue: "",
+		},
+		"bool other value": {
+			FeatureMap:        map[string]string{"TestBoolFeature": "someotherbadvalue"},
+			Base:              model.FeatureFlags{},
+			ExpectedTestValue: "",
+		},
+	} {
+		t.Run(name, func(t *testing.T) {
+			require.Equal(t, tc.ExpectedTestValue, featureFlagsFromMap(tc.FeatureMap, tc.Base).TestFeature)
+		})
+	}
+}

server/channels/app/featureflag/split_logger.go

@@ -0,0 +1,35 @@
+// Copyright (c) 2015-present Mattermost, Inc. All Rights Reserved.
+// See LICENSE.txt for license information.
+
+package featureflag
+
+import (
+	"fmt"
+
+	"github.com/mattermost/mattermost-server/v6/server/platform/shared/mlog"
+)
+
+type splitLogger struct {
+	wrappedLog *mlog.Logger
+}
+
+func (s *splitLogger) Error(msg ...any) {
+	s.wrappedLog.Error(fmt.Sprint(msg...))
+}
+
+func (s *splitLogger) Warning(msg ...any) {
+	s.wrappedLog.Warn(fmt.Sprint(msg...))
+}
+
+// Ignoring more verbose messages from split
+func (s *splitLogger) Info(msg ...any) {
+	//s.wrappedLog.Info(fmt.Sprint(msg...))
+}
+
+func (s *splitLogger) Debug(msg ...any) {
+	//s.wrappedLog.Debug(fmt.Sprint(msg...))
+}
+
+func (s *splitLogger) Verbose(msg ...any) {
+	//s.wrappedLog.Info(fmt.Sprint(msg...))
+}