remove use of any

common/loader/json_conf.go

@@ -9,13 +9,15 @@ import (
 	"v2ray.com/core/common/log"
 )
 
+type NamedTypeMap map[string]string
+
 type JSONConfigLoader struct {
-	cache     ConfigCreatorCache
+	cache     NamedTypeMap
 	idKey     string
 	configKey string
 }
 
-func NewJSONConfigLoader(cache ConfigCreatorCache, idKey string, configKey string) *JSONConfigLoader {
+func NewJSONConfigLoader(cache NamedTypeMap, idKey string, configKey string) *JSONConfigLoader {
 	return &JSONConfigLoader{
 		idKey:     idKey,
 		configKey: configKey,
@@ -24,7 +26,7 @@ func NewJSONConfigLoader(cache ConfigCreatorCache, idKey string, configKey strin
 }
 
 func (this *JSONConfigLoader) LoadWithID(raw []byte, id string) (interface{}, error) {
-	config, err := this.cache.CreateConfig(id)
+	config, err := GetInstance(this.cache[id])
 	if err != nil {
 		return nil, err
 	}

common/loader/type.go

@@ -0,0 +1,50 @@
+package loader
+
+import (
+	"errors"
+	"reflect"
+
+	"github.com/golang/protobuf/proto"
+)
+
+func NewTypedSettings(message proto.Message) *TypedSettings {
+	if message == nil {
+		return nil
+	}
+	settings, _ := proto.Marshal(message)
+	return &TypedSettings{
+		Type:     GetType(message),
+		Settings: settings,
+	}
+}
+
+func GetType(message proto.Message) string {
+	return proto.MessageName(message)
+}
+
+func GetInstance(messageType string) (interface{}, error) {
+	mType := proto.MessageType(messageType)
+	if mType == nil {
+		return nil, errors.New("Unknown type: " + messageType)
+	}
+	return reflect.New(mType).Interface(), nil
+}
+
+func (this *TypedSettings) Load(message proto.Message) error {
+	targetType := GetType(message)
+	if targetType != this.Type {
+		return errors.New("Have type " + this.Type + ", but retrieved for " + targetType)
+	}
+	return proto.Unmarshal(this.Settings, message)
+}
+
+func (this *TypedSettings) GetInstance() (interface{}, error) {
+	instance, err := GetInstance(this.Type)
+	if err != nil {
+		return nil, err
+	}
+	if err := proto.Unmarshal(this.Settings, instance.(proto.Message)); err != nil {
+		return nil, err
+	}
+	return instance, nil
+}

common/loader/type.proto

@@ -0,0 +1,11 @@
+syntax = "proto3";
+
+package v2ray.core.common.loader;
+option go_package = "loader";
+option java_package = "com.v2ray.core.common.loader";
+option java_outer_classname = "TypeProto";
+
+message TypedSettings {
+  string type = 1;
+  bytes settings = 2;
+}

common/protocol/server_spec.go

@@ -73,12 +73,12 @@ func (this *ServerSpec) HasUser(user *User) bool {
 	this.RLock()
 	defer this.RUnlock()
 
-	accountA, err := user.GetTypedAccount(this.newAccount())
+	accountA, err := user.GetTypedAccount()
 	if err != nil {
 		return false
 	}
 	for _, u := range this.users {
-		accountB, err := u.GetTypedAccount(this.newAccount())
+		accountB, err := u.GetTypedAccount()
 		if err == nil && accountA.Equals(accountB) {
 			return true
 		}

common/protocol/user.go

@@ -2,31 +2,31 @@ package protocol
 
 import (
 	"errors"
-
-	"github.com/golang/protobuf/proto"
-	"github.com/golang/protobuf/ptypes"
 )
 
 var (
-	ErrUserMissing    = errors.New("User is not specified.")
-	ErrAccountMissing = errors.New("Account is not specified.")
-	ErrNonMessageType = errors.New("Not a protobuf message.")
+	ErrUserMissing        = errors.New("User is not specified.")
+	ErrAccountMissing     = errors.New("Account is not specified.")
+	ErrNonMessageType     = errors.New("Not a protobuf message.")
+	ErrUnknownAccountType = errors.New("Unknown account type.")
 )
 
-func (this *User) GetTypedAccount(account AsAccount) (Account, error) {
-	anyAccount := this.GetAccount()
-	if anyAccount == nil {
+func (this *User) GetTypedAccount() (Account, error) {
+	if this.GetAccount() == nil {
 		return nil, ErrAccountMissing
 	}
-	protoAccount, ok := account.(proto.Message)
-	if !ok {
-		return nil, ErrNonMessageType
-	}
-	err := ptypes.UnmarshalAny(anyAccount, protoAccount)
+
+	rawAccount, err := this.Account.GetInstance()
 	if err != nil {
 		return nil, err
 	}
-	return account.AsAccount()
+	if asAccount, ok := rawAccount.(AsAccount); ok {
+		return asAccount.AsAccount()
+	}
+	if account, ok := rawAccount.(Account); ok {
+		return account, nil
+	}
+	return nil, errors.New("Unknown account type: " + this.Account.Type)
 }
 
 func (this *User) GetSettings() UserSettings {