Ehanced parameter metadata to include concepts of required/optional, …

operator/plugin.go

@@ -21,13 +21,6 @@ type PluginConfig struct {
 	Pipeline    []Config
 }
 
-// PluginParameter is a basic description of a plugin's parameter.
-type PluginParameter struct {
-	Label       string
-	Description string
-	Type        string
-}
-
 // PluginRegistry is a registry of plugin templates.
 type PluginRegistry map[string]*template.Template
 
@@ -63,6 +56,19 @@ func (r PluginRegistry) Render(pluginType string, params map[string]interface{})
 		)
 	}
 
+	for name, param := range config.Parameters {
+		if err := param.validate(); err != nil {
+			return PluginConfig{}, errors.NewError(
+				"invalid parameter description found in plugin config",
+				"ensure that all parameter descriptioins are valid for the plugin",
+				"plugin_type", pluginType,
+				"plugin_parameter", name,
+				"rendered_config", writer.String(),
+				"error_message", err.Error(),
+			)
+		}
+	}
+
 	return config, nil
 }
 

operator/plugin_parameter.go

@@ -0,0 +1,147 @@
+package operator
+
+import (
+	"fmt"
+
+	"github.com/observiq/carbon/errors"
+)
+
+// PluginParameter is a basic description of a plugin's parameter.
+type PluginParameter struct {
+	Label       string
+	Description string
+	Required    bool
+	Type        string      // "string", "int", "bool", "strings", or "enum"
+	ValidValues []string    `yaml:"valid_values"` // only useable if Type == "enum"
+	Default     interface{} // Must be valid according to Type & ValidValues
+}
+
+func (param PluginParameter) validate() error {
+	if param.Required && param.Default != nil {
+		return errors.NewError(
+			"required parameter cannot have a default value",
+			"ensure that required parameters do not have default values",
+		)
+	}
+
+	if err := param.validateType(); err != nil {
+		return err
+	}
+
+	if err := param.validateValidValues(); err != nil {
+		return err
+	}
+
+	if err := param.validateDefault(); err != nil {
+		return err
+	}
+
+	return nil
+}
+
+func (param PluginParameter) validateType() error {
+	switch param.Type {
+	case "string", "int", "bool", "strings", "enum": // ok
+	default:
+		return errors.NewError(
+			"invalid type for parameter",
+			"ensure that the type is one of 'string', 'int', 'bool', 'strings', or 'enum'",
+		)
+	}
+	return nil
+}
+
+func (param PluginParameter) validateValidValues() error {
+	switch param.Type {
+	case "string", "int", "bool", "strings":
+		if len(param.ValidValues) > 0 {
+			return errors.NewError(
+				fmt.Sprintf("valid_values is undefined for parameter of type '%s'", param.Type),
+				"remove 'valid_values' field or change type to 'enum'",
+			)
+		}
+	case "enum":
+		if len(param.ValidValues) == 0 {
+			return errors.NewError(
+				"parameter of type 'enum' must have 'valid_values' specified",
+				"specify an array that includes one or more valid values",
+			)
+		}
+	}
+	return nil
+}
+
+func (param PluginParameter) validateDefault() error {
+	if param.Default == nil {
+		return nil
+	}
+
+	// Validate that Default corresponds to Type
+	switch param.Type {
+	case "string":
+		if _, ok := param.Default.(string); !ok {
+			return errors.NewError(
+				"default value for a parameter of type 'string' must be a string",
+				"ensure that the default value is a string",
+			)
+		}
+	case "int":
+		switch param.Default.(type) {
+		case int, int32, int64: // ok
+		default:
+			return errors.NewError(
+				"default value for a parameter of type 'int' must be an integer",
+				"ensure that the default value is an integer",
+			)
+		}
+	case "bool":
+		if _, ok := param.Default.(bool); !ok {
+			return errors.NewError(
+				"default value for a parameter of type 'bool' must be a boolean",
+				"ensure that the default value is a boolean",
+			)
+		}
+	case "strings":
+		defaultList, ok := param.Default.([]interface{})
+		if !ok {
+			return errors.NewError(
+				"default value for a parameter of type 'strings' must be an array of strings",
+				"ensure that the default value is a string",
+			)
+		}
+		for _, s := range defaultList {
+			if _, ok := s.(string); !ok {
+				return errors.NewError(
+					"default value for a parameter of type 'strings' must be an array of strings",
+					"ensure that the default value is an array of strings",
+				)
+			}
+		}
+	case "enum":
+		if param.Default != nil {
+			// Validate that the default value is included in the enumeration
+			def, ok := param.Default.(string)
+			if !ok {
+				return errors.NewError(
+					"invalid default for enumerated parameter",
+					"ensure that the default value is a string",
+				)
+			}
+			for _, val := range param.ValidValues {
+				if val == def {
+					return nil
+				}
+			}
+			return errors.NewError(
+				"invalid default value for enumerated parameter",
+				"ensure default value is listed as a valid value",
+			)
+		}
+	default:
+		return errors.NewError(
+			"invalid type for parameter",
+			"ensure that the type is one of 'string', 'int', 'bool', 'strings', or 'enum'",
+		)
+	}
+	return nil
+}