wip

internal/updater/updater.go

@@ -2,10 +2,15 @@ package updater
 
 import (
 	"context"
+	"encoding/json"
 	"errors"
+	"fmt"
+	"io"
 	"net/http"
+	"strings"
 	"time"
 
+	"github.com/qdm12/gluetun/internal/constants/providers"
 	"github.com/qdm12/gluetun/internal/provider/common"
 	"github.com/qdm12/gluetun/internal/updater/unzip"
 	"golang.org/x/text/cases"
@@ -13,7 +18,8 @@ import (
 )
 
 type Updater struct {
-	providers Providers
+	providers            Providers
+	preferDirectDownload bool
 
 	// state
 	storage Storage
@@ -26,22 +32,31 @@ type Updater struct {
 }
 
 func New(httpClient *http.Client, storage Storage,
-	providers Providers, logger Logger,
+	providers Providers, logger Logger, preferDirectDownload bool,
 ) *Updater {
 	unzipper := unzip.New(httpClient)
 	return &Updater{
-		providers: providers,
-		storage:   storage,
-		logger:    logger,
-		timeNow:   time.Now,
-		client:    httpClient,
-		unzipper:  unzipper,
+		providers:            providers,
+		storage:              storage,
+		logger:               logger,
+		timeNow:              time.Now,
+		client:               httpClient,
+		unzipper:             unzipper,
+		preferDirectDownload: preferDirectDownload,
 	}
 }
 
 func (u *Updater) UpdateServers(ctx context.Context, providers []string,
 	minRatio float64,
 ) (err error) {
+	var manifest manifest
+	if u.preferDirectDownload {
+		manifest, err = u.fetchManifest(ctx)
+		if err != nil {
+			return fmt.Errorf("fetching remote manifest: %w", err)
+		}
+	}
+
 	caser := cases.Title(language.English)
 	for _, providerName := range providers {
 		u.logger.Info("updating " + caser.String(providerName) + " servers...")
@@ -49,7 +64,7 @@ func (u *Updater) UpdateServers(ctx context.Context, providers []string,
 		fetcher := u.providers.Get(providerName)
 		// TODO support servers offering only TCP or only UDP
 		// for NordVPN and PureVPN
-		err := u.updateProvider(ctx, fetcher, minRatio)
+		err := u.updateProvider(ctx, fetcher, manifest, minRatio)
 		switch {
 		case err == nil:
 			continue
@@ -70,3 +85,60 @@ func (u *Updater) UpdateServers(ctx context.Context, providers []string,
 
 	return nil
 }
+
+type manifest struct {
+	providerToFilepath map[string]string
+}
+
+func (u *Updater) fetchManifest(ctx context.Context) (m manifest, err error) {
+	const serversManifestURL = "https://raw.githubusercontent.com/qdm12/gluetun-servers/main/pkg/servers/manifest.json"
+	var raw map[string]json.RawMessage
+	err = u.fetchJSON(ctx, serversManifestURL, &raw)
+	if err != nil {
+		return m, err
+	}
+
+	providerNames := providers.All()
+	m.providerToFilepath = make(map[string]string, len(providerNames))
+	for _, name := range providerNames {
+		var metadata struct {
+			Filepath string `json:"filepath"`
+		}
+		err = json.Unmarshal(raw[name], &metadata)
+		if err != nil {
+			return m, fmt.Errorf("decoding manifest metadata for %s: %w", name, err)
+		} else if metadata.Filepath == "" {
+			return m, fmt.Errorf("manifest missing filepath for provider %s", name)
+		}
+		m.providerToFilepath[name] = metadata.Filepath
+	}
+
+	return m, nil
+}
+
+func (u *Updater) fetchJSON(ctx context.Context, rawURL string, dst any) (err error) {
+	req, err := http.NewRequestWithContext(ctx, http.MethodGet, rawURL, nil)
+	if err != nil {
+		return fmt.Errorf("creating request: %w", err)
+	}
+
+	response, err := u.client.Do(req)
+	if err != nil {
+		return fmt.Errorf("doing request: %w", err)
+	}
+	defer response.Body.Close()
+
+	if response.StatusCode != http.StatusOK {
+		const limit = 10 * 1024 * 1024 // 10 MiB
+		body, _ := io.ReadAll(io.LimitReader(response.Body, limit))
+		return fmt.Errorf("HTTP status code %d for %s: %s",
+			response.StatusCode, rawURL, strings.TrimSpace(string(body)))
+	}
+
+	err = json.NewDecoder(response.Body).Decode(dst)
+	if err != nil {
+		return fmt.Errorf("decoding response body: %w", err)
+	}
+
+	return nil
+}