mirrors/maddy
1
0
Fork 0
mirror of https://github.com/foxcpp/maddy.git synced 2025-04-03 21:27:35 +03:00
Code Issues Projects Releases Packages Wiki Activity

Restructure code tree

Browse source 
Root package now contains only initialization code and 'dummy' module.

Each module now got its own package. Module packages are grouped by
their main purpose (storage/, target/, auth/, etc). Shared code is
placed in these "group" packages.

Parser for module references in config is moved into config/module.

Code shared by tests (mock modules, etc) is placed in testutils.
This commit is contained in:
fox.cpp 2019-09-08 15:46:46 +03:00
parent d4d807d6c7
commit 35c3b1c792
No known key found for this signature in database
GPG key ID: E76D97CCEDE90B6C
51 changed files with 961 additions and 2223 deletions
Download patch file Download diff file Expand all files Collapse all files

193
config.go
View file

@ -4,208 +4,15 @@ import (
"errors"
"fmt"
"os"
"reflect"
"strconv"
"github.com/foxcpp/maddy/config"
"github.com/foxcpp/maddy/log"
"github.com/foxcpp/maddy/module"
)
/*
Config matchers for module interfaces.
*/
// createInlineModule is a helper function for config matchers that can create inline modules.
func createInlineModule(modName, instName string, aliases []string) (module.Module, error) {
newMod := module.Get(modName)
if newMod == nil {
return nil, fmt.Errorf("unknown module: %s", modName)
}
log.Debugln("module create", modName, instName, "(inline)")
return newMod(modName, instName, aliases)
}
// initInlineModule constructs "faked" config tree and passes it to module
// Init function to make it look like it is defined at top-level.
//
// args must contain at least one argument, otherwise initInlineModule panics.
func initInlineModule(modObj module.Module, globals map[string]interface{}, block *config.Node) error {
log.Debugln("module init", modObj.Name(), modObj.InstanceName(), "(inline)")
return modObj.Init(config.NewMap(globals, block))
}
// moduleFromNode does all work to create or get existing module object with a certain type.
// It is not used by top-level module definitions, only for references from other
// modules configuration blocks.
//
// inlineCfg should contain configuration directives for inline declarations.
// args should contain values that are used to create module.
// It should be either module name + instance name or just module name. Further extensions
// may add other string arguments (currently, they can be accessed by module instances
// as aliases argument to constructor).
//
// It checks using reflection whether it is possible to store a module object into modObj
// pointer (e.g. it implements all necessary interfaces) and stores it if everything is fine.
// If module object doesn't implement necessary module interfaces - error is returned.
// If modObj is not a pointer, moduleFromNode panics.
func moduleFromNode(args []string, inlineCfg *config.Node, globals map[string]interface{}, moduleIface interface{}) error {
// single argument
// - instance name of an existing module
// single argument + block
// - module name, inline definition
// two+ arguments + block
// - module name and instance name, inline definition
// two+ arguments, no block
// - module name and instance name, inline definition, empty config block
if len(args) == 0 {
return config.NodeErr(inlineCfg, "at least one argument is required")
}
var modObj module.Module
var err error
if inlineCfg.Children != nil || len(args) > 1 {
modName := args[0]
modAliases := args[1:]
instName := ""
if len(args) >= 2 {
modAliases = args[2:]
instName = args[1]
}
modObj, err = createInlineModule(modName, instName, modAliases)
} else {
if len(args) != 1 {
return config.NodeErr(inlineCfg, "exactly one argument is to use existing config block")
}
modObj, err = module.GetInstance(args[0])
}
if err != nil {
return config.NodeErr(inlineCfg, "%v", err)
}
// NOTE: This will panic if moduleIface is not a pointer.
modIfaceType := reflect.TypeOf(moduleIface).Elem()
modObjType := reflect.TypeOf(modObj)
if !modObjType.Implements(modIfaceType) && !modObjType.AssignableTo(modIfaceType) {
return config.NodeErr(inlineCfg, "module %s (%s) doesn't implement %v interface", modObj.Name(), modObj.InstanceName(), modIfaceType)
}
reflect.ValueOf(moduleIface).Elem().Set(reflect.ValueOf(modObj))
if inlineCfg.Children != nil {
if err := initInlineModule(modObj, globals, inlineCfg); err != nil {
return err
}
}
return nil
}
// deliveryDirective is a callback for use in config.Map.Custom.
//
// It does all work necessary to create a module instance from the config
// directive with the following structure:
// directive_name mod_name [inst_name] [{
// inline_mod_config
// }]
//
// Note that if used configuration structure lacks directive_name before mod_name - this function
// should not be used (call deliveryTarget directly).
func deliveryDirective(m *config.Map, node *config.Node) (interface{}, error) {
return deliveryTarget(m.Globals, node.Args, node)
}
func deliveryTarget(globals map[string]interface{}, args []string, block *config.Node) (module.DeliveryTarget, error) {
var target module.DeliveryTarget
if err := moduleFromNode(args, block, globals, &target); err != nil {
return nil, err
}
return target, nil
}
func messageCheck(globals map[string]interface{}, args []string, block *config.Node) (module.Check, error) {
var check module.Check
if err := moduleFromNode(args, block, globals, &check); err != nil {
return nil, err
}
return check, nil
}
func authDirective(m *config.Map, node *config.Node) (interface{}, error) {
var provider module.AuthProvider
if err := moduleFromNode(node.Args, node, m.Globals, &provider); err != nil {
return nil, err
}
return provider, nil
}
func storageDirective(m *config.Map, node *config.Node) (interface{}, error) {
var backend module.Storage
if err := moduleFromNode(node.Args, node, m.Globals, &backend); err != nil {
return nil, err
}
return backend, nil
}
type checkFailAction struct {
quarantine bool
reject bool
scoreAdjust int
}
func checkFailActionDirective(m *config.Map, node *config.Node) (interface{}, error) {
if len(node.Args) == 0 {
return nil, m.MatchErr("expected at least 1 argument")
}
if len(node.Children) != 0 {
return nil, m.MatchErr("can't declare block here")
}
switch node.Args[0] {
case "reject", "quarantine", "ignore":
if len(node.Args) > 1 {
return nil, m.MatchErr("too many arguments")
}
return checkFailAction{
reject: node.Args[0] == "reject",
quarantine: node.Args[0] == "quarantine",
}, nil
case "score":
if len(node.Args) != 2 {
return nil, m.MatchErr("expected 2 arguments")
}
scoreAdj, err := strconv.Atoi(node.Args[1])
if err != nil {
return nil, m.MatchErr("%v", err)
}
return checkFailAction{
scoreAdjust: scoreAdj,
}, nil
default:
return nil, m.MatchErr("invalid action")
}
}
// apply merges the result of check execution with action configuration specified
// in the check configuration.
func (cfa checkFailAction) apply(originalRes module.CheckResult) module.CheckResult {
if originalRes.RejectErr == nil {
return originalRes
}
originalRes.Quarantine = cfa.quarantine
originalRes.ScoreAdjust = int32(cfa.scoreAdjust)
if !cfa.reject {
originalRes.RejectErr = nil
}
return originalRes
}
func logOutput(m *config.Map, node *config.Node) (interface{}, error) {
if len(node.Args) == 0 {
return nil, m.MatchErr("expected at least 1 argument")