feat: 使用docker v29版本客户端

internal/data/container.go

@@ -1,40 +1,43 @@
 package data
 
 import (
+	"context"
 	"fmt"
 	"slices"
 	"strings"
 	"time"
 
-	"github.com/go-resty/resty/v2"
+	"github.com/moby/moby/client"
 
 	"github.com/acepanel/panel/internal/biz"
 	"github.com/acepanel/panel/internal/http/request"
 	"github.com/acepanel/panel/pkg/shell"
 	"github.com/acepanel/panel/pkg/types"
-	"github.com/acepanel/panel/pkg/types/docker/container"
 )
 
-type containerRepo struct {
-	client *resty.Client
-}
+type containerRepo struct{}
 
 func NewContainerRepo() biz.ContainerRepo {
-	return &containerRepo{
-		client: getDockerClient("/var/run/docker.sock"),
-	}
+	return &containerRepo{}
 }
 
 // ListAll 列出所有容器
 func (r *containerRepo) ListAll() ([]types.Container, error) {
-	var resp []container.Container
-	_, err := r.client.R().SetResult(&resp).SetQueryParam("all", "true").Get("/containers/json")
+	apiClient, err := getDockerClient("/var/run/docker.sock")
+	if err != nil {
+		return nil, err
+	}
+	defer func(apiClient *client.Client) { _ = apiClient.Close() }(apiClient)
+
+	resp, err := apiClient.ContainerList(context.Background(), client.ContainerListOptions{
+		All: true,
+	})
 	if err != nil {
 		return nil, err
 	}
 
 	var containers []types.Container
-	for _, item := range resp {
+	for _, item := range resp.Items {
 		ports := make([]types.ContainerPort, 0)
 		for _, port := range item.Ports {
 			ports = append(ports, types.ContainerPort{
@@ -56,7 +59,7 @@ func (r *containerRepo) ListAll() ([]types.Container, error) {
 			ImageID:   item.ImageID,
 			Command:   item.Command,
 			CreatedAt: time.Unix(item.Created, 0),
-			State:     item.State,
+			State:     string(item.State),
 			Status:    item.Status,
 			Ports:     ports,
 			Labels:    types.MapToKV(item.Labels),
@@ -93,8 +96,8 @@ func (r *containerRepo) Create(req *request.ContainerCreate) (string, error) {
 	} else {
 		for _, port := range req.Ports {
 			sb.WriteString(" -p ")
-			if port.Host != "" {
-				sb.WriteString(fmt.Sprintf("%s:", port.Host))
+			if port.Host.IsValid() {
+				sb.WriteString(fmt.Sprintf("%s:", port.Host.String()))
 			}
 			if port.HostStart == port.HostEnd || port.ContainerStart == port.ContainerEnd {
 				sb.WriteString(fmt.Sprintf("%d:%d/%s", port.HostStart, port.ContainerStart, port.Protocol))

internal/data/container_image.go

@@ -1,41 +1,44 @@
 package data
 
 import (
+	"context"
 	"fmt"
 	"slices"
 	"strings"
 	"time"
 
-	"github.com/go-resty/resty/v2"
+	"github.com/moby/moby/client"
 
 	"github.com/acepanel/panel/internal/biz"
 	"github.com/acepanel/panel/internal/http/request"
 	"github.com/acepanel/panel/pkg/shell"
 	"github.com/acepanel/panel/pkg/tools"
 	"github.com/acepanel/panel/pkg/types"
-	"github.com/acepanel/panel/pkg/types/docker/image"
 )
 
-type containerImageRepo struct {
-	client *resty.Client
-}
+type containerImageRepo struct{}
 
 func NewContainerImageRepo() biz.ContainerImageRepo {
-	return &containerImageRepo{
-		client: getDockerClient("/var/run/docker.sock"),
-	}
+	return &containerImageRepo{}
 }
 
 // List 列出镜像
 func (r *containerImageRepo) List() ([]types.ContainerImage, error) {
-	var resp []image.Image
-	_, err := r.client.R().SetResult(&resp).SetQueryParam("all", "true").Get("/images/json")
+	apiClient, err := getDockerClient("/var/run/docker.sock")
+	if err != nil {
+		return nil, err
+	}
+	defer func(apiClient *client.Client) { _ = apiClient.Close() }(apiClient)
+
+	resp, err := apiClient.ImageList(context.Background(), client.ImageListOptions{
+		All: true,
+	})
 	if err != nil {
 		return nil, err
 	}
 
 	var images []types.ContainerImage
-	for _, item := range resp {
+	for _, item := range resp.Items {
 		images = append(images, types.ContainerImage{
 			ID:          item.ID,
 			Containers:  item.Containers,

internal/data/container_network.go

@@ -1,40 +1,41 @@
 package data
 
 import (
+	"context"
 	"fmt"
 	"slices"
 	"strings"
 	"time"
 
-	"github.com/go-resty/resty/v2"
+	"github.com/moby/moby/client"
 
 	"github.com/acepanel/panel/internal/biz"
 	"github.com/acepanel/panel/internal/http/request"
 	"github.com/acepanel/panel/pkg/shell"
 	"github.com/acepanel/panel/pkg/types"
-	"github.com/acepanel/panel/pkg/types/docker/network"
 )
 
-type containerNetworkRepo struct {
-	client *resty.Client
-}
+type containerNetworkRepo struct{}
 
 func NewContainerNetworkRepo() biz.ContainerNetworkRepo {
-	return &containerNetworkRepo{
-		client: getDockerClient("/var/run/docker.sock"),
-	}
+	return &containerNetworkRepo{}
 }
 
 // List 列出网络
 func (r *containerNetworkRepo) List() ([]types.ContainerNetwork, error) {
-	var resp []network.Network
-	_, err := r.client.R().SetResult(&resp).Get("/networks")
+	apiClient, err := getDockerClient("/var/run/docker.sock")
+	if err != nil {
+		return nil, err
+	}
+	defer func(apiClient *client.Client) { _ = apiClient.Close() }(apiClient)
+
+	resp, err := apiClient.NetworkList(context.Background(), client.NetworkListOptions{})
 	if err != nil {
 		return nil, err
 	}
 
 	var networks []types.ContainerNetwork
-	for _, item := range resp {
+	for _, item := range resp.Items {
 		ipamConfigs := make([]types.ContainerNetworkIPAMConfig, 0)
 		for _, ipam := range item.IPAM.Config {
 			ipamConfigs = append(ipamConfigs, types.ContainerNetworkIPAMConfig{

internal/data/container_volume.go

@@ -1,47 +1,49 @@
 package data
 
 import (
+	"context"
 	"fmt"
 	"slices"
 	"strings"
 	"time"
 
-	"github.com/go-resty/resty/v2"
+	"github.com/moby/moby/client"
 
 	"github.com/acepanel/panel/internal/biz"
 	"github.com/acepanel/panel/internal/http/request"
 	"github.com/acepanel/panel/pkg/shell"
 	"github.com/acepanel/panel/pkg/tools"
 	"github.com/acepanel/panel/pkg/types"
-	"github.com/acepanel/panel/pkg/types/docker/volume"
 )
 
-type containerVolumeRepo struct {
-	client *resty.Client
-}
+type containerVolumeRepo struct{}
 
 func NewContainerVolumeRepo() biz.ContainerVolumeRepo {
-	return &containerVolumeRepo{
-		client: getDockerClient("/var/run/docker.sock"),
-	}
+	return &containerVolumeRepo{}
 }
 
 // List 列出存储卷
 func (r *containerVolumeRepo) List() ([]types.ContainerVolume, error) {
-	var resp volume.ListResponse
-	_, err := r.client.R().SetResult(&resp).Get("/volumes")
+	apiClient, err := getDockerClient("/var/run/docker.sock")
+	if err != nil {
+		return nil, err
+	}
+	defer func(apiClient *client.Client) { _ = apiClient.Close() }(apiClient)
+
+	resp, err := apiClient.VolumeList(context.Background(), client.VolumeListOptions{})
 	if err != nil {
 		return nil, err
 	}
 
 	var volumes []types.ContainerVolume
-	for _, item := range resp.Volumes {
+	for _, item := range resp.Items {
+		createdAt, _ := time.Parse(time.RFC3339Nano, item.CreatedAt)
 		volumes = append(volumes, types.ContainerVolume{
 			Name:       item.Name,
 			Driver:     item.Driver,
 			Scope:      item.Scope,
 			MountPoint: item.Mountpoint,
-			CreatedAt:  item.CreatedAt,
+			CreatedAt:  createdAt,
 			Labels:     types.MapToKV(item.Labels),
 			Options:    types.MapToKV(item.Options),
 			RefCount:   item.UsageData.RefCount,

internal/data/helper.go

@@ -1,23 +1,16 @@
 package data
 
 import (
-	"context"
-	"net"
-	"net/http"
-	"time"
+	"fmt"
 
-	"github.com/go-resty/resty/v2"
+	"github.com/moby/moby/client"
 )
 
-func getDockerClient(sock string) *resty.Client {
-	client := resty.New()
-	client.SetTimeout(1 * time.Minute)
-	client.SetRetryCount(2)
-	client.SetTransport(&http.Transport{
-		DialContext: func(ctx context.Context, _ string, _ string) (net.Conn, error) {
-			return (&net.Dialer{}).DialContext(ctx, "unix", sock)
-		},
-	})
-	client.SetBaseURL("http://d/v1.40")
-	return client
+func getDockerClient(sock string) (*client.Client, error) {
+	apiClient, err := client.New(client.WithHost(fmt.Sprintf("unix://%s", sock)), client.WithAPIVersionNegotiation())
+	if err != nil {
+		return nil, err
+	}
+
+	return apiClient, nil
 }