chore: move code around

app/internal/utils/bpsconv.go

@@ -0,0 +1,68 @@
+package utils
+
+import (
+	"errors"
+	"fmt"
+	"strconv"
+	"strings"
+)
+
+const (
+	Byte = 1.0 << (10 * iota)
+	Kilobyte
+	Megabyte
+	Gigabyte
+	Terabyte
+)
+
+// StringToBps converts a string to a bandwidth value in bytes per second.
+// E.g. "100 Mbps", "512 kbps", "1g" are all valid.
+func StringToBps(s string) (uint64, error) {
+	s = strings.ToLower(strings.TrimSpace(s))
+	spl := 0
+	for i, c := range s {
+		if c < '0' || c > '9' {
+			spl = i
+			break
+		}
+	}
+	if spl == 0 {
+		// No unit or no value
+		return 0, errors.New("invalid format")
+	}
+	v, err := strconv.ParseUint(s[:spl], 10, 64)
+	if err != nil {
+		return 0, err
+	}
+	unit := strings.TrimSpace(s[spl:])
+
+	switch strings.ToLower(unit) {
+	case "b", "bps":
+		return v * Byte / 8, nil
+	case "k", "kb", "kbps":
+		return v * Kilobyte / 8, nil
+	case "m", "mb", "mbps":
+		return v * Megabyte / 8, nil
+	case "g", "gb", "gbps":
+		return v * Gigabyte / 8, nil
+	case "t", "tb", "tbps":
+		return v * Terabyte / 8, nil
+	default:
+		return 0, errors.New("unsupported unit")
+	}
+}
+
+// ConvBandwidth handles both string and int types for bandwidth.
+// When using string, it will be parsed as a bandwidth string with units.
+// When using int, it will be parsed as a raw bandwidth in bytes per second.
+// It does NOT support float types.
+func ConvBandwidth(bw interface{}) (uint64, error) {
+	switch bwT := bw.(type) {
+	case string:
+		return StringToBps(bwT)
+	case int:
+		return uint64(bwT), nil
+	default:
+		return 0, fmt.Errorf("invalid type %T for bandwidth", bwT)
+	}
+}

app/internal/utils/bpsconv_test.go

@@ -0,0 +1,40 @@
+package utils
+
+import "testing"
+
+func TestStringToBps(t *testing.T) {
+	type args struct {
+		s string
+	}
+	tests := []struct {
+		name    string
+		args    args
+		want    uint64
+		wantErr bool
+	}{
+		{"bps", args{"800 bps"}, 100, false},
+		{"kbps", args{"800 kbps"}, 102400, false},
+		{"mbps", args{"800 mbps"}, 104857600, false},
+		{"gbps", args{"800 gbps"}, 107374182400, false},
+		{"tbps", args{"800 tbps"}, 109951162777600, false},
+		{"mbps simp", args{"100m"}, 13107200, false},
+		{"gbps simp upper", args{"2G"}, 268435456, false},
+		{"invalid 1", args{"damn"}, 0, true},
+		{"invalid 2", args{"6444"}, 0, true},
+		{"invalid 3", args{"5.4 mbps"}, 0, true},
+		{"invalid 4", args{"kbps"}, 0, true},
+		{"invalid 5", args{"1234 5678 gbps"}, 0, true},
+	}
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			got, err := StringToBps(tt.args.s)
+			if (err != nil) != tt.wantErr {
+				t.Errorf("StringToBps() error = %v, wantErr %v", err, tt.wantErr)
+				return
+			}
+			if got != tt.want {
+				t.Errorf("StringToBps() got = %v, want %v", got, tt.want)
+			}
+		})
+	}
+}

app/internal/utils/geoip.go

@@ -0,0 +1,70 @@
+package utils
+
+import (
+	"io"
+	"net/http"
+	"os"
+
+	"github.com/oschwald/geoip2-golang"
+)
+
+const (
+	geoipDefaultFilename = "GeoLite2-Country.mmdb"
+	geoipDownloadURL     = "https://git.io/GeoLite2-Country.mmdb"
+)
+
+// GeoIPLoader provides the on-demand GeoIP database loading function required by the ACL engine.
+type GeoIPLoader struct {
+	Filename        string
+	DownloadFunc    func(filename, url string) // Called when downloading the GeoIP database.
+	DownloadErrFunc func(err error)            // Called when downloading the GeoIP database succeeds/fails.
+
+	db *geoip2.Reader
+}
+
+func (l *GeoIPLoader) download() error {
+	resp, err := http.Get(geoipDownloadURL)
+	if err != nil {
+		return err
+	}
+	defer resp.Body.Close()
+
+	f, err := os.Create(geoipDefaultFilename)
+	if err != nil {
+		return err
+	}
+	defer f.Close()
+
+	_, err = io.Copy(f, resp.Body)
+	return err
+}
+
+func (l *GeoIPLoader) Load() *geoip2.Reader {
+	if l.db == nil {
+		if l.Filename == "" {
+			// Filename not specified, try default.
+			if _, err := os.Stat(geoipDefaultFilename); err == nil {
+				// Default already exists, just use it.
+				l.Filename = geoipDefaultFilename
+			} else if os.IsNotExist(err) {
+				// Default doesn't exist, download it.
+				l.DownloadFunc(geoipDefaultFilename, geoipDownloadURL)
+				err := l.download()
+				l.DownloadErrFunc(err)
+				if err != nil {
+					return nil
+				}
+				l.Filename = geoipDefaultFilename
+			} else {
+				// Other error
+				return nil
+			}
+		}
+		db, err := geoip2.Open(l.Filename)
+		if err != nil {
+			return nil
+		}
+		l.db = db
+	}
+	return l.db
+}

app/internal/utils/qr.go

@@ -0,0 +1,16 @@
+package utils
+
+import (
+	"os"
+
+	"github.com/mdp/qrterminal/v3"
+)
+
+func PrintQR(str string) {
+	qrterminal.GenerateWithConfig(str, qrterminal.Config{
+		Level:     qrterminal.L,
+		Writer:    os.Stdout,
+		BlackChar: qrterminal.BLACK,
+		WhiteChar: qrterminal.WHITE,
+	})
+}