From 2e74986fe409c280f89ca08ea913ffea05fcfe00 Mon Sep 17 00:00:00 2001
From: Skyxim <noreply@skyxim.com>
Date: Thu, 28 Apr 2022 08:55:45 +0800
Subject: [PATCH] refactor: adjust provider loading order, remove meaningless
 pointers

---
 config/config.go         |  8 +++---
 hub/executor/executor.go | 53 +++++++++++++++++++++-------------------
 tunnel/tunnel.go         |  6 ++---
 3 files changed, 35 insertions(+), 32 deletions(-)

diff --git a/config/config.go b/config/config.go
index b4874175..c6069c69 100644
--- a/config/config.go
+++ b/config/config.go
@@ -151,7 +151,7 @@ type Config struct {
 	Users         []auth.AuthUser
 	Proxies       map[string]C.Proxy
 	Providers     map[string]providerTypes.ProxyProvider
-	RuleProviders map[string]*providerTypes.RuleProvider
+	RuleProviders map[string]providerTypes.RuleProvider
 	Sniffer       *Sniffer
 }
 
@@ -523,8 +523,8 @@ func parseProxies(cfg *RawConfig) (proxies map[string]C.Proxy, providersMap map[
 	return proxies, providersMap, nil
 }
 
-func parseRules(cfg *RawConfig, proxies map[string]C.Proxy) ([]C.Rule, map[string]*providerTypes.RuleProvider, error) {
-	ruleProviders := map[string]*providerTypes.RuleProvider{}
+func parseRules(cfg *RawConfig, proxies map[string]C.Proxy) ([]C.Rule, map[string]providerTypes.RuleProvider, error) {
+	ruleProviders := map[string]providerTypes.RuleProvider{}
 	log.Infoln("Geodata Loader mode: %s", geodata.LoaderName())
 	// parse rule provider
 	for name, mapping := range cfg.RuleProvider {
@@ -533,7 +533,7 @@ func parseRules(cfg *RawConfig, proxies map[string]C.Proxy) ([]C.Rule, map[strin
 			return nil, nil, err
 		}
 
-		ruleProviders[name] = &rp
+		ruleProviders[name] = rp
 		RP.SetRuleProvider(rp)
 	}
 
diff --git a/hub/executor/executor.go b/hub/executor/executor.go
index 404e7fe4..75476527 100644
--- a/hub/executor/executor.go
+++ b/hub/executor/executor.go
@@ -82,8 +82,9 @@ func ApplyConfig(cfg *config.Config, force bool) {
 	updateTun(cfg.Tun, cfg.DNS)
 	updateExperimental(cfg)
 	updateHosts(cfg.Hosts)
-	loadProvider(cfg.RuleProviders, cfg.Providers)
+	loadProxyProvider(cfg.Providers)
 	updateProfile(cfg)
+	loadRuleProvider(cfg.RuleProviders)
 
 	log.SetLevel(cfg.General.LogLevel)
 }
@@ -181,39 +182,41 @@ func updateProxies(proxies map[string]C.Proxy, providers map[string]provider.Pro
 	tunnel.UpdateProxies(proxies, providers)
 }
 
-func updateRules(rules []C.Rule, ruleProviders map[string]*provider.RuleProvider) {
+func updateRules(rules []C.Rule, ruleProviders map[string]provider.RuleProvider) {
 	tunnel.UpdateRules(rules, ruleProviders)
 }
 
-func loadProvider(ruleProviders map[string]*provider.RuleProvider, proxyProviders map[string]provider.ProxyProvider) {
-	load := func(pv provider.Provider) {
-		if pv.VehicleType() == provider.Compatible {
-			log.Infoln("Start initial compatible provider %s", pv.Name())
-		} else {
-			log.Infoln("Start initial provider %s", (pv).Name())
-		}
-
-		if err := (pv).Initial(); err != nil {
-			switch pv.Type() {
-			case provider.Proxy:
-				{
-					log.Warnln("initial proxy provider %s error: %v", (pv).Name(), err)
-				}
-			case provider.Rule:
-				{
-					log.Warnln("initial rule provider %s error: %v", (pv).Name(), err)
-				}
+func loadProvider(pv provider.Provider) {
+	if pv.VehicleType() == provider.Compatible {
+		log.Infoln("Start initial compatible provider %s", pv.Name())
+	} else {
+		log.Infoln("Start initial provider %s", (pv).Name())
+	}
 
+	if err := (pv).Initial(); err != nil {
+		switch pv.Type() {
+		case provider.Proxy:
+			{
+				log.Warnln("initial proxy provider %s error: %v", (pv).Name(), err)
 			}
+		case provider.Rule:
+			{
+				log.Warnln("initial rule provider %s error: %v", (pv).Name(), err)
+			}
+
 		}
 	}
+}
 
-	for _, proxyProvider := range proxyProviders {
-		load(proxyProvider)
-	}
-
+func loadRuleProvider(ruleProviders map[string]provider.RuleProvider) {
 	for _, ruleProvider := range ruleProviders {
-		load(*ruleProvider)
+		loadProvider(ruleProvider)
+	}
+}
+
+func loadProxyProvider(ruleProviders map[string]provider.ProxyProvider) {
+	for _, ruleProvider := range ruleProviders {
+		loadProvider(ruleProvider)
 	}
 }
 
diff --git a/tunnel/tunnel.go b/tunnel/tunnel.go
index 6d0265d6..2108e814 100644
--- a/tunnel/tunnel.go
+++ b/tunnel/tunnel.go
@@ -30,7 +30,7 @@ var (
 	rules         []C.Rule
 	proxies       = make(map[string]C.Proxy)
 	providers     map[string]provider.ProxyProvider
-	ruleProviders map[string]*provider.RuleProvider
+	ruleProviders map[string]provider.RuleProvider
 	configMux     sync.RWMutex
 
 	// Outbound Rule
@@ -62,7 +62,7 @@ func Rules() []C.Rule {
 }
 
 // UpdateRules handle update rules
-func UpdateRules(newRules []C.Rule, rp map[string]*provider.RuleProvider) {
+func UpdateRules(newRules []C.Rule, rp map[string]provider.RuleProvider) {
 	configMux.Lock()
 	rules = newRules
 	ruleProviders = rp
@@ -80,7 +80,7 @@ func Providers() map[string]provider.ProxyProvider {
 }
 
 // RuleProviders return all loaded rule providers
-func RuleProviders() map[string]*provider.RuleProvider {
+func RuleProviders() map[string]provider.RuleProvider {
 	return ruleProviders
 }