Public IP endpoint with GET /ip fixing #319

internal/server/handler.go

@@ -7,6 +7,7 @@ import (
 	"github.com/qdm12/gluetun/internal/dns"
 	"github.com/qdm12/gluetun/internal/models"
 	"github.com/qdm12/gluetun/internal/openvpn"
+	"github.com/qdm12/gluetun/internal/publicip"
 	"github.com/qdm12/gluetun/internal/updater"
 	"github.com/qdm12/golibs/logging"
 )
@@ -16,15 +17,17 @@ func newHandler(logger logging.Logger, logging bool,
 	openvpnLooper openvpn.Looper,
 	unboundLooper dns.Looper,
 	updaterLooper updater.Looper,
+	publicIPLooper publicip.Looper,
 ) http.Handler {
 	handler := &handler{}
 
 	openvpn := newOpenvpnHandler(openvpnLooper, logger)
 	dns := newDNSHandler(unboundLooper, logger)
 	updater := newUpdaterHandler(updaterLooper, logger)
+	publicip := newPublicIPHandler(publicIPLooper, logger)
 
 	handler.v0 = newHandlerV0(logger, openvpnLooper, unboundLooper, updaterLooper)
-	handler.v1 = newHandlerV1(logger, buildInfo, openvpn, dns, updater)
+	handler.v1 = newHandlerV1(logger, buildInfo, openvpn, dns, updater, publicip)
 
 	handlerWithLog := withLogMiddleware(handler, logger, logging)
 	handler.setLogEnabled = handlerWithLog.setEnabled

internal/server/handlerv1.go

@@ -11,13 +11,14 @@ import (
 )
 
 func newHandlerV1(logger logging.Logger, buildInfo models.BuildInformation,
-	openvpn, dns, updater http.Handler) http.Handler {
+	openvpn, dns, updater, publicip http.Handler) http.Handler {
 	return &handlerV1{
 		logger:    logger,
 		buildInfo: buildInfo,
 		openvpn:   openvpn,
 		dns:       dns,
 		updater:   updater,
+		publicip:  publicip,
 	}
 }
 
@@ -27,6 +28,7 @@ type handlerV1 struct {
 	openvpn   http.Handler
 	dns       http.Handler
 	updater   http.Handler
+	publicip  http.Handler
 }
 
 func (h *handlerV1) ServeHTTP(w http.ResponseWriter, r *http.Request) {
@@ -39,6 +41,8 @@ func (h *handlerV1) ServeHTTP(w http.ResponseWriter, r *http.Request) {
 		h.dns.ServeHTTP(w, r)
 	case strings.HasPrefix(r.RequestURI, "/updater"):
 		h.updater.ServeHTTP(w, r)
+	case strings.HasPrefix(r.RequestURI, "/publicip"):
+		h.publicip.ServeHTTP(w, r)
 	default:
 		errString := fmt.Sprintf("%s %s not found", r.Method, r.RequestURI)
 		http.Error(w, errString, http.StatusNotFound)

internal/server/publicip.go

@@ -0,0 +1,55 @@
+//nolint:dupl
+package server
+
+import (
+	"encoding/json"
+	"net/http"
+	"strings"
+
+	"github.com/qdm12/gluetun/internal/publicip"
+	"github.com/qdm12/golibs/logging"
+)
+
+func newPublicIPHandler(
+	looper publicip.Looper,
+	logger logging.Logger) http.Handler {
+	return &publicIPHandler{
+		looper: looper,
+		logger: logger,
+	}
+}
+
+type publicIPHandler struct {
+	looper publicip.Looper
+	logger logging.Logger
+}
+
+func (h *publicIPHandler) ServeHTTP(w http.ResponseWriter, r *http.Request) {
+	r.RequestURI = strings.TrimPrefix(r.RequestURI, "/publicip")
+	switch r.RequestURI {
+	case "/ip":
+		switch r.Method {
+		case http.MethodGet:
+			h.getPublicIP(w)
+		default:
+			http.Error(w, "", http.StatusNotFound)
+		}
+	default:
+		http.Error(w, "", http.StatusNotFound)
+	}
+}
+
+type publicIPWrapper struct {
+	PublicIP string `json:"public_ip"`
+}
+
+func (h *publicIPHandler) getPublicIP(w http.ResponseWriter) {
+	publicIP := h.looper.GetPublicIP()
+	encoder := json.NewEncoder(w)
+	data := publicIPWrapper{PublicIP: publicIP.String()}
+	if err := encoder.Encode(data); err != nil {
+		h.logger.Warn(err)
+		w.WriteHeader(http.StatusInternalServerError)
+		return
+	}
+}

internal/server/server.go

@@ -9,6 +9,7 @@ import (
 	"github.com/qdm12/gluetun/internal/dns"
 	"github.com/qdm12/gluetun/internal/models"
 	"github.com/qdm12/gluetun/internal/openvpn"
+	"github.com/qdm12/gluetun/internal/publicip"
 	"github.com/qdm12/gluetun/internal/updater"
 	"github.com/qdm12/golibs/logging"
 )
@@ -25,9 +26,11 @@ type server struct {
 
 func New(address string, logging bool, logger logging.Logger,
 	buildInfo models.BuildInformation,
-	openvpnLooper openvpn.Looper, unboundLooper dns.Looper, updaterLooper updater.Looper) Server {
+	openvpnLooper openvpn.Looper, unboundLooper dns.Looper,
+	updaterLooper updater.Looper, publicIPLooper publicip.Looper) Server {
 	serverLogger := logger.WithPrefix("http server: ")
-	handler := newHandler(serverLogger, logging, buildInfo, openvpnLooper, unboundLooper, updaterLooper)
+	handler := newHandler(serverLogger, logging, buildInfo,
+		openvpnLooper, unboundLooper, updaterLooper, publicIPLooper)
 	return &server{
 		address: address,
 		logger:  serverLogger,