refactor docker api code, deps upgrade

internal/api/v1/dockerapi/containers.go

@@ -4,14 +4,9 @@ import (
 	"context"
 	"net/http"
 	"sort"
-	"time"
 
-	"github.com/coder/websocket"
-	"github.com/coder/websocket/wsjson"
 	"github.com/docker/docker/api/types/container"
 	"github.com/yusing/go-proxy/internal/gperr"
-	"github.com/yusing/go-proxy/internal/net/gphttp/gpwebsocket"
-	"github.com/yusing/go-proxy/internal/net/gphttp/httpheaders"
 )
 
 type Container struct {
@@ -23,30 +18,10 @@ type Container struct {
 }
 
 func Containers(w http.ResponseWriter, r *http.Request) {
-	if httpheaders.IsWebsocket(r.Header) {
-		gpwebsocket.Periodic(w, r, 5*time.Second, func(conn *websocket.Conn) error {
-			containers, err := listContainers(r.Context())
-			if err != nil {
-				return err
-			}
-			return wsjson.Write(r.Context(), conn, containers)
-		})
-	} else {
-		containers, err := listContainers(r.Context())
-		handleResult(w, err, containers)
-	}
+	serveHTTP[Container, []Container](w, r, GetContainers)
 }
 
-func listContainers(ctx context.Context) ([]Container, error) {
-	ctx, cancel := context.WithTimeout(ctx, reqTimeout)
-	defer cancel()
-
-	dockerClients, err := getDockerClients()
-	if err != nil {
-		return nil, err
-	}
-	defer closeAllClients(dockerClients)
-
+func GetContainers(ctx context.Context, dockerClients DockerClients) ([]Container, gperr.Error) {
 	errs := gperr.NewBuilder("failed to get containers")
 	containers := make([]Container, 0)
 	for server, dockerClient := range dockerClients {

internal/api/v1/dockerapi/info.go

@@ -4,43 +4,39 @@ import (
 	"context"
 	"encoding/json"
 	"net/http"
+	"sort"
 
 	dockerSystem "github.com/docker/docker/api/types/system"
 	"github.com/yusing/go-proxy/internal/gperr"
 	"github.com/yusing/go-proxy/internal/utils/strutils"
 )
 
-type DockerInfo dockerSystem.Info
+type dockerInfo dockerSystem.Info
 
-func (d *DockerInfo) MarshalJSON() ([]byte, error) {
+func (d *dockerInfo) MarshalJSON() ([]byte, error) {
 	return json.Marshal(map[string]any{
-		"host": d.Name,
+		"name":    d.Name,
+		"version": d.ServerVersion,
 		"containers": map[string]int{
 			"total":   d.Containers,
 			"running": d.ContainersRunning,
 			"paused":  d.ContainersPaused,
 			"stopped": d.ContainersStopped,
 		},
-		"images":  d.Images,
-		"n_cpu":   d.NCPU,
-		"memory":  strutils.FormatByteSizeWithUnit(d.MemTotal),
-		"version": d.ServerVersion,
+		"images": d.Images,
+		"n_cpu":  d.NCPU,
+		"memory": strutils.FormatByteSizeWithUnit(d.MemTotal),
 	})
 }
 
-func Info(w http.ResponseWriter, r *http.Request) {
-	ctx, cancel := context.WithTimeout(r.Context(), reqTimeout)
-	defer cancel()
-
-	dockerClients, ok := getDockerClientsWithErrHandling(w)
-	if !ok {
-		return
-	}
-	defer closeAllClients(dockerClients)
+func DockerInfo(w http.ResponseWriter, r *http.Request) {
+	serveHTTP[dockerInfo, []dockerInfo](w, r, GetDockerInfo)
+}
 
+func GetDockerInfo(ctx context.Context, dockerClients DockerClients) ([]dockerInfo, gperr.Error) {
 	errs := gperr.NewBuilder("failed to get docker info")
+	dockerInfos := make([]dockerInfo, len(dockerClients))
 
-	dockerInfos := make([]DockerInfo, len(dockerClients))
 	i := 0
 	for name, dockerClient := range dockerClients {
 		info, err := dockerClient.Info(ctx)
@@ -49,9 +45,12 @@ func Info(w http.ResponseWriter, r *http.Request) {
 			continue
 		}
 		info.Name = name
-		dockerInfos[i] = DockerInfo(info)
+		dockerInfos[i] = dockerInfo(info)
 		i++
 	}
 
-	handleResult(w, errs.Error(), dockerInfos)
+	sort.Slice(dockerInfos, func(i, j int) bool {
+		return dockerInfos[i].Name < dockerInfos[j].Name
+	})
+	return dockerInfos, errs.Error()
 }

internal/api/v1/dockerapi/utils.go

@@ -1,12 +1,25 @@
 package dockerapi
 
 import (
+	"context"
 	"encoding/json"
 	"net/http"
+	"time"
 
+	"github.com/coder/websocket"
+	"github.com/coder/websocket/wsjson"
 	config "github.com/yusing/go-proxy/internal/config/types"
 	"github.com/yusing/go-proxy/internal/docker"
 	"github.com/yusing/go-proxy/internal/gperr"
+	"github.com/yusing/go-proxy/internal/net/gphttp/gpwebsocket"
+	"github.com/yusing/go-proxy/internal/net/gphttp/httpheaders"
+)
+
+type (
+	DockerClients     map[string]*docker.SharedClient
+	ResultType[T any] interface {
+		map[string]T | []T
+	}
 )
 
 // getDockerClients returns a map of docker clients for the current config.
@@ -14,11 +27,11 @@ import (
 // Returns a map of docker clients by server name and an error if any.
 //
 // Even if there are errors, the map of docker clients might not be empty.
-func getDockerClients() (map[string]*docker.SharedClient, gperr.Error) {
+func getDockerClients() (DockerClients, gperr.Error) {
 	cfg := config.GetInstance()
 
 	dockerHosts := cfg.Value().Providers.Docker
-	dockerClients := make(map[string]*docker.SharedClient)
+	dockerClients := make(DockerClients)
 
 	connErrs := gperr.NewBuilder("failed to connect to docker")
 
@@ -43,21 +56,6 @@ func getDockerClients() (map[string]*docker.SharedClient, gperr.Error) {
 	return dockerClients, connErrs.Error()
 }
 
-// getDockerClientsWithErrHandling returns a map of docker clients for the current config.
-//
-// Returns a map of docker clients by server name and a boolean indicating if http handler should stop/
-func getDockerClientsWithErrHandling(w http.ResponseWriter) (map[string]*docker.SharedClient, bool) {
-	dockerClients, err := getDockerClients()
-	if err != nil {
-		gperr.LogError("failed to get docker clients", err)
-		if len(dockerClients) == 0 {
-			http.Error(w, "no docker hosts connected successfully", http.StatusInternalServerError)
-			return nil, false
-		}
-	}
-	return dockerClients, true
-}
-
 func getDockerClient(w http.ResponseWriter, server string) (*docker.SharedClient, bool, error) {
 	cfg := config.GetInstance()
 	var host string
@@ -86,13 +84,13 @@ func getDockerClient(w http.ResponseWriter, server string) (*docker.SharedClient
 // closeAllClients closes all docker clients after a delay.
 //
 // This is used to ensure that all docker clients are closed after the http handler returns.
-func closeAllClients(dockerClients map[string]*docker.SharedClient) {
+func closeAllClients(dockerClients DockerClients) {
 	for _, dockerClient := range dockerClients {
 		dockerClient.Close()
 	}
 }
 
-func handleResult[T any](w http.ResponseWriter, errs error, result []T) {
+func handleResult[V any, T ResultType[V]](w http.ResponseWriter, errs error, result T) {
 	if errs != nil {
 		gperr.LogError("docker errors", errs)
 		if len(result) == 0 {
@@ -102,3 +100,25 @@ func handleResult[T any](w http.ResponseWriter, errs error, result []T) {
 	}
 	json.NewEncoder(w).Encode(result)
 }
+
+func serveHTTP[V any, T ResultType[V]](w http.ResponseWriter, r *http.Request, getResult func(ctx context.Context, dockerClients DockerClients) (T, gperr.Error)) {
+	dockerClients, err := getDockerClients()
+	if err != nil {
+		handleResult[V, T](w, err, nil)
+		return
+	}
+	defer closeAllClients(dockerClients)
+
+	if httpheaders.IsWebsocket(r.Header) {
+		gpwebsocket.Periodic(w, r, 5*time.Second, func(conn *websocket.Conn) error {
+			result, err := getResult(r.Context(), dockerClients)
+			if err != nil {
+				return err
+			}
+			return wsjson.Write(r.Context(), conn, result)
+		})
+	} else {
+		result, err := getResult(r.Context(), dockerClients)
+		handleResult[V, T](w, err, result)
+	}
+}