Revert "refactor(docker): migrate from github.com/docker/docker to github.com/moby/moby"

This reverts commit c156173757.

internal/api/v1/docker/container.go

@@ -4,7 +4,6 @@ import (
 	"net/http"
 
 	"github.com/gin-gonic/gin"
-	"github.com/moby/moby/client"
 	"github.com/yusing/godoxy/internal/docker"
 	apitypes "github.com/yusing/goutils/apitypes"
 )
@@ -35,30 +34,30 @@ func GetContainer(c *gin.Context) {
 		return
 	}
 
-	dockerClient, err := docker.NewClient(dockerHost)
+	client, err := docker.NewClient(dockerHost)
 	if err != nil {
 		c.Error(apitypes.InternalServerError(err, "failed to create docker client"))
 		return
 	}
 
-	defer dockerClient.Close()
+	defer client.Close()
 
-	cont, err := dockerClient.ContainerInspect(c.Request.Context(), id, client.ContainerInspectOptions{})
+	cont, err := client.ContainerInspect(c.Request.Context(), id)
 	if err != nil {
 		c.Error(apitypes.InternalServerError(err, "failed to inspect container"))
 		return
 	}
 
 	var state ContainerState
-	if cont.Container.State != nil {
-		state = cont.Container.State.Status
+	if cont.State != nil {
+		state = cont.State.Status
 	}
 
 	c.JSON(http.StatusOK, &Container{
 		Server: dockerHost,
-		Name:   cont.Container.Name,
-		ID:     cont.Container.ID,
-		Image:  cont.Container.Image,
+		Name:   cont.Name,
+		ID:     cont.ID,
+		Image:  cont.Image,
 		State:  state,
 	})
 }

internal/api/v1/docker/containers.go

@@ -4,9 +4,8 @@ import (
 	"context"
 	"sort"
 
+	"github.com/docker/docker/api/types/container"
 	"github.com/gin-gonic/gin"
-	"github.com/moby/moby/api/types/container"
-	"github.com/moby/moby/client"
 	gperr "github.com/yusing/goutils/errs"
 
 	_ "github.com/yusing/goutils/apitypes"
@@ -40,12 +39,12 @@ func GetContainers(ctx context.Context, dockerClients DockerClients) ([]Containe
 	errs := gperr.NewBuilder("failed to get containers")
 	containers := make([]Container, 0)
 	for server, dockerClient := range dockerClients {
-		conts, err := dockerClient.ContainerList(ctx, client.ContainerListOptions{All: true})
+		conts, err := dockerClient.ContainerList(ctx, container.ListOptions{All: true})
 		if err != nil {
 			errs.Add(err)
 			continue
 		}
-		for _, cont := range conts.Items {
+		for _, cont := range conts {
 			containers = append(containers, Container{
 				Server: server,
 				Name:   cont.Names[0],

internal/api/v1/docker/info.go

@@ -4,9 +4,8 @@ import (
 	"context"
 	"sort"
 
+	dockerSystem "github.com/docker/docker/api/types/system"
 	"github.com/gin-gonic/gin"
-	dockerSystem "github.com/moby/moby/api/types/system"
-	"github.com/moby/moby/client"
 	gperr "github.com/yusing/goutils/errs"
 	strutils "github.com/yusing/goutils/strings"
 
@@ -65,13 +64,13 @@ func GetDockerInfo(ctx context.Context, dockerClients DockerClients) ([]dockerIn
 
 	i := 0
 	for name, dockerClient := range dockerClients {
-		info, err := dockerClient.Info(ctx, client.InfoOptions{})
+		info, err := dockerClient.Info(ctx)
 		if err != nil {
 			errs.Add(err)
 			continue
 		}
-		info.Info.Name = name
-		dockerInfos[i] = toDockerInfo(info.Info)
+		info.Name = name
+		dockerInfos[i] = toDockerInfo(info)
 		i++
 	}
 

internal/api/v1/docker/logs.go

@@ -6,9 +6,9 @@ import (
 	"fmt"
 	"net/http"
 
+	"github.com/docker/docker/api/types/container"
+	"github.com/docker/docker/pkg/stdcopy"
 	"github.com/gin-gonic/gin"
-	"github.com/moby/moby/api/pkg/stdcopy"
-	"github.com/moby/moby/client"
 	"github.com/rs/zerolog/log"
 	"github.com/yusing/godoxy/internal/docker"
 	apitypes "github.com/yusing/goutils/apitypes"
@@ -70,7 +70,7 @@ func Logs(c *gin.Context) {
 	}
 	defer dockerClient.Close()
 
-	opts := client.ContainerLogsOptions{
+	opts := container.LogsOptions{
 		ShowStdout: queryParams.Stdout,
 		ShowStderr: queryParams.Stderr,
 		Since:      queryParams.Since,

internal/api/v1/docker/restart.go

@@ -4,23 +4,17 @@ import (
 	"net/http"
 
 	"github.com/gin-gonic/gin"
-	"github.com/moby/moby/client"
 	"github.com/yusing/godoxy/internal/docker"
 	apitypes "github.com/yusing/goutils/apitypes"
 )
 
-type RestartRequest struct {
-	ID string `json:"id" binding:"required"`
-	client.ContainerRestartOptions
-}
-
 // @x-id				"restart"
 // @BasePath		/api/v1
 // @Summary		Restart container
 // @Description	Restart container by container id
 // @Tags			docker
 // @Produce		json
-// @Param			request	body	RestartRequest	true	"Request"
+// @Param			request	body		StopRequest	true	"Request"
 // @Success		200	{object}  apitypes.SuccessResponse
 // @Failure		400	{object}	apitypes.ErrorResponse "Invalid request"
 // @Failure		403	{object}	apitypes.ErrorResponse
@@ -28,7 +22,7 @@ type RestartRequest struct {
 // @Failure		500	{object}	apitypes.ErrorResponse
 // @Router			/docker/restart [post]
 func Restart(c *gin.Context) {
-	var req RestartRequest
+	var req StopRequest
 	if err := c.ShouldBindJSON(&req); err != nil {
 		c.JSON(http.StatusBadRequest, apitypes.Error("invalid request", err))
 		return
@@ -48,7 +42,7 @@ func Restart(c *gin.Context) {
 
 	defer client.Close()
 
-	_, err = client.ContainerRestart(c.Request.Context(), req.ID, req.ContainerRestartOptions)
+	err = client.ContainerRestart(c.Request.Context(), req.ID, req.StopOptions)
 	if err != nil {
 		c.Error(apitypes.InternalServerError(err, "failed to restart container"))
 		return

internal/api/v1/docker/start.go

@@ -3,15 +3,15 @@ package dockerapi
 import (
 	"net/http"
 
+	"github.com/docker/docker/api/types/container"
 	"github.com/gin-gonic/gin"
-	"github.com/moby/moby/client"
 	"github.com/yusing/godoxy/internal/docker"
 	apitypes "github.com/yusing/goutils/apitypes"
 )
 
 type StartRequest struct {
 	ID string `json:"id" binding:"required"`
-	client.ContainerStartOptions
+	container.StartOptions
 }
 
 // @x-id				"start"
@@ -48,7 +48,7 @@ func Start(c *gin.Context) {
 
 	defer client.Close()
 
-	_, err = client.ContainerStart(c.Request.Context(), req.ID, req.ContainerStartOptions)
+	err = client.ContainerStart(c.Request.Context(), req.ID, req.StartOptions)
 	if err != nil {
 		c.Error(apitypes.InternalServerError(err, "failed to start container"))
 		return

internal/api/v1/docker/stop.go

@@ -3,15 +3,15 @@ package dockerapi
 import (
 	"net/http"
 
+	"github.com/docker/docker/api/types/container"
 	"github.com/gin-gonic/gin"
-	"github.com/moby/moby/client"
 	"github.com/yusing/godoxy/internal/docker"
 	apitypes "github.com/yusing/goutils/apitypes"
 )
 
 type StopRequest struct {
 	ID string `json:"id" binding:"required"`
-	client.ContainerStopOptions
+	container.StopOptions
 }
 
 // @x-id				"stop"
@@ -48,7 +48,7 @@ func Stop(c *gin.Context) {
 
 	defer client.Close()
 
-	_, err = client.ContainerStop(c.Request.Context(), req.ID, req.ContainerStopOptions)
+	err = client.ContainerStop(c.Request.Context(), req.ID, req.StopOptions)
 	if err != nil {
 		c.Error(apitypes.InternalServerError(err, "failed to stop container"))
 		return

internal/docker/client.go

@@ -14,7 +14,7 @@ import (
 	"unsafe"
 
 	"github.com/docker/cli/cli/connhelper"
-	"github.com/moby/moby/client"
+	"github.com/docker/docker/client"
 	"github.com/rs/zerolog/log"
 	"github.com/yusing/godoxy/agent/pkg/agent"
 	"github.com/yusing/godoxy/internal/common"
@@ -110,8 +110,6 @@ func Clients() map[string]*SharedClient {
 	return clients
 }
 
-var versionArg = client.WithVersion("v1.51.0")
-
 // NewClient creates a new Docker client connection to the specified host.
 //
 // Returns existing client if available.
@@ -154,7 +152,7 @@ func NewClient(host string, unique ...bool) (*SharedClient, error) {
 		opt = []client.Opt{
 			client.WithHost(agent.DockerHost),
 			client.WithHTTPClient(cfg.NewHTTPClient()),
-			versionArg,
+			client.WithAPIVersionNegotiation(),
 		}
 		addr = "tcp://" + cfg.Addr
 		dial = cfg.DialContext
@@ -165,7 +163,7 @@ func NewClient(host string, unique ...bool) (*SharedClient, error) {
 		case common.DockerHostFromEnv:
 			opt = []client.Opt{
 				client.WithHostFromEnv(),
-				versionArg,
+				client.WithAPIVersionNegotiation(),
 			}
 		default:
 			helper, err := connhelper.GetConnectionHelper(host)
@@ -181,19 +179,19 @@ func NewClient(host string, unique ...bool) (*SharedClient, error) {
 				opt = []client.Opt{
 					client.WithHTTPClient(httpClient),
 					client.WithHost(helper.Host),
-					versionArg,
+					client.WithAPIVersionNegotiation(),
 					client.WithDialContext(helper.Dialer),
 				}
 			} else {
 				opt = []client.Opt{
 					client.WithHost(host),
-					versionArg,
+					client.WithAPIVersionNegotiation(),
 				}
 			}
 		}
 	}
 
-	client, err := client.New(opt...)
+	client, err := client.NewClientWithOpts(opt...)
 	if err != nil {
 		return nil, err
 	}

internal/docker/container.go

@@ -11,9 +11,8 @@ import (
 	"strconv"
 	"strings"
 
+	"github.com/docker/docker/api/types/container"
 	"github.com/docker/go-connections/nat"
-	"github.com/moby/moby/api/types/container"
-	"github.com/moby/moby/client"
 	"github.com/yusing/godoxy/agent/pkg/agent"
 	"github.com/yusing/godoxy/internal/serialization"
 	"github.com/yusing/godoxy/internal/types"
@@ -93,24 +92,24 @@ func IsBlacklisted(c *types.Container) bool {
 }
 
 func UpdatePorts(c *types.Container) error {
-	dockerClient, err := NewClient(c.DockerHost)
+	client, err := NewClient(c.DockerHost)
 	if err != nil {
 		return err
 	}
-	defer dockerClient.Close()
+	defer client.Close()
 
-	inspect, err := dockerClient.ContainerInspect(context.Background(), c.ContainerID, client.ContainerInspectOptions{})
+	inspect, err := client.ContainerInspect(context.Background(), c.ContainerID)
 	if err != nil {
 		return err
 	}
 
-	for port := range inspect.Container.Config.ExposedPorts {
-		proto, portStr := nat.SplitProtoPort(port.String())
+	for port := range inspect.Config.ExposedPorts {
+		proto, portStr := nat.SplitProtoPort(string(port))
 		portInt, _ := nat.ParsePort(portStr)
 		if portInt == 0 {
 			continue
 		}
-		c.PublicPortMapping[portInt] = container.PortSummary{
+		c.PublicPortMapping[portInt] = container.Port{
 			PublicPort:  uint16(portInt), //nolint:gosec
 			PrivatePort: uint16(portInt), //nolint:gosec
 			Type:        proto,
@@ -208,8 +207,8 @@ func setPrivateHostname(c *types.Container, helper containerHelper) {
 	}
 	if c.Network != "" {
 		v, ok := helper.NetworkSettings.Networks[c.Network]
-		if ok && v.IPAddress.IsValid() {
-			c.PrivateHostname = v.IPAddress.String()
+		if ok {
+			c.PrivateHostname = v.IPAddress
 			return
 		}
 		// try {project_name}_{network_name}
@@ -217,9 +216,9 @@ func setPrivateHostname(c *types.Container, helper containerHelper) {
 			oldNetwork, newNetwork := c.Network, fmt.Sprintf("%s_%s", proj, c.Network)
 			if newNetwork != oldNetwork {
 				v, ok = helper.NetworkSettings.Networks[newNetwork]
-				if ok && v.IPAddress.IsValid() {
+				if ok {
 					c.Network = newNetwork // update network to the new one
-					c.PrivateHostname = v.IPAddress.String()
+					c.PrivateHostname = v.IPAddress
 					return
 				}
 			}
@@ -230,9 +229,9 @@ func setPrivateHostname(c *types.Container, helper containerHelper) {
 	}
 	// fallback to first network if no network is specified
 	for k, v := range helper.NetworkSettings.Networks {
-		if v.IPAddress.IsValid() {
+		if v.IPAddress != "" {
 			c.Network = k // update network to the first network
-			c.PrivateHostname = v.IPAddress.String()
+			c.PrivateHostname = v.IPAddress
 			return
 		}
 	}

internal/docker/container_helper.go

@@ -3,7 +3,7 @@ package docker
 import (
 	"strings"
 
-	"github.com/moby/moby/api/types/container"
+	"github.com/docker/docker/api/types/container"
 	"github.com/yusing/ds/ordered"
 	"github.com/yusing/godoxy/internal/types"
 	strutils "github.com/yusing/goutils/strings"

internal/docker/container_test.go

@@ -3,7 +3,7 @@ package docker
 import (
 	"testing"
 
-	"github.com/moby/moby/api/types/container"
+	"github.com/docker/docker/api/types/container"
 	expect "github.com/yusing/goutils/testing"
 )
 

internal/docker/list_containers.go

@@ -3,11 +3,11 @@ package docker
 import (
 	"context"
 
-	"github.com/moby/moby/api/types/container"
-	"github.com/moby/moby/client"
+	"github.com/docker/docker/api/types/container"
+	"github.com/docker/docker/client"
 )
 
-var listOptions = client.ContainerListOptions{
+var listOptions = container.ListOptions{
 	// created|restarting|running|removing|paused|exited|dead
 	// Filters: filters.NewArgs(
 	// 	filters.Arg("status", "created"),
@@ -30,7 +30,7 @@ func ListContainers(ctx context.Context, clientHost string) ([]container.Summary
 	if err != nil {
 		return nil, err
 	}
-	return containers.Items, nil
+	return containers, nil
 }
 
 func IsErrConnectionFailed(err error) bool {

internal/idlewatcher/provider/docker.go

@@ -3,8 +3,7 @@ package provider
 import (
 	"context"
 
-	"github.com/moby/moby/api/types/container"
-	"github.com/moby/moby/client"
+	"github.com/docker/docker/api/types/container"
 	"github.com/yusing/godoxy/internal/docker"
 	idlewatcher "github.com/yusing/godoxy/internal/idlewatcher/types"
 	"github.com/yusing/godoxy/internal/types"
@@ -18,7 +17,7 @@ type DockerProvider struct {
 	containerID string
 }
 
-var startOptions = client.ContainerStartOptions{}
+var startOptions = container.StartOptions{}
 
 func NewDockerProvider(dockerHost, containerID string) (idlewatcher.Provider, error) {
 	client, err := docker.NewClient(dockerHost)
@@ -33,41 +32,34 @@ func NewDockerProvider(dockerHost, containerID string) (idlewatcher.Provider, er
 }
 
 func (p *DockerProvider) ContainerPause(ctx context.Context) error {
-	_, err := p.client.ContainerPause(ctx, p.containerID, client.ContainerPauseOptions{})
-	return err
+	return p.client.ContainerPause(ctx, p.containerID)
 }
 
 func (p *DockerProvider) ContainerUnpause(ctx context.Context) error {
-	_, err := p.client.ContainerUnpause(ctx, p.containerID, client.ContainerUnpauseOptions{})
-	return err
+	return p.client.ContainerUnpause(ctx, p.containerID)
 }
 
 func (p *DockerProvider) ContainerStart(ctx context.Context) error {
-	_, err := p.client.ContainerStart(ctx, p.containerID, startOptions)
-	return err
+	return p.client.ContainerStart(ctx, p.containerID, startOptions)
 }
 
 func (p *DockerProvider) ContainerStop(ctx context.Context, signal types.ContainerSignal, timeout int) error {
-	_, err := p.client.ContainerStop(ctx, p.containerID, client.ContainerStopOptions{
+	return p.client.ContainerStop(ctx, p.containerID, container.StopOptions{
 		Signal:  string(signal),
 		Timeout: &timeout,
 	})
-	return err
 }
 
 func (p *DockerProvider) ContainerKill(ctx context.Context, signal types.ContainerSignal) error {
-	_, err := p.client.ContainerKill(ctx, p.containerID, client.ContainerKillOptions{
-		Signal: string(signal),
-	})
-	return err
+	return p.client.ContainerKill(ctx, p.containerID, string(signal))
 }
 
 func (p *DockerProvider) ContainerStatus(ctx context.Context) (idlewatcher.ContainerStatus, error) {
-	status, err := p.client.ContainerInspect(ctx, p.containerID, client.ContainerInspectOptions{})
+	status, err := p.client.ContainerInspect(ctx, p.containerID)
 	if err != nil {
 		return idlewatcher.ContainerStatusError, err
 	}
-	switch status.Container.State.Status {
+	switch status.State.Status {
 	case container.StateRunning:
 		return idlewatcher.ContainerStatusRunning, nil
 	case container.StateExited, container.StateDead, container.StateRestarting:
@@ -75,12 +67,12 @@ func (p *DockerProvider) ContainerStatus(ctx context.Context) (idlewatcher.Conta
 	case container.StatePaused:
 		return idlewatcher.ContainerStatusPaused, nil
 	}
-	return idlewatcher.ContainerStatusError, idlewatcher.ErrUnexpectedContainerStatus.Subject(string(status.Container.State.Status))
+	return idlewatcher.ContainerStatusError, idlewatcher.ErrUnexpectedContainerStatus.Subject(status.State.Status)
 }
 
 func (p *DockerProvider) Watch(ctx context.Context) (eventCh <-chan watcher.Event, errCh <-chan gperr.Error) {
 	return p.watcher.EventsWithOptions(ctx, watcher.DockerListOptions{
-		Filters: watcher.NewDockerFilters(
+		Filters: watcher.NewDockerFilter(
 			watcher.DockerFilterContainer,
 			watcher.DockerFilterContainerNameID(p.containerID),
 			watcher.DockerFilterStart,

internal/route/provider/docker_labels_test.go

@@ -3,8 +3,8 @@ package provider
 import (
 	"testing"
 
+	"github.com/docker/docker/api/types/container"
 	"github.com/goccy/go-yaml"
-	"github.com/moby/moby/api/types/container"
 	"github.com/yusing/godoxy/internal/docker"
 	expect "github.com/yusing/goutils/testing"
 
@@ -25,7 +25,7 @@ func TestParseDockerLabels(t *testing.T) {
 			Names:  []string{"container"},
 			Labels: labels,
 			State:  "running",
-			Ports: []container.PortSummary{
+			Ports: []container.Port{
 				{Type: "tcp", PrivatePort: 1234, PublicPort: 1234},
 			},
 		}, "/var/run/docker.sock"),

internal/route/provider/docker_test.go

@@ -1,13 +1,12 @@
 package provider
 
 import (
-	"net/netip"
 	"testing"
 	"time"
 
-	"github.com/moby/moby/api/types/container"
-	"github.com/moby/moby/api/types/network"
-	"github.com/moby/moby/client"
+	"github.com/docker/docker/api/types/container"
+	"github.com/docker/docker/api/types/network"
+	"github.com/docker/docker/client"
 	D "github.com/yusing/godoxy/internal/docker"
 	"github.com/yusing/godoxy/internal/route"
 	routeTypes "github.com/yusing/godoxy/internal/route/types"
@@ -275,7 +274,7 @@ func TestPrivateIPLocalhost(t *testing.T) {
 		NetworkSettings: &container.NetworkSettingsSummary{
 			Networks: map[string]*network.EndpointSettings{
 				"network": {
-					IPAddress: netip.MustParseAddr(testDockerIP),
+					IPAddress: testDockerIP,
 				},
 			},
 		},
@@ -293,7 +292,7 @@ func TestPrivateIPRemote(t *testing.T) {
 		NetworkSettings: &container.NetworkSettingsSummary{
 			Networks: map[string]*network.EndpointSettings{
 				"network": {
-					IPAddress: netip.MustParseAddr(testDockerIP),
+					IPAddress: testDockerIP,
 				},
 			},
 		},
@@ -315,11 +314,11 @@ func TestStreamDefaultValues(t *testing.T) {
 		NetworkSettings: &container.NetworkSettingsSummary{
 			Networks: map[string]*network.EndpointSettings{
 				"network": {
-					IPAddress: netip.MustParseAddr(privIP),
+					IPAddress: privIP,
 				},
 			},
 		},
-		Ports: []container.PortSummary{
+		Ports: []container.Port{
 			{Type: "udp", PrivatePort: privPort, PublicPort: pubPort},
 		},
 	}
@@ -372,7 +371,7 @@ func TestImplicitExcludeDatabase(t *testing.T) {
 	t.Run("exposed port detection", func(t *testing.T) {
 		r, ok := makeRoutes(&container.Summary{
 			Names: dummyNames,
-			Ports: []container.PortSummary{
+			Ports: []container.Port{
 				{Type: "tcp", PrivatePort: 5432, PublicPort: 5432},
 			},
 		})["a"]

internal/route/provider/provider.go

@@ -8,7 +8,7 @@ import (
 	"sync"
 	"time"
 
-	"github.com/moby/moby/client"
+	"github.com/docker/docker/client"
 	"github.com/rs/zerolog"
 	"github.com/yusing/godoxy/agent/pkg/agent"
 	"github.com/yusing/godoxy/internal/common"

internal/route/route.go

@@ -13,6 +13,7 @@ import (
 	"sync"
 	"time"
 
+	"github.com/docker/docker/api/types/container"
 	"github.com/rs/zerolog/log"
 	"github.com/yusing/godoxy/agent/pkg/agent"
 	"github.com/yusing/godoxy/internal/docker"
@@ -877,7 +878,7 @@ var preferredPortOrder = []int{
 	8443,
 }
 
-func preferredPort(portMapping types.PortMapping) (res int) {
+func preferredPort(portMapping map[int]container.Port) (res int) {
 	for _, port := range preferredPortOrder {
 		if _, ok := portMapping[port]; ok {
 			return port

internal/route/route_test.go

@@ -3,6 +3,7 @@ package route
 import (
 	"testing"
 
+	"github.com/docker/docker/api/types/container"
 	"github.com/yusing/godoxy/internal/common"
 	route "github.com/yusing/godoxy/internal/route/types"
 	"github.com/yusing/godoxy/internal/types"
@@ -136,7 +137,7 @@ func TestRouteValidate(t *testing.T) {
 }
 
 func TestPreferredPort(t *testing.T) {
-	ports := types.PortMapping{
+	ports := map[int]container.Port{
 		22:   {PrivatePort: 22},
 		1000: {PrivatePort: 1000},
 		3000: {PrivatePort: 80},

internal/types/docker.go

@@ -2,7 +2,7 @@ package types
 
 import (
 	"github.com/bytedance/sonic"
-	"github.com/moby/moby/api/types/container"
+	"github.com/docker/docker/api/types/container"
 	"github.com/yusing/ds/ordered"
 	"github.com/yusing/godoxy/agent/pkg/agent"
 	"github.com/yusing/godoxy/internal/utils"
@@ -12,7 +12,7 @@ import (
 type (
 	LabelMap = map[string]any
 
-	PortMapping = map[int]container.PortSummary
+	PortMapping = map[int]container.Port
 	Container   struct {
 		_ utils.NoCopy
 

internal/watcher/docker_watcher.go

@@ -5,8 +5,9 @@ import (
 	"errors"
 	"time"
 
-	dockerEvents "github.com/moby/moby/api/types/events"
-	"github.com/moby/moby/client"
+	dockerEvents "github.com/docker/docker/api/types/events"
+	"github.com/docker/docker/api/types/filters"
+	"github.com/docker/docker/client"
 	"github.com/rs/zerolog/log"
 	"github.com/yusing/godoxy/internal/docker"
 	"github.com/yusing/godoxy/internal/watcher/events"
@@ -15,42 +16,23 @@ import (
 
 type (
 	DockerWatcher     string
-	DockerListOptions = client.EventsListOptions
-	DockerFilters     = client.Filters
+	DockerListOptions = dockerEvents.ListOptions
 )
 
-type DockerFilter struct {
-	Term   string
-	Values []string
-}
-
-func NewDockerFilter(term string, values ...string) DockerFilter {
-	return DockerFilter{
-		Term:   term,
-		Values: values,
-	}
-}
-
-func NewDockerFilters(filters ...DockerFilter) client.Filters {
-	f := make(client.Filters, len(filters))
-	for _, filter := range filters {
-		f.Add(filter.Term, filter.Values...)
-	}
-	return f
-}
-
 // https://docs.docker.com/reference/api/engine/version/v1.47/#tag/System/operation/SystemPingHead
 var (
-	DockerFilterContainer = NewDockerFilter("type", string(dockerEvents.ContainerEventType))
-	DockerFilterStart     = NewDockerFilter("event", string(dockerEvents.ActionStart))
-	DockerFilterStop      = NewDockerFilter("event", string(dockerEvents.ActionStop))
-	DockerFilterDie       = NewDockerFilter("event", string(dockerEvents.ActionDie))
-	DockerFilterDestroy   = NewDockerFilter("event", string(dockerEvents.ActionDestroy))
-	DockerFilterKill      = NewDockerFilter("event", string(dockerEvents.ActionKill))
-	DockerFilterPause     = NewDockerFilter("event", string(dockerEvents.ActionPause))
-	DockerFilterUnpause   = NewDockerFilter("event", string(dockerEvents.ActionUnPause))
+	DockerFilterContainer = filters.Arg("type", string(dockerEvents.ContainerEventType))
+	DockerFilterStart     = filters.Arg("event", string(dockerEvents.ActionStart))
+	DockerFilterStop      = filters.Arg("event", string(dockerEvents.ActionStop))
+	DockerFilterDie       = filters.Arg("event", string(dockerEvents.ActionDie))
+	DockerFilterDestroy   = filters.Arg("event", string(dockerEvents.ActionDestroy))
+	DockerFilterKill      = filters.Arg("event", string(dockerEvents.ActionKill))
+	DockerFilterPause     = filters.Arg("event", string(dockerEvents.ActionPause))
+	DockerFilterUnpause   = filters.Arg("event", string(dockerEvents.ActionUnPause))
 
-	optionsDefault = DockerListOptions{Filters: NewDockerFilters(
+	NewDockerFilter = filters.NewArgs
+
+	optionsDefault = DockerListOptions{Filters: NewDockerFilter(
 		DockerFilterContainer,
 		DockerFilterStart,
 		// DockerFilterStop,
@@ -69,8 +51,8 @@ var (
 	}
 )
 
-func DockerFilterContainerNameID(nameOrID string) DockerFilter {
-	return NewDockerFilter("container", nameOrID)
+func DockerFilterContainerNameID(nameOrID string) filters.KeyValuePair {
+	return filters.Arg("container", nameOrID)
 }
 
 func NewDockerWatcher(host string) DockerWatcher {
@@ -98,15 +80,15 @@ func (w DockerWatcher) EventsWithOptions(ctx context.Context, options DockerList
 			client.Close()
 		}()
 
-		chs := client.Events(ctx, options)
+		cEventCh, cErrCh := client.Events(ctx, options)
 		defer log.Debug().Str("host", client.Address()).Msg("docker watcher closed")
 		for {
 			select {
 			case <-ctx.Done():
 				return
-			case msg := <-chs.Messages:
+			case msg := <-cEventCh:
 				w.handleEvent(msg, eventCh)
-			case err := <-chs.Err:
+			case err := <-cErrCh:
 				if err == nil {
 					continue
 				}
@@ -135,7 +117,7 @@ func (w DockerWatcher) EventsWithOptions(ctx context.Context, options DockerList
 				// connection successful, trigger reload (reload routes)
 				eventCh <- reloadTrigger
 				// reopen event channel
-				chs = client.Events(ctx, options)
+				cEventCh, cErrCh = client.Events(ctx, options)
 			}
 		}
 	}()

internal/watcher/events/events.go

@@ -3,7 +3,7 @@ package events
 import (
 	"fmt"
 
-	dockerEvents "github.com/moby/moby/api/types/events"
+	dockerEvents "github.com/docker/docker/api/types/events"
 )
 
 type (

internal/watcher/health/monitor/docker.go

@@ -5,8 +5,7 @@ import (
 	"net/url"
 
 	"github.com/bytedance/sonic"
-	"github.com/moby/moby/api/types/container"
-	"github.com/moby/moby/client"
+	"github.com/docker/docker/api/types/container"
 	"github.com/rs/zerolog/log"
 	"github.com/yusing/godoxy/internal/docker"
 	"github.com/yusing/godoxy/internal/types"
@@ -89,7 +88,7 @@ func (mon *DockerHealthMonitor) CheckHealth() (types.HealthCheckResult, error) {
 	defer cancel()
 
 	// the actual inspect response is intercepted and returned as RequestInterceptedError
-	_, err := mon.client.ContainerInspect(ctx, mon.containerID, client.ContainerInspectOptions{})
+	_, err := mon.client.ContainerInspect(ctx, mon.containerID)
 
 	var interceptedErr *httputils.RequestInterceptedError
 	if !httputils.AsRequestInterceptedError(err, &interceptedErr) {
@@ -112,7 +111,7 @@ func (mon *DockerHealthMonitor) CheckHealth() (types.HealthCheckResult, error) {
 		mon.numDockerFailures = 0
 		return types.HealthCheckResult{
 			Healthy: false,
-			Detail:  "container is " + string(status),
+			Detail:  "container is " + status,
 		}, nil
 	case "created":
 		mon.numDockerFailures = 0