109 lines
3.4 KiB
Go
109 lines
3.4 KiB
Go
package libnetwork
|
|
|
|
import (
|
|
"fmt"
|
|
"reflect"
|
|
|
|
"github.com/docker/libnetwork/pkg/options"
|
|
)
|
|
|
|
// DriverParams are a generic structure to hold driver specific settings.
|
|
type DriverParams options.Generic
|
|
|
|
var drivers = map[string]struct {
|
|
creatorFn interface{}
|
|
creatorArg interface{}
|
|
}{}
|
|
|
|
// RegisterNetworkType associates a textual identifier with a way to create a
|
|
// new network. It is called by the various network implementations, and used
|
|
// upon invokation of the libnetwork.NetNetwork function.
|
|
//
|
|
// creatorFn must be of type func (creatorArgType) (Network, error), where
|
|
// createArgType is the type of the creatorArg argument.
|
|
//
|
|
// For example:
|
|
//
|
|
// func CreateTestNetwork(name string, config *TestNetworkConfig()) (Network, error) {
|
|
// }
|
|
//
|
|
// func init() {
|
|
// RegisterNetworkType("test", CreateTestNetwork, &TestNetworkConfig{})
|
|
// }
|
|
//
|
|
func RegisterNetworkType(name string, creatorFn interface{}, creatorArg interface{}) error {
|
|
// Validate the creator function signature.
|
|
ctorArg := []reflect.Type{reflect.TypeOf((*string)(nil)), reflect.TypeOf(creatorArg)}
|
|
ctorRet := []reflect.Type{reflect.TypeOf((*Network)(nil)).Elem(), reflect.TypeOf((*error)(nil)).Elem()}
|
|
if err := validateFunctionSignature(creatorFn, ctorArg, ctorRet); err != nil {
|
|
sig := fmt.Sprintf("func (%s) (Network, error)", ctorArg[0].Name())
|
|
return fmt.Errorf("invalid signature for %q creator function (expected %s)", name, sig)
|
|
}
|
|
|
|
// Store the new driver information to invoke at creation time.
|
|
if _, ok := drivers[name]; ok {
|
|
return fmt.Errorf("a driver for network type %q is already registed", name)
|
|
}
|
|
drivers[name] = struct {
|
|
creatorFn interface{}
|
|
creatorArg interface{}
|
|
}{creatorFn, creatorArg}
|
|
return nil
|
|
}
|
|
|
|
func createNetwork(networkType, name string, generic DriverParams) (Network, error) {
|
|
d, ok := drivers[networkType]
|
|
if !ok {
|
|
return nil, fmt.Errorf("unknown driver %q", networkType)
|
|
}
|
|
|
|
config, err := options.GenerateFromModel(options.Generic(generic), d.creatorArg)
|
|
if err != nil {
|
|
return nil, fmt.Errorf("failed to generate driver config: %v", err)
|
|
}
|
|
|
|
arg := []reflect.Value{reflect.ValueOf(name), reflect.ValueOf(config)}
|
|
res := reflect.ValueOf(d.creatorFn).Call(arg)
|
|
return makeCreateResult(res)
|
|
}
|
|
|
|
func makeCreateResult(res []reflect.Value) (net Network, err error) {
|
|
if !res[0].IsNil() {
|
|
net = res[0].Interface().(Network)
|
|
}
|
|
if !res[1].IsNil() {
|
|
err = res[1].Interface().(error)
|
|
}
|
|
return
|
|
}
|
|
|
|
func validateFunctionSignature(fn interface{}, params []reflect.Type, returns []reflect.Type) error {
|
|
// Valid that argument is a function.
|
|
fnType := reflect.TypeOf(fn)
|
|
if fnType.Kind() != reflect.Func {
|
|
return fmt.Errorf("argument is %s, not function", fnType.Name())
|
|
}
|
|
|
|
// Vaidate arguments numbers and types.
|
|
if fnType.NumIn() != len(params) {
|
|
return fmt.Errorf("expected function with %d arguments, got %d", len(params), fnType.NumIn())
|
|
}
|
|
for i, argType := range params {
|
|
if argType != fnType.In(i) {
|
|
return fmt.Errorf("argument %d type should be %s, got %s", i, argType.Name(), fnType.In(i).Name())
|
|
}
|
|
}
|
|
|
|
// Validate return values numbers and types.
|
|
if fnType.NumOut() != len(returns) {
|
|
return fmt.Errorf("expected function with %d return values, got %d", len(params), fnType.NumIn())
|
|
}
|
|
for i, retType := range returns {
|
|
if retType != fnType.Out(i) {
|
|
return fmt.Errorf("return value %d type should be %s, got %s", i, retType.Name(), fnType.Out(i).Name())
|
|
}
|
|
}
|
|
|
|
return nil
|
|
}
|