mirrors/mostlymatter
1
0
Форкнуть 0
Код Задачи Запросы на слияние Действия Пакеты Проекты Релизы Вики Активность

MM-14441: restrict system admin config (#10477)

Просмотр исходного кода 
* tweak utils.Merge docs

* move merge_test to utils_test package for easier testing

* utils: support MergeConfig and StructFieldFilter

* constrain updating certain fields by the restricted system admin
Этот коммит содержится в:
Jesse Hallam
2019-03-21 15:46:38 -04:00
коммит произвёл GitHub
родитель 3d92af2737
Коммит 8c8b1bbc9c
10 изменённых файлов: 316 добавлений и 220 удалений
Скачать Patch файл Скачать Diff файл Показать все файлы Свернуть все файлы

69
utils/merge.go
Просмотреть файл

@@ -8,37 +8,40 @@ import (
"reflect"
)
// Merge will return a new struct/map/slice of the same type as base and patch, with patch merged into base.
// Specifically, patch's values will be preferred except when patch's value is `nil`.
// Note: a referenced value (eg. *bool) will only be `nil` if the pointer is nil. If the value is a zero value,
// then that is considered a legitimate value. Eg, *bool(false) will overwrite *bool(true).
// StructFieldFilter defines a callback function used to decide if a patch value should be applied.
type StructFieldFilter func(structField reflect.StructField, base reflect.Value, patch reflect.Value) bool
// MergeConfig allows for optional merge customizations.
type MergeConfig struct {
StructFieldFilter StructFieldFilter
}
// Merge will return a new value of the same type as base and patch, recursively merging non-nil values from patch on top of base.
//
// Restrictions/guarantees:
// - base and patch will not be modified
// - base and patch can be pointers or values
// - base and patch must be the same type
// - if slices are different, this rule applies:
// - if patch is not nil, overwrite the base slice.
// - otherwise, keep the base slice
// - maps will be merged according to the following rules:
// - if patch is not nil, replace the base map completely
// - otherwise, keep the base map
// - reference values (eg. slice/ptr/map) will be cloned
// - channel values are not supported at the moment
// - base and patch will never be modified
// - values from patch are always selected when non-nil
// - structs are merged recursively
// - maps and slices are treated as pointers, and merged as a single value
//
// Usage: callers need to cast the returned interface back into the original type, eg:
// Note that callers need to cast the returned interface back into the original type:
// func mergeTestStruct(base, patch *testStruct) (*testStruct, error) {
// ret, err := merge(base, patch)
// if err != nil {
// return nil, err
// }
//
// retTS := ret.(testStruct)
// return &retTS, nil
// }
func Merge(base interface{}, patch interface{}) (interface{}, error) {
func Merge(base interface{}, patch interface{}, mergeConfig *MergeConfig) (interface{}, error) {
if reflect.TypeOf(base) != reflect.TypeOf(patch) {
return nil, fmt.Errorf("cannot merge different types. base type: %s, patch type: %s",
reflect.TypeOf(base), reflect.TypeOf(patch))
return nil, fmt.Errorf(
"cannot merge different types. base type: %s, patch type: %s",
reflect.TypeOf(base),
reflect.TypeOf(patch),
)
}
commonType := reflect.TypeOf(base)
@@ -52,7 +55,7 @@ func Merge(base interface{}, patch interface{}) (interface{}, error) {
ret := reflect.New(commonType)
val, ok := merge(baseVal, patchVal)
val, ok := merge(baseVal, patchVal, mergeConfig)
if ok {
ret.Elem().Set(val)
}
@@ -60,7 +63,7 @@ func Merge(base interface{}, patch interface{}) (interface{}, error) {
}
// merge recursively merges patch into base and returns the new struct, ptr, slice/map, or value
func merge(base, patch reflect.Value) (reflect.Value, bool) {
func merge(base, patch reflect.Value, mergeConfig *MergeConfig) (reflect.Value, bool) {
commonType := base.Type()
switch commonType.Kind() {
@@ -70,7 +73,13 @@ func merge(base, patch reflect.Value) (reflect.Value, bool) {
if !merged.Field(i).CanSet() {
continue
}
val, ok := merge(base.Field(i), patch.Field(i))
if mergeConfig != nil && mergeConfig.StructFieldFilter != nil {
if !mergeConfig.StructFieldFilter(commonType.Field(i), base.Field(i), patch.Field(i)) {
merged.Field(i).Set(base.Field(i))
continue
}
}
val, ok := merge(base.Field(i), patch.Field(i), mergeConfig)
if ok {
merged.Field(i).Set(val)
}
@@ -85,13 +94,13 @@ func merge(base, patch reflect.Value) (reflect.Value, bool) {
// clone reference values (if any)
if base.IsNil() {
val, _ := merge(patch.Elem(), patch.Elem())
val, _ := merge(patch.Elem(), patch.Elem(), mergeConfig)
mergedPtr.Elem().Set(val)
} else if patch.IsNil() {
val, _ := merge(base.Elem(), base.Elem())
val, _ := merge(base.Elem(), base.Elem(), mergeConfig)
mergedPtr.Elem().Set(val)
} else {
val, _ := merge(base.Elem(), patch.Elem())
val, _ := merge(base.Elem(), patch.Elem(), mergeConfig)
mergedPtr.Elem().Set(val)
}
return mergedPtr, true
@@ -105,7 +114,7 @@ func merge(base, patch reflect.Value) (reflect.Value, bool) {
merged := reflect.MakeSlice(commonType, 0, patch.Len())
for i := 0; i < patch.Len(); i++ {
// recursively merge patch with itself. This will clone reference values.
val, _ := merge(patch.Index(i), patch.Index(i))
val, _ := merge(patch.Index(i), patch.Index(i), mergeConfig)
merged = reflect.Append(merged, val)
}
return merged, true
@@ -115,7 +124,7 @@ func merge(base, patch reflect.Value) (reflect.Value, bool) {
for i := 0; i < base.Len(); i++ {
// recursively merge base with itself. This will clone reference values.
val, _ := merge(base.Index(i), base.Index(i))
val, _ := merge(base.Index(i), base.Index(i), mergeConfig)
merged = reflect.Append(merged, val)
}
return merged, true
@@ -135,7 +144,7 @@ func merge(base, patch reflect.Value) (reflect.Value, bool) {
}
for _, key := range mapPtr.MapKeys() {
// clone reference values
val, ok := merge(mapPtr.MapIndex(key), mapPtr.MapIndex(key))
val, ok := merge(mapPtr.MapIndex(key), mapPtr.MapIndex(key), mergeConfig)
if !ok {
val = reflect.New(mapPtr.MapIndex(key).Type()).Elem()
}
@@ -151,11 +160,11 @@ func merge(base, patch reflect.Value) (reflect.Value, bool) {
// clone reference values (if any)
if base.IsNil() {
val, _ = merge(patch.Elem(), patch.Elem())
val, _ = merge(patch.Elem(), patch.Elem(), mergeConfig)
} else if patch.IsNil() {
val, _ = merge(base.Elem(), base.Elem())
val, _ = merge(base.Elem(), base.Elem(), mergeConfig)
} else {
val, _ = merge(base.Elem(), patch.Elem())
val, _ = merge(base.Elem(), patch.Elem(), mergeConfig)
}
return val, true

75
utils/merge_test.go
Просмотреть файл

@@ -1,11 +1,14 @@
package utils
package utils_test
import (
"fmt"
"reflect"
"testing"
"github.com/stretchr/testify/assert"
"github.com/stretchr/testify/require"
"github.com/mattermost/mattermost-server/utils"
)
// Test merging maps alone. This isolates the complexity of merging maps from merging maps recursively in
@@ -1156,6 +1159,38 @@ func TestMergeWithVeryComplexStruct(t *testing.T) {
})
}
func TestMergeWithStructFieldFilter(t *testing.T) {
t.Run("filter skips merging from patch", func(t *testing.T) {
t1 := evenSimpler{newBool(true), &evenSimpler2{newString("base")}}
t2 := evenSimpler{newBool(false), &evenSimpler2{newString("patch")}}
expected := evenSimpler{newBool(true), &evenSimpler2{newString("base")}}
merged, err := mergeEvenSimplerWithConfig(t1, t2, &utils.MergeConfig{
StructFieldFilter: func(structField reflect.StructField, base, patch reflect.Value) bool {
return false
},
})
require.NoError(t, err)
assert.Equal(t, expected, *merged)
})
t.Run("filter skips merging configured fields from patch", func(t *testing.T) {
t1 := evenSimpler{newBool(true), &evenSimpler2{newString("base")}}
t2 := evenSimpler{newBool(false), &evenSimpler2{newString("patch")}}
expected := evenSimpler{newBool(false), &evenSimpler2{newString("base")}}
merged, err := mergeEvenSimplerWithConfig(t1, t2, &utils.MergeConfig{
StructFieldFilter: func(structField reflect.StructField, base, patch reflect.Value) bool {
return structField.Name == "B"
},
})
require.NoError(t, err)
assert.Equal(t, expected, *merged)
})
}
type testStruct struct {
I int
I8 int8
@@ -1504,11 +1539,10 @@ func setupStructs(t *testing.T) {
map[int]*string{1: newString("Another"), 2: newString("map of"), 3: newString("pointers, wow!")},
mergeStructEmbedBaseA, &mergeStructEmbedBaseB,
}
}
func mergeSimple(base, patch simple) (*simple, error) {
ret, err := Merge(base, patch)
ret, err := utils.Merge(base, patch, nil)
if err != nil {
return nil, err
}
@@ -1517,7 +1551,16 @@ func mergeSimple(base, patch simple) (*simple, error) {
}
func mergeEvenSimpler(base, patch evenSimpler) (*evenSimpler, error) {
ret, err := Merge(base, patch)
ret, err := utils.Merge(base, patch, nil)
if err != nil {
return nil, err
}
retTS := ret.(evenSimpler)
return &retTS, nil
}
func mergeEvenSimplerWithConfig(base, patch evenSimpler, mergeConfig *utils.MergeConfig) (*evenSimpler, error) {
ret, err := utils.Merge(base, patch, mergeConfig)
if err != nil {
return nil, err
}
@@ -1526,7 +1569,7 @@ func mergeEvenSimpler(base, patch evenSimpler) (*evenSimpler, error) {
}
func mergeSliceStruct(base, patch sliceStruct) (*sliceStruct, error) {
ret, err := Merge(base, patch)
ret, err := utils.Merge(base, patch, nil)
if err != nil {
return nil, err
}
@@ -1535,7 +1578,7 @@ func mergeSliceStruct(base, patch sliceStruct) (*sliceStruct, error) {
}
func mergeMapPtr(base, patch mapPtr) (*mapPtr, error) {
ret, err := Merge(base, patch)
ret, err := utils.Merge(base, patch, nil)
if err != nil {
return nil, err
}
@@ -1544,7 +1587,7 @@ func mergeMapPtr(base, patch mapPtr) (*mapPtr, error) {
}
func mergeMapPtrState(base, patch mapPtrState) (*mapPtrState, error) {
ret, err := Merge(base, patch)
ret, err := utils.Merge(base, patch, nil)
if err != nil {
return nil, err
}
@@ -1553,7 +1596,7 @@ func mergeMapPtrState(base, patch mapPtrState) (*mapPtrState, error) {
}
func mergeMapPtrState2(base, patch mapPtrState2) (*mapPtrState2, error) {
ret, err := Merge(base, patch)
ret, err := utils.Merge(base, patch, nil)
if err != nil {
return nil, err
}
@@ -1562,7 +1605,7 @@ func mergeMapPtrState2(base, patch mapPtrState2) (*mapPtrState2, error) {
}
func mergeTestStructs(base, patch testStruct) (*testStruct, error) {
ret, err := Merge(base, patch)
ret, err := utils.Merge(base, patch, nil)
if err != nil {
return nil, err
}
@@ -1571,7 +1614,7 @@ func mergeTestStructs(base, patch testStruct) (*testStruct, error) {
}
func mergeStringIntMap(base, patch map[string]int) (map[string]int, error) {
ret, err := Merge(base, patch)
ret, err := utils.Merge(base, patch, nil)
if err != nil {
return nil, err
}
@@ -1580,7 +1623,7 @@ func mergeStringIntMap(base, patch map[string]int) (map[string]int, error) {
}
func mergeStringPtrIntMap(base, patch map[string]*int) (map[string]*int, error) {
ret, err := Merge(base, patch)
ret, err := utils.Merge(base, patch, nil)
if err != nil {
return nil, err
}
@@ -1589,7 +1632,7 @@ func mergeStringPtrIntMap(base, patch map[string]*int) (map[string]*int, error)
}
func mergeStringSliceIntMap(base, patch map[string][]int) (map[string][]int, error) {
ret, err := Merge(base, patch)
ret, err := utils.Merge(base, patch, nil)
if err != nil {
return nil, err
}
@@ -1598,7 +1641,7 @@ func mergeStringSliceIntMap(base, patch map[string][]int) (map[string][]int, err
}
func mergeMapOfMap(base, patch map[string]map[string]*int) (map[string]map[string]*int, error) {
ret, err := Merge(base, patch)
ret, err := utils.Merge(base, patch, nil)
if err != nil {
return nil, err
}
@@ -1607,7 +1650,7 @@ func mergeMapOfMap(base, patch map[string]map[string]*int) (map[string]map[strin
}
func mergeInterfaceMap(base, patch map[string]interface{}) (map[string]interface{}, error) {
ret, err := Merge(base, patch)
ret, err := utils.Merge(base, patch, nil)
if err != nil {
return nil, err
}
@@ -1616,7 +1659,7 @@ func mergeInterfaceMap(base, patch map[string]interface{}) (map[string]interface
}
func mergeStringSlices(base, patch []string) ([]string, error) {
ret, err := Merge(base, patch)
ret, err := utils.Merge(base, patch, nil)
if err != nil {
return nil, err
}
@@ -1625,7 +1668,7 @@ func mergeStringSlices(base, patch []string) ([]string, error) {
}
func mergeTestStructsPtrs(base, patch *testStruct) (*testStruct, error) {
ret, err := Merge(base, patch)
ret, err := utils.Merge(base, patch, nil)
if err != nil {
return nil, err
}