Create completely new ServersInfo.inner when refresh()

Exclude servers/relays that have been removed from the sources, had their
privacy level lowered, or IPv6 has became unavailable while enabled IPv6
servers.

Author: lifenjoiner

dnscrypt-proxy/serversInfo.go

@@ -217,7 +217,7 @@ func (serversInfo *ServersInfo) registerRelay(name string, stamp stamps.ServerSt
 	serversInfo.registeredRelays = append(serversInfo.registeredRelays, newRegisteredServer)
 }
 
-func (serversInfo *ServersInfo) refreshServer(proxy *Proxy, name string, stamp stamps.ServerStamp) error {
+func (serversInfo *ServersInfo) initServerInfo(proxy *Proxy, name string, stamp stamps.ServerStamp) (*ServerInfo, bool, error) {
 	serversInfo.RLock()
 	isNew := true
 	for _, oldServer := range serversInfo.inner {
@@ -229,26 +229,33 @@ func (serversInfo *ServersInfo) refreshServer(proxy *Proxy, name string, stamp s
 	serversInfo.RUnlock()
 	newServer, err := fetchServerInfo(proxy, name, stamp, isNew)
 	if err != nil {
-		return err
+		return nil, isNew, err
 	}
 	if name != newServer.Name {
 		dlog.Fatalf("[%s] != [%s]", name, newServer.Name)
 	}
 	newServer.rtt = ewma.NewMovingAverage(RTTEwmaDecay)
 	newServer.rtt.Set(float64(newServer.initialRtt))
-	isNew = true
+	return &newServer, isNew, err
+}
+
+func (serversInfo *ServersInfo) refreshServer(proxy *Proxy, name string, stamp stamps.ServerStamp) error {
+	newServer, isNew, err := serversInfo.initServerInfo(proxy, name, stamp)
+	if err != nil {
+		return err
+	}
 	serversInfo.Lock()
 	for i, oldServer := range serversInfo.inner {
 		if oldServer.Name == name {
-			serversInfo.inner[i] = &newServer
+			serversInfo.inner[i] = newServer
 			isNew = false
 			break
 		}
 	}
 	serversInfo.Unlock()
 	if isNew {
 		serversInfo.Lock()
-		serversInfo.inner = append(serversInfo.inner, &newServer)
+		serversInfo.inner = append(serversInfo.inner, newServer)
 		serversInfo.Unlock()
 		proxy.serversInfo.registerServer(name, stamp)
 	}
@@ -266,29 +273,48 @@ func (serversInfo *ServersInfo) refresh(proxy *Proxy) (int, error) {
 	serversInfo.RUnlock()
 	countChannel := make(chan struct{}, proxy.certRefreshConcurrency)
 	errorChannel := make(chan error, serversCount)
+	serverInfoChannel := make(chan *ServerInfo, serversCount)
+	rebuildInner := len(serversInfo.inner) > 0
 	for i := range registeredServers {
 		countChannel <- struct{}{}
 		go func(registeredServer *RegisteredServer) {
-			err := serversInfo.refreshServer(proxy, registeredServer.name, registeredServer.stamp)
-			if err == nil {
-				proxy.xTransport.internalResolverReady = true
+			var serverInfo *ServerInfo
+			var err error
+			if rebuildInner {
+				serverInfo, _, err = serversInfo.initServerInfo(proxy, registeredServer.name, registeredServer.stamp)
+				serverInfoChannel <- serverInfo
+			} else {
+				err = serversInfo.refreshServer(proxy, registeredServer.name, registeredServer.stamp)
+				if err == nil {
+					proxy.xTransport.internalResolverReady = true
+				}
 			}
 			errorChannel <- err
 			<-countChannel
 		}(&registeredServers[i])
 	}
 	liveServers := 0
 	var err error
+	var innerRefresh []*ServerInfo
 	for i := 0; i < serversCount; i++ {
 		err = <-errorChannel
 		if err == nil {
 			liveServers++
 		}
+		if rebuildInner {
+			serverInfo := <-serverInfoChannel
+			if serverInfo != nil {
+				innerRefresh = append(innerRefresh, serverInfo)
+			}
+		}
 	}
 	if liveServers > 0 {
 		err = nil
 	}
 	serversInfo.Lock()
+	if len(innerRefresh) > 0 {
+		serversInfo.inner = innerRefresh
+	}
 	sort.SliceStable(serversInfo.inner, func(i, j int) bool {
 		return serversInfo.inner[i].initialRtt < serversInfo.inner[j].initialRtt
 	})