refactor config cache

common/loader/json_conf.go

@@ -10,21 +10,21 @@ import (
 )
 
 type JSONConfigLoader struct {
-	*BaseConfigLoader
+	cache     ConfigCreatorCache
 	idKey     string
 	configKey string
 }
 
-func NewJSONConfigLoader(idKey string, configKey string) *JSONConfigLoader {
+func NewJSONConfigLoader(cache ConfigCreatorCache, idKey string, configKey string) *JSONConfigLoader {
 	return &JSONConfigLoader{
 		idKey:     idKey,
 		configKey: configKey,
-		BaseConfigLoader: NewBaseConfigLoader(),
+		cache:     cache,
 	}
 }
 
 func (this *JSONConfigLoader) LoadWithID(raw []byte, id string) (interface{}, error) {
-	config, err := this.CreateConfig(id)
+	config, err := this.cache.CreateConfig(id)
 	if err != nil {
 		return nil, err
 	}

common/loader/json_conf_test.go

@@ -0,0 +1,39 @@
+// +build json
+
+package loader_test
+
+import (
+	"testing"
+
+	. "v2ray.com/core/common/loader"
+	"v2ray.com/core/testing/assert"
+)
+
+type TestConfigA struct {
+	V int
+}
+
+type TestConfigB struct {
+	S string
+}
+
+func TestCreatorCache(t *testing.T) {
+	assert := assert.On(t)
+
+	cache := ConfigCreatorCache{}
+	creator1 := func() interface{} { return &TestConfigA{} }
+	creator2 := func() interface{} { return &TestConfigB{} }
+	cache.RegisterCreator("1", creator1)
+
+	loader := NewJSONConfigLoader(cache, "test", "")
+	rawA, err := loader.LoadWithID([]byte(`{"V": 2}`), "1")
+	assert.Error(err).IsNil()
+	instA := rawA.(*TestConfigA)
+	assert.Int(instA.V).Equals(2)
+
+	cache.RegisterCreator("2", creator2)
+	rawB, err := loader.LoadWithID([]byte(`{"S": "a"}`), "2")
+	assert.Error(err).IsNil()
+	instB := rawB.(*TestConfigB)
+	assert.String(instB.S).Equals("a")
+}

common/loader/loader.go

@@ -11,36 +11,26 @@ var (
 
 type ConfigCreator func() interface{}
 
-type ConfigLoader interface {
-	RegisterCreator(string, ConfigCreator) error
-	CreateConfig(string) (interface{}, error)
-	Load([]byte) (interface{}, string, error)
-	LoadWithID([]byte, string) (interface{}, error)
-}
+type ConfigCreatorCache map[string]ConfigCreator
 
-type BaseConfigLoader struct {
-	creators map[string]ConfigCreator
-}
-
-func NewBaseConfigLoader() *BaseConfigLoader {
-	return &BaseConfigLoader{
-		creators: make(map[string]ConfigCreator),
-	}
-}
-
-func (this *BaseConfigLoader) RegisterCreator(id string, creator ConfigCreator) error {
-	if _, found := this.creators[id]; found {
+func (this ConfigCreatorCache) RegisterCreator(id string, creator ConfigCreator) error {
+	if _, found := this[id]; found {
 		return common.ErrDuplicatedName
 	}
 
-	this.creators[id] = creator
+	this[id] = creator
 	return nil
 }
 
-func (this *BaseConfigLoader) CreateConfig(id string) (interface{}, error) {
-	creator, found := this.creators[id]
+func (this ConfigCreatorCache) CreateConfig(id string) (interface{}, error) {
+	creator, found := this[id]
 	if !found {
 		return nil, ErrUnknownConfigID
 	}
 	return creator(), nil
 }
+
+type ConfigLoader interface {
+	Load([]byte) (interface{}, string, error)
+	LoadWithID([]byte, string) (interface{}, error)
+}

proxy/blackhole/config_json.go

@@ -21,7 +21,7 @@ func (this *Config) UnmarshalJSON(data []byte) error {
 
 	this.Response = new(NoneResponse)
 	if jsonConfig.Response != nil {
-		loader := loader.NewJSONConfigLoader("type", "")
+		loader := loader.NewJSONConfigLoader(loader.ConfigCreatorCache{}, "type", "")
 		loader.RegisterCreator("none", func() interface{} { return new(NoneResponse) })
 		loader.RegisterCreator("http", func() interface{} { return new(HTTPResponse) })
 		response, _, err := loader.Load(jsonConfig.Response)

proxy/registry/config_cache_json.go

@@ -7,6 +7,6 @@ import (
 )
 
 func init() {
-	inboundConfigCache = loader.NewJSONConfigLoader("protocol", "settings")
-	outboundConfigCache = loader.NewJSONConfigLoader("protocol", "settings")
+	inboundConfigCache = loader.NewJSONConfigLoader(loader.ConfigCreatorCache{}, "protocol", "settings")
+	outboundConfigCache = loader.NewJSONConfigLoader(loader.ConfigCreatorCache{}, "protocol", "settings")
 }

transport/internet/authenticator_json.go

@@ -6,11 +6,7 @@ import (
 	"v2ray.com/core/common/loader"
 )
 
-func RegisterAuthenticatorConfig(name string, configCreator loader.ConfigCreator) error {
-	return configCache.RegisterCreator(name, configCreator)
-}
-
-func CreateAuthenticatorConfig(rawConfig []byte) (string, AuthenticatorConfig, error) {
+func CreateAuthenticatorConfig(rawConfig []byte) (string, interface{}, error) {
 	config, name, err := configCache.Load(rawConfig)
 	if err != nil {
 		return name, nil, err
@@ -18,6 +14,6 @@ func CreateAuthenticatorConfig(rawConfig []byte) (string, AuthenticatorConfig, e
 	return name, config, nil
 }
 
-var (
-	configCache = loader.NewJSONConfigLoader("type", "")
-)
+func init() {
+	configCache = loader.NewJSONConfigLoader(loader.ConfigCreatorCache{}, "type", "")
+}