mirror of
https://github.com/ClickHouse/ClickHouse.git
synced 2024-12-12 17:32:32 +00:00
129 lines
2.9 KiB
Go
129 lines
2.9 KiB
Go
package config
|
|
|
|
import (
|
|
"fmt"
|
|
"github.com/ClickHouse/clickhouse-diagnostics/internal/platform/utils"
|
|
"strings"
|
|
)
|
|
|
|
type ConfigParam interface {
|
|
Name() string
|
|
Required() bool
|
|
Description() string
|
|
validate(defaultConfig ConfigParam) error
|
|
}
|
|
|
|
type Configuration struct {
|
|
Params []ConfigParam
|
|
}
|
|
|
|
type Param struct {
|
|
name string
|
|
description string
|
|
required bool
|
|
}
|
|
|
|
func NewParam(name string, description string, required bool) Param {
|
|
return Param{
|
|
name: name,
|
|
description: description,
|
|
required: required,
|
|
}
|
|
}
|
|
|
|
func (bp Param) Name() string {
|
|
return bp.name
|
|
}
|
|
|
|
func (bp Param) Required() bool {
|
|
return bp.required
|
|
}
|
|
|
|
func (bp Param) Description() string {
|
|
return bp.description
|
|
}
|
|
|
|
func (bp Param) validate(defaultConfig ConfigParam) error {
|
|
return nil
|
|
}
|
|
|
|
func (c Configuration) GetConfigParam(paramName string) (ConfigParam, error) {
|
|
for _, param := range c.Params {
|
|
if param.Name() == paramName {
|
|
return param, nil
|
|
}
|
|
}
|
|
return nil, fmt.Errorf("%s does not exist", paramName)
|
|
}
|
|
|
|
// ValidateConfig finds the intersection of a config c and a default config. Requires all possible params to be in default.
|
|
func (c Configuration) ValidateConfig(defaultConfig Configuration) (Configuration, error) {
|
|
var finalParams []ConfigParam
|
|
for _, defaultParam := range defaultConfig.Params {
|
|
setParam, err := c.GetConfigParam(defaultParam.Name())
|
|
if err == nil {
|
|
// check the set value is valid
|
|
if err := setParam.validate(defaultParam); err != nil {
|
|
return Configuration{}, fmt.Errorf("parameter %s is invalid - %s", defaultParam.Name(), err.Error())
|
|
}
|
|
finalParams = append(finalParams, setParam)
|
|
} else if defaultParam.Required() {
|
|
return Configuration{}, fmt.Errorf("missing required parameter %s - %s", defaultParam.Name(), err.Error())
|
|
} else {
|
|
finalParams = append(finalParams, defaultParam)
|
|
}
|
|
}
|
|
return Configuration{
|
|
Params: finalParams,
|
|
}, nil
|
|
}
|
|
|
|
type StringParam struct {
|
|
Param
|
|
Value string
|
|
AllowEmpty bool
|
|
}
|
|
|
|
func (sp StringParam) validate(defaultConfig ConfigParam) error {
|
|
dsp := defaultConfig.(StringParam)
|
|
if !dsp.AllowEmpty && strings.TrimSpace(sp.Value) == "" {
|
|
return fmt.Errorf("%s cannot be empty", sp.Name())
|
|
}
|
|
// if the parameter is not required it doesn't matter
|
|
return nil
|
|
}
|
|
|
|
type StringListParam struct {
|
|
Param
|
|
Values []string
|
|
}
|
|
|
|
type StringOptions struct {
|
|
Param
|
|
Options []string
|
|
Value string
|
|
AllowEmpty bool
|
|
}
|
|
|
|
func (so StringOptions) validate(defaultConfig ConfigParam) error {
|
|
dso := defaultConfig.(StringOptions)
|
|
if !dso.AllowEmpty && strings.TrimSpace(so.Value) == "" {
|
|
return fmt.Errorf("%s cannot be empty", so.Name())
|
|
}
|
|
if !utils.Contains(dso.Options, so.Value) {
|
|
return fmt.Errorf("%s is not a valid value for %s - %v", so.Value, so.Name(), so.Options)
|
|
}
|
|
// if the parameter is not required it doesn't matter
|
|
return nil
|
|
}
|
|
|
|
type IntParam struct {
|
|
Param
|
|
Value int64
|
|
}
|
|
|
|
type BoolParam struct {
|
|
Param
|
|
Value bool
|
|
}
|