Add support for region paths

config.go

@@ -46,6 +46,17 @@ func reloadConfig() {
 	// Reload server list
 	reloadServers()
 
+	// Create mirror map
+	mirrors := make(map[string][]*Server)
+
+	for _, server := range servers {
+		mirrors[server.Continent] = append(mirrors[server.Continent], server)
+	}
+
+	mirrors["default"] = append(mirrors["NA"], mirrors["EU"]...)
+
+	mirrorMap = mirrors
+
 	// Check top choices size
 	if topChoices > len(servers) {
 		topChoices = len(servers)

http.go

@@ -3,9 +3,11 @@ package main
 import (
 	"encoding/json"
 	"fmt"
+	"github.com/jmcvetta/randutil"
 	"net"
 	"net/http"
 	"net/url"
+	"os"
 	"path"
 	"strings"
 )
@@ -18,21 +20,19 @@ func statusHandler(w http.ResponseWriter, r *http.Request) {
 func legacyMirrorsHandler(w http.ResponseWriter, r *http.Request) {
 	w.Header().Set("Content-Type", "application/json")
 
-	mirrors := make(map[string][]string)
+	mirrorOutput := make(map[string][]string)
 
-	for _, server := range servers {
+	for region, mirrors := range mirrorMap {
-		u := &url.URL{
+		list := make([]string, len(mirrors))
-			Scheme: r.URL.Scheme,
+
-			Host:   server.Host,
+		for i, mirror := range mirrors {
-			Path:   server.Path,
+			list[i] = r.URL.Scheme + "://" + mirror.Host + "/" + strings.TrimLeft(mirror.Path, "/")
 		}
 
-		mirrors[server.Continent] = append(mirrors[server.Continent], u.String())
+		mirrorOutput[region] = list
 	}
 
-	mirrors["default"] = append(mirrors["NA"], mirrors["EU"]...)
+	json.NewEncoder(w).Encode(mirrorOutput)
-
-	json.NewEncoder(w).Encode(mirrors)
 }
 
 func mirrorsHandler(w http.ResponseWriter, r *http.Request) {
@@ -50,16 +50,57 @@ func redirectHandler(w http.ResponseWriter, r *http.Request) {
 
 	ip := net.ParseIP(ipStr)
 
-	// TODO: This is temporary to allow testing on private addresses.
+	if ip.IsLoopback() || ip.IsPrivate() {
-	if ip.IsPrivate() {
+		overrideIP := os.Getenv("OVERRIDE_IP")
-		ip = net.ParseIP("1.1.1.1")
+
+		if overrideIP == "" {
+			overrideIP = "1.1.1.1"
+		}
+
+		ip = net.ParseIP(overrideIP)
 	}
 
-	server, distance, err := servers.Closest(ip)
+	var server *Server
+	var distance float64
 
-	if err != nil {
+	if strings.HasPrefix(r.URL.Path, "/region") {
-		http.Error(w, err.Error(), http.StatusInternalServerError)
+		parts := strings.Split(r.URL.Path, "/")
-		return
+
+		// region = parts[2]
+		if mirrors, ok := mirrorMap[parts[2]]; ok {
+			choices := make([]randutil.Choice, len(mirrors))
+
+			for i, item := range mirrors {
+				if !item.Available {
+					continue
+				}
+
+				choices[i] = randutil.Choice{
+					Weight: item.Weight,
+					Item:   item,
+				}
+			}
+
+			choice, err := randutil.WeightedChoice(choices)
+
+			if err != nil {
+				http.Error(w, err.Error(), http.StatusInternalServerError)
+				return
+			}
+
+			server = choice.Item.(*Server)
+
+			r.URL.Path = strings.Join(parts[3:], "/")
+		}
+	}
+
+	if server == nil {
+		server, distance, err = servers.Closest(ip)
+
+		if err != nil {
+			http.Error(w, err.Error(), http.StatusInternalServerError)
+			return
+		}
 	}
 
 	scheme := r.URL.Scheme
@@ -96,7 +137,10 @@ func redirectHandler(w http.ResponseWriter, r *http.Request) {
 	server.Redirects.Inc()
 	redirectsServed.Inc()
 
-	w.Header().Set("X-Geo-Distance", fmt.Sprintf("%f", distance))
+	if distance > 0 {
+		w.Header().Set("X-Geo-Distance", fmt.Sprintf("%f", distance))
+	}
+
 	w.Header().Set("Location", u.String())
 	w.WriteHeader(http.StatusFound)
 }

main.go

@@ -18,8 +18,9 @@ import (
 )
 
 var (
-	db      *maxminddb.Reader
+	db        *maxminddb.Reader
-	servers ServerList
+	servers   ServerList
+	mirrorMap map[string][]*Server
 
 	dlMap map[string]string
 
@@ -110,6 +111,7 @@ func main() {
 	r.Use(RealIPMiddleware)
 	r.Use(logger.Logger("router", log.StandardLogger()))
 
+	r.Head("/status", statusHandler)
 	r.Get("/status", statusHandler)
 	r.Get("/mirrors", legacyMirrorsHandler)
 	r.Get("/mirrors.json", mirrorsHandler)

servers.go

@@ -123,19 +123,6 @@ type ComputedDistance struct {
 // DistanceList is a list of Computed Distances with an easy "Choices" func
 type DistanceList []ComputedDistance
 
-func (d DistanceList) Choices() []randutil.Choice {
-	c := make([]randutil.Choice, len(d))
-
-	for i, item := range d {
-		c[i] = randutil.Choice{
-			Weight: item.Server.Weight,
-			Item:   item,
-		}
-	}
-
-	return c
-}
-
 // Closest will use GeoIP on the IP provided and find the closest servers.
 // When we have a list of x servers closest, we can choose a random or weighted one.
 // Return values are the closest server, the distance, and if an error occurred.
@@ -157,18 +144,33 @@ func (s ServerList) Closest(ip net.IP) (*Server, float64, error) {
 				continue
 			}
 
+			distance := Distance(city.Location.Latitude, city.Location.Longitude, server.Latitude, server.Longitude)
+
 			c[i] = ComputedDistance{
 				Server:   server,
-				Distance: Distance(city.Location.Latitude, city.Location.Longitude, server.Latitude, server.Longitude),
+				Distance: distance,
 			}
 		}
 
 		// Sort by distance
-		sort.Slice(s, func(i int, j int) bool {
+		sort.Slice(c, func(i int, j int) bool {
 			return c[i].Distance < c[j].Distance
 		})
 
-		choiceInterface = c[0:topChoices].Choices()
+		choices := make([]randutil.Choice, topChoices)
+
+		for i, item := range c[0:topChoices] {
+			if item.Server == nil {
+				continue
+			}
+
+			choices[i] = randutil.Choice{
+				Weight: item.Server.Weight,
+				Item:   item,
+			}
+		}
+
+		choiceInterface = choices
 
 		serverCache.Add(ip.String(), choiceInterface)
 	}