2022-10-08 10:32:02 +00:00
|
|
|
package service
|
|
|
|
|
|
|
|
import (
|
|
|
|
"context"
|
|
|
|
"encoding/json"
|
2022-10-11 06:20:51 +00:00
|
|
|
"fmt"
|
2023-03-28 11:02:11 +00:00
|
|
|
"io"
|
2023-05-23 07:43:51 +00:00
|
|
|
"os"
|
2023-03-09 10:42:17 +00:00
|
|
|
"os/exec"
|
2023-08-02 08:47:30 +00:00
|
|
|
"path"
|
2023-07-12 06:33:19 +00:00
|
|
|
"path/filepath"
|
2022-12-06 10:24:26 +00:00
|
|
|
"sort"
|
2022-10-12 10:55:47 +00:00
|
|
|
"strconv"
|
2022-10-08 10:32:02 +00:00
|
|
|
"strings"
|
2023-04-25 14:06:17 +00:00
|
|
|
"sync"
|
2022-10-08 10:32:02 +00:00
|
|
|
"time"
|
|
|
|
|
2022-10-18 10:39:45 +00:00
|
|
|
"github.com/1Panel-dev/1Panel/backend/app/dto"
|
2023-03-13 15:49:31 +00:00
|
|
|
"github.com/1Panel-dev/1Panel/backend/buserr"
|
2022-10-18 10:39:45 +00:00
|
|
|
"github.com/1Panel-dev/1Panel/backend/constant"
|
2022-12-28 10:35:53 +00:00
|
|
|
"github.com/1Panel-dev/1Panel/backend/global"
|
2023-07-17 08:34:29 +00:00
|
|
|
"github.com/1Panel-dev/1Panel/backend/utils/cmd"
|
2023-03-13 15:49:31 +00:00
|
|
|
"github.com/1Panel-dev/1Panel/backend/utils/common"
|
2022-10-18 10:39:45 +00:00
|
|
|
"github.com/1Panel-dev/1Panel/backend/utils/docker"
|
2022-10-08 10:32:02 +00:00
|
|
|
"github.com/docker/docker/api/types"
|
2022-10-12 10:55:47 +00:00
|
|
|
"github.com/docker/docker/api/types/container"
|
2022-10-11 06:20:51 +00:00
|
|
|
"github.com/docker/docker/api/types/filters"
|
|
|
|
"github.com/docker/docker/api/types/network"
|
2023-03-28 11:02:11 +00:00
|
|
|
"github.com/docker/docker/client"
|
2022-10-12 10:55:47 +00:00
|
|
|
"github.com/docker/go-connections/nat"
|
2023-06-13 15:04:12 +00:00
|
|
|
"github.com/gorilla/websocket"
|
2022-10-12 10:55:47 +00:00
|
|
|
v1 "github.com/opencontainers/image-spec/specs-go/v1"
|
2023-06-15 12:44:13 +00:00
|
|
|
"github.com/shirou/gopsutil/v3/cpu"
|
|
|
|
"github.com/shirou/gopsutil/v3/mem"
|
2022-10-08 10:32:02 +00:00
|
|
|
)
|
|
|
|
|
|
|
|
type ContainerService struct{}
|
|
|
|
|
|
|
|
type IContainerService interface {
|
|
|
|
Page(req dto.PageContainer) (int64, interface{}, error)
|
2023-06-28 06:30:11 +00:00
|
|
|
List() ([]string, error)
|
2023-02-07 10:48:32 +00:00
|
|
|
PageNetwork(req dto.SearchWithPage) (int64, interface{}, error)
|
2023-07-07 15:17:05 +00:00
|
|
|
ListNetwork() ([]dto.Options, error)
|
2023-02-07 10:48:32 +00:00
|
|
|
PageVolume(req dto.SearchWithPage) (int64, interface{}, error)
|
2022-10-12 10:55:47 +00:00
|
|
|
ListVolume() ([]dto.Options, error)
|
2023-02-07 10:48:32 +00:00
|
|
|
PageCompose(req dto.SearchWithPage) (int64, interface{}, error)
|
2023-03-20 10:16:26 +00:00
|
|
|
CreateCompose(req dto.ComposeCreate) (string, error)
|
2022-10-17 08:04:39 +00:00
|
|
|
ComposeOperation(req dto.ComposeOperation) error
|
2023-06-15 03:00:11 +00:00
|
|
|
ContainerCreate(req dto.ContainerOperate) error
|
|
|
|
ContainerUpdate(req dto.ContainerOperate) error
|
2023-06-16 09:54:11 +00:00
|
|
|
ContainerUpgrade(req dto.ContainerUpgrade) error
|
2023-06-15 03:00:11 +00:00
|
|
|
ContainerInfo(req dto.OperationWithName) (*dto.ContainerOperate, error)
|
2023-07-06 10:04:22 +00:00
|
|
|
ContainerListStats() ([]dto.ContainerListStats, error)
|
2023-10-07 06:30:46 +00:00
|
|
|
LoadResourceLimit() (*dto.ResourceLimit, error)
|
2023-05-23 07:43:51 +00:00
|
|
|
ContainerLogClean(req dto.OperationWithName) error
|
2022-10-08 10:32:02 +00:00
|
|
|
ContainerOperation(req dto.ContainerOperation) error
|
2023-06-13 15:04:12 +00:00
|
|
|
ContainerLogs(wsConn *websocket.Conn, container, since, tail string, follow bool) error
|
2023-07-06 10:04:22 +00:00
|
|
|
ContainerStats(id string) (*dto.ContainerStats, error)
|
2022-10-11 11:47:16 +00:00
|
|
|
Inspect(req dto.InspectReq) (string, error)
|
2022-10-11 06:20:51 +00:00
|
|
|
DeleteNetwork(req dto.BatchDelete) error
|
2023-05-30 07:30:57 +00:00
|
|
|
CreateNetwork(req dto.NetworkCreate) error
|
2022-10-11 06:20:51 +00:00
|
|
|
DeleteVolume(req dto.BatchDelete) error
|
2023-05-30 07:30:57 +00:00
|
|
|
CreateVolume(req dto.VolumeCreate) error
|
2023-03-28 10:00:06 +00:00
|
|
|
TestCompose(req dto.ComposeCreate) (bool, error)
|
|
|
|
ComposeUpdate(req dto.ComposeUpdate) error
|
2023-05-23 11:00:06 +00:00
|
|
|
Prune(req dto.ContainerPrune) (dto.ContainerPruneReport, error)
|
2023-08-02 08:47:30 +00:00
|
|
|
|
2023-08-09 03:18:12 +00:00
|
|
|
LoadContainerLogs(req dto.OperationWithNameAndType) string
|
2023-09-28 02:56:16 +00:00
|
|
|
ComposeLogs(wsConn *websocket.Conn, composePath, since, tail string, follow bool) error
|
2022-10-08 10:32:02 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
func NewIContainerService() IContainerService {
|
|
|
|
return &ContainerService{}
|
|
|
|
}
|
2022-10-11 06:20:51 +00:00
|
|
|
|
2022-10-08 10:32:02 +00:00
|
|
|
func (u *ContainerService) Page(req dto.PageContainer) (int64, interface{}, error) {
|
|
|
|
var (
|
2023-06-29 10:40:12 +00:00
|
|
|
records []types.Container
|
|
|
|
list []types.Container
|
2022-10-08 10:32:02 +00:00
|
|
|
)
|
|
|
|
client, err := docker.NewDockerClient()
|
|
|
|
if err != nil {
|
|
|
|
return 0, nil, err
|
|
|
|
}
|
2022-10-17 08:04:39 +00:00
|
|
|
options := types.ContainerListOptions{All: true}
|
|
|
|
if len(req.Filters) != 0 {
|
|
|
|
options.Filters = filters.NewArgs()
|
|
|
|
options.Filters.Add("label", req.Filters)
|
|
|
|
}
|
|
|
|
list, err = client.ContainerList(context.Background(), options)
|
2022-10-08 10:32:02 +00:00
|
|
|
if err != nil {
|
|
|
|
return 0, nil, err
|
|
|
|
}
|
2023-02-07 10:48:32 +00:00
|
|
|
if len(req.Name) != 0 {
|
2023-05-30 07:30:57 +00:00
|
|
|
length, count := len(list), 0
|
|
|
|
for count < length {
|
2023-02-07 10:48:32 +00:00
|
|
|
if !strings.Contains(list[count].Names[0][1:], req.Name) {
|
|
|
|
list = append(list[:count], list[(count+1):]...)
|
2023-05-30 07:30:57 +00:00
|
|
|
length--
|
2023-02-07 10:48:32 +00:00
|
|
|
} else {
|
|
|
|
count++
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
2023-06-29 10:40:12 +00:00
|
|
|
switch req.OrderBy {
|
|
|
|
case "name":
|
|
|
|
sort.Slice(list, func(i, j int) bool {
|
|
|
|
if req.Order == constant.OrderAsc {
|
|
|
|
return list[i].Names[0][1:] < list[j].Names[0][1:]
|
|
|
|
}
|
|
|
|
return list[i].Names[0][1:] > list[j].Names[0][1:]
|
|
|
|
})
|
|
|
|
case "state":
|
|
|
|
sort.Slice(list, func(i, j int) bool {
|
|
|
|
if req.Order == constant.OrderAsc {
|
|
|
|
return list[i].State < list[j].State
|
|
|
|
}
|
|
|
|
return list[i].State > list[j].State
|
|
|
|
})
|
|
|
|
default:
|
|
|
|
sort.Slice(list, func(i, j int) bool {
|
|
|
|
if req.Order == constant.OrderAsc {
|
|
|
|
return list[i].Created < list[j].Created
|
|
|
|
}
|
|
|
|
return list[i].Created > list[j].Created
|
|
|
|
})
|
|
|
|
}
|
|
|
|
|
2022-10-08 10:32:02 +00:00
|
|
|
total, start, end := len(list), (req.Page-1)*req.PageSize, req.Page*req.PageSize
|
|
|
|
if start > total {
|
|
|
|
records = make([]types.Container, 0)
|
|
|
|
} else {
|
|
|
|
if end >= total {
|
|
|
|
end = total
|
|
|
|
}
|
|
|
|
records = list[start:end]
|
|
|
|
}
|
|
|
|
|
2023-06-29 10:40:12 +00:00
|
|
|
backDatas := make([]dto.ContainerInfo, len(records))
|
|
|
|
for i := 0; i < len(records); i++ {
|
2023-07-06 10:04:22 +00:00
|
|
|
item := records[i]
|
|
|
|
IsFromCompose := false
|
|
|
|
if _, ok := item.Labels[composeProjectLabel]; ok {
|
|
|
|
IsFromCompose = true
|
|
|
|
}
|
|
|
|
IsFromApp := false
|
|
|
|
if created, ok := item.Labels[composeCreatedBy]; ok && created == "Apps" {
|
|
|
|
IsFromApp = true
|
|
|
|
}
|
2023-04-25 14:06:17 +00:00
|
|
|
|
2023-09-05 09:32:15 +00:00
|
|
|
ports := simplifyPort(item.Ports)
|
2023-07-06 10:04:22 +00:00
|
|
|
backDatas[i] = dto.ContainerInfo{
|
|
|
|
ContainerID: item.ID,
|
|
|
|
CreateTime: time.Unix(item.Created, 0).Format("2006-01-02 15:04:05"),
|
|
|
|
Name: item.Names[0][1:],
|
|
|
|
ImageId: strings.Split(item.ImageID, ":")[1],
|
|
|
|
ImageName: item.Image,
|
|
|
|
State: item.State,
|
|
|
|
RunTime: item.Status,
|
|
|
|
Ports: ports,
|
|
|
|
IsFromApp: IsFromApp,
|
|
|
|
IsFromCompose: IsFromCompose,
|
|
|
|
}
|
2023-09-04 07:51:10 +00:00
|
|
|
if item.NetworkSettings != nil && len(item.NetworkSettings.Networks) > 0 {
|
|
|
|
networks := make([]string, 0, len(item.NetworkSettings.Networks))
|
|
|
|
for key := range item.NetworkSettings.Networks {
|
2023-09-04 14:24:14 +00:00
|
|
|
networks = append(networks, item.NetworkSettings.Networks[key].IPAddress)
|
2023-09-04 07:51:10 +00:00
|
|
|
}
|
|
|
|
sort.Strings(networks)
|
|
|
|
backDatas[i].Network = networks
|
|
|
|
}
|
2023-04-25 14:06:17 +00:00
|
|
|
}
|
2022-10-08 10:32:02 +00:00
|
|
|
|
|
|
|
return int64(total), backDatas, nil
|
|
|
|
}
|
|
|
|
|
2023-06-28 06:30:11 +00:00
|
|
|
func (u *ContainerService) List() ([]string, error) {
|
|
|
|
client, err := docker.NewDockerClient()
|
|
|
|
if err != nil {
|
|
|
|
return nil, err
|
|
|
|
}
|
|
|
|
containers, err := client.ContainerList(context.Background(), types.ContainerListOptions{All: true})
|
|
|
|
if err != nil {
|
|
|
|
return nil, err
|
|
|
|
}
|
|
|
|
var datas []string
|
|
|
|
for _, container := range containers {
|
|
|
|
for _, name := range container.Names {
|
|
|
|
if len(name) != 0 {
|
2023-08-02 08:47:30 +00:00
|
|
|
datas = append(datas, strings.TrimPrefix(name, "/"))
|
2023-06-28 06:30:11 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
return datas, nil
|
|
|
|
}
|
|
|
|
|
2023-07-06 10:04:22 +00:00
|
|
|
func (u *ContainerService) ContainerListStats() ([]dto.ContainerListStats, error) {
|
|
|
|
client, err := docker.NewDockerClient()
|
|
|
|
if err != nil {
|
|
|
|
return nil, err
|
|
|
|
}
|
|
|
|
list, err := client.ContainerList(context.Background(), types.ContainerListOptions{All: true})
|
|
|
|
if err != nil {
|
|
|
|
return nil, err
|
|
|
|
}
|
|
|
|
var datas []dto.ContainerListStats
|
|
|
|
var wg sync.WaitGroup
|
|
|
|
wg.Add(len(list))
|
|
|
|
for i := 0; i < len(list); i++ {
|
|
|
|
go func(item types.Container) {
|
2023-09-21 09:34:22 +00:00
|
|
|
datas = append(datas, loadCpuAndMem(client, item.ID))
|
2023-07-06 10:04:22 +00:00
|
|
|
wg.Done()
|
|
|
|
}(list[i])
|
|
|
|
}
|
|
|
|
wg.Wait()
|
|
|
|
return datas, nil
|
|
|
|
}
|
|
|
|
|
2022-10-11 11:47:16 +00:00
|
|
|
func (u *ContainerService) Inspect(req dto.InspectReq) (string, error) {
|
|
|
|
client, err := docker.NewDockerClient()
|
|
|
|
if err != nil {
|
|
|
|
return "", err
|
|
|
|
}
|
|
|
|
var inspectInfo interface{}
|
|
|
|
switch req.Type {
|
|
|
|
case "container":
|
|
|
|
inspectInfo, err = client.ContainerInspect(context.Background(), req.ID)
|
2023-09-21 09:20:20 +00:00
|
|
|
case "image":
|
|
|
|
inspectInfo, _, err = client.ImageInspectWithRaw(context.Background(), req.ID)
|
2022-10-11 11:47:16 +00:00
|
|
|
case "network":
|
|
|
|
inspectInfo, err = client.NetworkInspect(context.TODO(), req.ID, types.NetworkInspectOptions{})
|
|
|
|
case "volume":
|
|
|
|
inspectInfo, err = client.VolumeInspect(context.TODO(), req.ID)
|
|
|
|
}
|
|
|
|
if err != nil {
|
|
|
|
return "", err
|
|
|
|
}
|
|
|
|
bytes, err := json.Marshal(inspectInfo)
|
|
|
|
if err != nil {
|
|
|
|
return "", err
|
|
|
|
}
|
|
|
|
return string(bytes), nil
|
|
|
|
}
|
|
|
|
|
2023-05-23 11:00:06 +00:00
|
|
|
func (u *ContainerService) Prune(req dto.ContainerPrune) (dto.ContainerPruneReport, error) {
|
|
|
|
report := dto.ContainerPruneReport{}
|
|
|
|
client, err := docker.NewDockerClient()
|
|
|
|
if err != nil {
|
|
|
|
return report, err
|
|
|
|
}
|
|
|
|
pruneFilters := filters.NewArgs()
|
|
|
|
if req.WithTagAll {
|
|
|
|
pruneFilters.Add("dangling", "false")
|
|
|
|
if req.PruneType != "image" {
|
|
|
|
pruneFilters.Add("until", "24h")
|
|
|
|
}
|
|
|
|
}
|
|
|
|
switch req.PruneType {
|
|
|
|
case "container":
|
|
|
|
rep, err := client.ContainersPrune(context.Background(), pruneFilters)
|
|
|
|
if err != nil {
|
|
|
|
return report, err
|
|
|
|
}
|
|
|
|
report.DeletedNumber = len(rep.ContainersDeleted)
|
|
|
|
report.SpaceReclaimed = int(rep.SpaceReclaimed)
|
|
|
|
case "image":
|
|
|
|
rep, err := client.ImagesPrune(context.Background(), pruneFilters)
|
|
|
|
if err != nil {
|
|
|
|
return report, err
|
|
|
|
}
|
|
|
|
report.DeletedNumber = len(rep.ImagesDeleted)
|
|
|
|
report.SpaceReclaimed = int(rep.SpaceReclaimed)
|
|
|
|
case "network":
|
|
|
|
rep, err := client.NetworksPrune(context.Background(), pruneFilters)
|
|
|
|
if err != nil {
|
|
|
|
return report, err
|
|
|
|
}
|
|
|
|
report.DeletedNumber = len(rep.NetworksDeleted)
|
|
|
|
case "volume":
|
|
|
|
rep, err := client.VolumesPrune(context.Background(), pruneFilters)
|
|
|
|
if err != nil {
|
|
|
|
return report, err
|
|
|
|
}
|
|
|
|
report.DeletedNumber = len(rep.VolumesDeleted)
|
|
|
|
report.SpaceReclaimed = int(rep.SpaceReclaimed)
|
|
|
|
}
|
|
|
|
return report, nil
|
|
|
|
}
|
|
|
|
|
2023-10-07 06:30:46 +00:00
|
|
|
func (u *ContainerService) LoadResourceLimit() (*dto.ResourceLimit, error) {
|
2023-07-05 10:16:19 +00:00
|
|
|
cpuCounts, err := cpu.Counts(true)
|
2023-06-15 12:44:13 +00:00
|
|
|
if err != nil {
|
|
|
|
return nil, fmt.Errorf("load cpu limit failed, err: %v", err)
|
|
|
|
}
|
|
|
|
memoryInfo, err := mem.VirtualMemory()
|
|
|
|
if err != nil {
|
|
|
|
return nil, fmt.Errorf("load memory limit failed, err: %v", err)
|
|
|
|
}
|
|
|
|
|
|
|
|
data := dto.ResourceLimit{
|
|
|
|
CPU: cpuCounts,
|
|
|
|
Memory: int(memoryInfo.Total),
|
|
|
|
}
|
|
|
|
return &data, nil
|
|
|
|
}
|
|
|
|
|
2023-06-15 03:00:11 +00:00
|
|
|
func (u *ContainerService) ContainerCreate(req dto.ContainerOperate) error {
|
|
|
|
client, err := docker.NewDockerClient()
|
2023-04-28 14:46:20 +00:00
|
|
|
if err != nil {
|
|
|
|
return err
|
2023-03-13 15:49:31 +00:00
|
|
|
}
|
2023-07-05 08:48:25 +00:00
|
|
|
ctx := context.Background()
|
|
|
|
newContainer, _ := client.ContainerInspect(ctx, req.Name)
|
2023-07-05 09:40:19 +00:00
|
|
|
if newContainer.ContainerJSONBase != nil {
|
2023-07-05 08:48:25 +00:00
|
|
|
return buserr.New(constant.ErrContainerName)
|
|
|
|
}
|
2023-06-15 03:00:11 +00:00
|
|
|
|
2023-06-16 09:54:11 +00:00
|
|
|
var config container.Config
|
|
|
|
var hostConf container.HostConfig
|
2023-07-07 15:17:05 +00:00
|
|
|
var networkConf network.NetworkingConfig
|
|
|
|
if err := loadConfigInfo(req, &config, &hostConf, &networkConf); err != nil {
|
2022-10-12 10:55:47 +00:00
|
|
|
return err
|
|
|
|
}
|
2023-04-28 14:46:20 +00:00
|
|
|
|
2023-06-15 03:00:11 +00:00
|
|
|
global.LOG.Infof("new container info %s has been made, now start to create", req.Name)
|
|
|
|
|
2023-07-10 14:45:08 +00:00
|
|
|
if !checkImageExist(client, req.Image) || req.ForcePull {
|
2023-06-15 03:00:11 +00:00
|
|
|
if err := pullImages(ctx, client, req.Image); err != nil {
|
2023-07-10 14:45:08 +00:00
|
|
|
if !req.ForcePull {
|
|
|
|
return err
|
|
|
|
}
|
|
|
|
global.LOG.Errorf("force pull image %s failed, err: %v", req.Image, err)
|
2023-06-15 03:00:11 +00:00
|
|
|
}
|
2023-04-28 14:46:20 +00:00
|
|
|
}
|
2023-07-07 15:17:05 +00:00
|
|
|
container, err := client.ContainerCreate(ctx, &config, &hostConf, &networkConf, &v1.Platform{}, req.Name)
|
2023-06-15 03:00:11 +00:00
|
|
|
if err != nil {
|
|
|
|
_ = client.ContainerRemove(ctx, req.Name, types.ContainerRemoveOptions{RemoveVolumes: true, Force: true})
|
|
|
|
return err
|
2022-10-12 10:55:47 +00:00
|
|
|
}
|
2023-06-15 03:00:11 +00:00
|
|
|
global.LOG.Infof("create container %s successful! now check if the container is started and delete the container information if it is not.", req.Name)
|
|
|
|
if err := client.ContainerStart(ctx, container.ID, types.ContainerStartOptions{}); err != nil {
|
|
|
|
_ = client.ContainerRemove(ctx, req.Name, types.ContainerRemoveOptions{RemoveVolumes: true, Force: true})
|
|
|
|
return fmt.Errorf("create successful but start failed, err: %v", err)
|
2022-10-12 10:55:47 +00:00
|
|
|
}
|
2023-06-15 03:00:11 +00:00
|
|
|
return nil
|
|
|
|
}
|
|
|
|
|
|
|
|
func (u *ContainerService) ContainerInfo(req dto.OperationWithName) (*dto.ContainerOperate, error) {
|
|
|
|
client, err := docker.NewDockerClient()
|
|
|
|
if err != nil {
|
|
|
|
return nil, err
|
2022-10-12 10:55:47 +00:00
|
|
|
}
|
2023-06-15 03:00:11 +00:00
|
|
|
ctx := context.Background()
|
|
|
|
oldContainer, err := client.ContainerInspect(ctx, req.Name)
|
|
|
|
if err != nil {
|
|
|
|
return nil, err
|
2022-10-12 10:55:47 +00:00
|
|
|
}
|
2023-06-15 03:00:11 +00:00
|
|
|
|
|
|
|
var data dto.ContainerOperate
|
2023-07-05 08:48:25 +00:00
|
|
|
data.ContainerID = oldContainer.ID
|
2023-06-15 03:00:11 +00:00
|
|
|
data.Name = strings.ReplaceAll(oldContainer.Name, "/", "")
|
|
|
|
data.Image = oldContainer.Config.Image
|
2023-07-07 15:17:05 +00:00
|
|
|
if oldContainer.NetworkSettings != nil {
|
|
|
|
for network := range oldContainer.NetworkSettings.Networks {
|
|
|
|
data.Network = network
|
|
|
|
break
|
|
|
|
}
|
|
|
|
}
|
2023-06-15 03:00:11 +00:00
|
|
|
data.Cmd = oldContainer.Config.Cmd
|
2023-10-07 06:30:46 +00:00
|
|
|
data.OpenStdin = oldContainer.Config.OpenStdin
|
|
|
|
data.Tty = oldContainer.Config.Tty
|
2023-09-07 08:24:10 +00:00
|
|
|
data.Entrypoint = oldContainer.Config.Entrypoint
|
2023-06-15 03:00:11 +00:00
|
|
|
data.Env = oldContainer.Config.Env
|
2023-06-16 09:54:11 +00:00
|
|
|
data.CPUShares = oldContainer.HostConfig.CPUShares
|
2023-06-15 03:00:11 +00:00
|
|
|
for key, val := range oldContainer.Config.Labels {
|
|
|
|
data.Labels = append(data.Labels, fmt.Sprintf("%s=%s", key, val))
|
2023-06-14 15:26:13 +00:00
|
|
|
}
|
2023-06-15 03:00:11 +00:00
|
|
|
for key, val := range oldContainer.HostConfig.PortBindings {
|
|
|
|
var itemPort dto.PortHelper
|
|
|
|
if !strings.Contains(string(key), "/") {
|
|
|
|
continue
|
|
|
|
}
|
|
|
|
itemPort.ContainerPort = strings.Split(string(key), "/")[0]
|
|
|
|
itemPort.Protocol = strings.Split(string(key), "/")[1]
|
|
|
|
for _, binds := range val {
|
|
|
|
itemPort.HostIP = binds.HostIP
|
|
|
|
itemPort.HostPort = binds.HostPort
|
|
|
|
data.ExposedPorts = append(data.ExposedPorts, itemPort)
|
|
|
|
}
|
2022-10-12 10:55:47 +00:00
|
|
|
}
|
2023-06-15 03:00:11 +00:00
|
|
|
data.AutoRemove = oldContainer.HostConfig.AutoRemove
|
|
|
|
data.PublishAllPorts = oldContainer.HostConfig.PublishAllPorts
|
|
|
|
data.RestartPolicy = oldContainer.HostConfig.RestartPolicy.Name
|
|
|
|
if oldContainer.HostConfig.NanoCPUs != 0 {
|
2023-07-10 06:45:08 +00:00
|
|
|
data.NanoCPUs = float64(oldContainer.HostConfig.NanoCPUs) / 1000000000
|
2022-10-12 10:55:47 +00:00
|
|
|
}
|
2023-06-15 03:00:11 +00:00
|
|
|
if oldContainer.HostConfig.Memory != 0 {
|
2023-07-10 06:45:08 +00:00
|
|
|
data.Memory = float64(oldContainer.HostConfig.Memory) / 1024 / 1024
|
2023-06-15 03:00:11 +00:00
|
|
|
}
|
2023-07-28 10:26:02 +00:00
|
|
|
data.Volumes = loadVolumeBinds(oldContainer.HostConfig.Binds)
|
2022-12-28 10:35:53 +00:00
|
|
|
|
2023-06-15 03:00:11 +00:00
|
|
|
return &data, nil
|
|
|
|
}
|
2023-03-28 11:02:11 +00:00
|
|
|
|
2023-06-15 03:00:11 +00:00
|
|
|
func (u *ContainerService) ContainerUpdate(req dto.ContainerOperate) error {
|
|
|
|
client, err := docker.NewDockerClient()
|
|
|
|
if err != nil {
|
|
|
|
return err
|
|
|
|
}
|
2023-03-28 11:02:11 +00:00
|
|
|
ctx := context.Background()
|
2023-07-05 08:48:25 +00:00
|
|
|
newContainer, _ := client.ContainerInspect(ctx, req.Name)
|
2023-07-05 09:40:19 +00:00
|
|
|
if newContainer.ContainerJSONBase != nil && newContainer.ID != req.ContainerID {
|
2023-07-05 08:48:25 +00:00
|
|
|
return buserr.New(constant.ErrContainerName)
|
|
|
|
}
|
|
|
|
|
|
|
|
oldContainer, err := client.ContainerInspect(ctx, req.ContainerID)
|
2023-06-15 03:00:11 +00:00
|
|
|
if err != nil {
|
|
|
|
return err
|
|
|
|
}
|
2023-07-10 14:45:08 +00:00
|
|
|
if !checkImageExist(client, req.Image) || req.ForcePull {
|
2023-04-17 08:08:28 +00:00
|
|
|
if err := pullImages(ctx, client, req.Image); err != nil {
|
2023-07-10 14:45:08 +00:00
|
|
|
if !req.ForcePull {
|
|
|
|
return err
|
|
|
|
}
|
|
|
|
global.LOG.Errorf("force pull image %s failed, err: %v", req.Image, err)
|
2023-04-17 08:08:28 +00:00
|
|
|
}
|
2023-03-28 11:02:11 +00:00
|
|
|
}
|
2023-07-12 06:33:19 +00:00
|
|
|
|
|
|
|
if err := client.ContainerRemove(ctx, req.ContainerID, types.ContainerRemoveOptions{Force: true}); err != nil {
|
|
|
|
return err
|
|
|
|
}
|
|
|
|
|
2023-06-15 03:00:11 +00:00
|
|
|
config := oldContainer.Config
|
|
|
|
hostConf := oldContainer.HostConfig
|
2023-07-07 15:17:05 +00:00
|
|
|
var networkConf network.NetworkingConfig
|
|
|
|
if err := loadConfigInfo(req, config, hostConf, &networkConf); err != nil {
|
2023-07-27 05:58:13 +00:00
|
|
|
reCreateAfterUpdate(req.Name, client, oldContainer.Config, oldContainer.HostConfig, oldContainer.NetworkSettings)
|
2023-06-15 03:00:11 +00:00
|
|
|
return err
|
|
|
|
}
|
|
|
|
|
|
|
|
global.LOG.Infof("new container info %s has been update, now start to recreate", req.Name)
|
2023-07-07 15:17:05 +00:00
|
|
|
container, err := client.ContainerCreate(ctx, config, hostConf, &networkConf, &v1.Platform{}, req.Name)
|
2022-10-12 10:55:47 +00:00
|
|
|
if err != nil {
|
2023-07-27 05:58:13 +00:00
|
|
|
reCreateAfterUpdate(req.Name, client, oldContainer.Config, oldContainer.HostConfig, oldContainer.NetworkSettings)
|
2023-10-07 06:30:46 +00:00
|
|
|
return fmt.Errorf("update container failed, err: %v", err)
|
2022-10-12 10:55:47 +00:00
|
|
|
}
|
2023-06-15 03:00:11 +00:00
|
|
|
global.LOG.Infof("update container %s successful! now check if the container is started.", req.Name)
|
2023-03-28 11:02:11 +00:00
|
|
|
if err := client.ContainerStart(ctx, container.ID, types.ContainerStartOptions{}); err != nil {
|
2023-06-15 03:00:11 +00:00
|
|
|
return fmt.Errorf("update successful but start failed, err: %v", err)
|
2022-10-12 10:55:47 +00:00
|
|
|
}
|
2023-06-15 03:00:11 +00:00
|
|
|
|
2022-10-12 10:55:47 +00:00
|
|
|
return nil
|
|
|
|
}
|
|
|
|
|
2023-06-16 09:54:11 +00:00
|
|
|
func (u *ContainerService) ContainerUpgrade(req dto.ContainerUpgrade) error {
|
|
|
|
client, err := docker.NewDockerClient()
|
|
|
|
if err != nil {
|
|
|
|
return err
|
|
|
|
}
|
|
|
|
ctx := context.Background()
|
|
|
|
oldContainer, err := client.ContainerInspect(ctx, req.Name)
|
|
|
|
if err != nil {
|
|
|
|
return err
|
|
|
|
}
|
2023-07-10 14:45:08 +00:00
|
|
|
if !checkImageExist(client, req.Image) || req.ForcePull {
|
2023-06-16 09:54:11 +00:00
|
|
|
if err := pullImages(ctx, client, req.Image); err != nil {
|
2023-07-10 14:45:08 +00:00
|
|
|
if !req.ForcePull {
|
|
|
|
return err
|
|
|
|
}
|
|
|
|
global.LOG.Errorf("force pull image %s failed, err: %v", req.Image, err)
|
2023-06-16 09:54:11 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
config := oldContainer.Config
|
|
|
|
config.Image = req.Image
|
|
|
|
hostConf := oldContainer.HostConfig
|
2023-07-07 15:17:05 +00:00
|
|
|
var networkConf network.NetworkingConfig
|
|
|
|
if oldContainer.NetworkSettings != nil {
|
|
|
|
for networkKey := range oldContainer.NetworkSettings.Networks {
|
|
|
|
networkConf.EndpointsConfig = map[string]*network.EndpointSettings{networkKey: {}}
|
|
|
|
break
|
|
|
|
}
|
|
|
|
}
|
2023-06-16 09:54:11 +00:00
|
|
|
if err := client.ContainerRemove(ctx, req.Name, types.ContainerRemoveOptions{Force: true}); err != nil {
|
|
|
|
return err
|
|
|
|
}
|
|
|
|
|
|
|
|
global.LOG.Infof("new container info %s has been update, now start to recreate", req.Name)
|
2023-07-27 05:58:13 +00:00
|
|
|
container, err := client.ContainerCreate(ctx, config, hostConf, &networkConf, &v1.Platform{}, req.Name)
|
2023-06-16 09:54:11 +00:00
|
|
|
if err != nil {
|
2023-07-27 05:58:13 +00:00
|
|
|
reCreateAfterUpdate(req.Name, client, oldContainer.Config, oldContainer.HostConfig, oldContainer.NetworkSettings)
|
2023-10-07 06:30:46 +00:00
|
|
|
return fmt.Errorf("upgrade container failed, err: %v", err)
|
2023-06-16 09:54:11 +00:00
|
|
|
}
|
2023-07-27 05:58:13 +00:00
|
|
|
global.LOG.Infof("upgrade container %s successful! now check if the container is started.", req.Name)
|
2023-06-16 09:54:11 +00:00
|
|
|
if err := client.ContainerStart(ctx, container.ID, types.ContainerStartOptions{}); err != nil {
|
2023-07-27 05:58:13 +00:00
|
|
|
return fmt.Errorf("upgrade successful but start failed, err: %v", err)
|
2023-06-16 09:54:11 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
return nil
|
|
|
|
}
|
|
|
|
|
2022-10-08 10:32:02 +00:00
|
|
|
func (u *ContainerService) ContainerOperation(req dto.ContainerOperation) error {
|
|
|
|
var err error
|
|
|
|
ctx := context.Background()
|
2022-10-13 10:24:24 +00:00
|
|
|
client, err := docker.NewDockerClient()
|
2022-10-08 10:32:02 +00:00
|
|
|
if err != nil {
|
|
|
|
return err
|
|
|
|
}
|
2022-12-28 10:35:53 +00:00
|
|
|
global.LOG.Infof("start container %s operation %s", req.Name, req.Operation)
|
2022-10-08 10:32:02 +00:00
|
|
|
switch req.Operation {
|
|
|
|
case constant.ContainerOpStart:
|
2022-12-13 10:54:28 +00:00
|
|
|
err = client.ContainerStart(ctx, req.Name, types.ContainerStartOptions{})
|
2022-10-08 10:32:02 +00:00
|
|
|
case constant.ContainerOpStop:
|
2023-03-28 02:52:17 +00:00
|
|
|
err = client.ContainerStop(ctx, req.Name, container.StopOptions{})
|
2022-10-08 10:32:02 +00:00
|
|
|
case constant.ContainerOpRestart:
|
2023-03-28 02:52:17 +00:00
|
|
|
err = client.ContainerRestart(ctx, req.Name, container.StopOptions{})
|
2022-10-08 10:32:02 +00:00
|
|
|
case constant.ContainerOpKill:
|
2022-12-13 10:54:28 +00:00
|
|
|
err = client.ContainerKill(ctx, req.Name, "SIGKILL")
|
2022-10-08 10:32:02 +00:00
|
|
|
case constant.ContainerOpPause:
|
2022-12-13 10:54:28 +00:00
|
|
|
err = client.ContainerPause(ctx, req.Name)
|
2022-10-08 10:32:02 +00:00
|
|
|
case constant.ContainerOpUnpause:
|
2022-12-13 10:54:28 +00:00
|
|
|
err = client.ContainerUnpause(ctx, req.Name)
|
2022-10-08 10:32:02 +00:00
|
|
|
case constant.ContainerOpRename:
|
2023-07-05 08:48:25 +00:00
|
|
|
newContainer, _ := client.ContainerInspect(ctx, req.NewName)
|
2023-07-05 09:40:19 +00:00
|
|
|
if newContainer.ContainerJSONBase != nil {
|
2023-07-05 08:48:25 +00:00
|
|
|
return buserr.New(constant.ErrContainerName)
|
|
|
|
}
|
2022-12-13 10:54:28 +00:00
|
|
|
err = client.ContainerRename(ctx, req.Name, req.NewName)
|
2022-10-08 10:32:02 +00:00
|
|
|
case constant.ContainerOpRemove:
|
2022-12-13 10:54:28 +00:00
|
|
|
err = client.ContainerRemove(ctx, req.Name, types.ContainerRemoveOptions{RemoveVolumes: true, Force: true})
|
2022-10-08 10:32:02 +00:00
|
|
|
}
|
|
|
|
return err
|
|
|
|
}
|
|
|
|
|
2023-05-23 07:43:51 +00:00
|
|
|
func (u *ContainerService) ContainerLogClean(req dto.OperationWithName) error {
|
|
|
|
client, err := docker.NewDockerClient()
|
|
|
|
if err != nil {
|
|
|
|
return err
|
|
|
|
}
|
2023-08-21 09:00:12 +00:00
|
|
|
ctx := context.Background()
|
|
|
|
containerItem, err := client.ContainerInspect(ctx, req.Name)
|
2023-05-23 07:43:51 +00:00
|
|
|
if err != nil {
|
|
|
|
return err
|
|
|
|
}
|
2023-08-21 09:00:12 +00:00
|
|
|
if err := client.ContainerStop(ctx, containerItem.ID, container.StopOptions{}); err != nil {
|
|
|
|
return err
|
|
|
|
}
|
|
|
|
file, err := os.OpenFile(containerItem.LogPath, os.O_RDWR|os.O_CREATE, 0666)
|
2023-05-23 07:43:51 +00:00
|
|
|
if err != nil {
|
|
|
|
return err
|
|
|
|
}
|
|
|
|
defer file.Close()
|
|
|
|
if err = file.Truncate(0); err != nil {
|
|
|
|
return err
|
|
|
|
}
|
|
|
|
_, _ = file.Seek(0, 0)
|
2023-07-12 06:33:19 +00:00
|
|
|
|
2023-08-21 09:00:12 +00:00
|
|
|
files, _ := filepath.Glob(fmt.Sprintf("%s.*", containerItem.LogPath))
|
2023-07-12 06:33:19 +00:00
|
|
|
for _, file := range files {
|
|
|
|
_ = os.Remove(file)
|
|
|
|
}
|
2023-08-21 09:00:12 +00:00
|
|
|
|
|
|
|
if err := client.ContainerStart(ctx, containerItem.ID, types.ContainerStartOptions{}); err != nil {
|
|
|
|
return err
|
|
|
|
}
|
2023-05-23 07:43:51 +00:00
|
|
|
return nil
|
|
|
|
}
|
|
|
|
|
2023-06-13 15:04:12 +00:00
|
|
|
func (u *ContainerService) ContainerLogs(wsConn *websocket.Conn, container, since, tail string, follow bool) error {
|
2023-07-17 08:34:29 +00:00
|
|
|
if cmd.CheckIllegal(container, since, tail) {
|
|
|
|
return buserr.New(constant.ErrCmdIllegal)
|
|
|
|
}
|
2023-06-13 15:04:12 +00:00
|
|
|
command := fmt.Sprintf("docker logs %s", container)
|
|
|
|
if tail != "0" {
|
2023-09-05 14:04:11 +00:00
|
|
|
command += " --tail " + tail
|
2022-10-08 10:32:02 +00:00
|
|
|
}
|
2023-06-13 15:04:12 +00:00
|
|
|
if since != "all" {
|
|
|
|
command += " --since " + since
|
|
|
|
}
|
|
|
|
if follow {
|
|
|
|
command += " -f"
|
|
|
|
}
|
|
|
|
command += " 2>&1"
|
|
|
|
cmd := exec.Command("bash", "-c", command)
|
|
|
|
stdout, err := cmd.StdoutPipe()
|
2023-03-09 10:42:17 +00:00
|
|
|
if err != nil {
|
2023-06-13 15:04:12 +00:00
|
|
|
return err
|
|
|
|
}
|
|
|
|
if err := cmd.Start(); err != nil {
|
|
|
|
return err
|
|
|
|
}
|
|
|
|
|
2023-06-14 06:16:13 +00:00
|
|
|
buffer := make([]byte, 1024)
|
2023-06-13 15:04:12 +00:00
|
|
|
for {
|
2023-06-14 06:16:13 +00:00
|
|
|
n, err := stdout.Read(buffer)
|
2023-06-13 15:04:12 +00:00
|
|
|
if err != nil {
|
|
|
|
if err == io.EOF {
|
|
|
|
break
|
|
|
|
}
|
|
|
|
global.LOG.Errorf("read bytes from container log failed, err: %v", err)
|
|
|
|
continue
|
|
|
|
}
|
2023-06-14 06:16:13 +00:00
|
|
|
if err = wsConn.WriteMessage(websocket.TextMessage, buffer[:n]); err != nil {
|
2023-06-13 15:04:12 +00:00
|
|
|
global.LOG.Errorf("send message with container log to ws failed, err: %v", err)
|
|
|
|
break
|
|
|
|
}
|
2022-10-08 10:32:02 +00:00
|
|
|
}
|
2023-06-13 15:04:12 +00:00
|
|
|
return nil
|
2022-10-08 10:32:02 +00:00
|
|
|
}
|
2022-10-11 06:20:51 +00:00
|
|
|
|
2023-07-06 10:04:22 +00:00
|
|
|
func (u *ContainerService) ContainerStats(id string) (*dto.ContainerStats, error) {
|
2022-10-13 10:24:24 +00:00
|
|
|
client, err := docker.NewDockerClient()
|
|
|
|
if err != nil {
|
|
|
|
return nil, err
|
|
|
|
}
|
|
|
|
res, err := client.ContainerStats(context.TODO(), id, false)
|
|
|
|
if err != nil {
|
|
|
|
return nil, err
|
|
|
|
}
|
|
|
|
defer res.Body.Close()
|
|
|
|
|
2023-04-07 03:30:10 +00:00
|
|
|
body, err := io.ReadAll(res.Body)
|
2022-10-13 10:24:24 +00:00
|
|
|
if err != nil {
|
2023-04-25 14:06:17 +00:00
|
|
|
res.Body.Close()
|
2022-10-13 10:24:24 +00:00
|
|
|
return nil, err
|
|
|
|
}
|
2023-04-25 14:06:17 +00:00
|
|
|
res.Body.Close()
|
2022-10-13 10:24:24 +00:00
|
|
|
var stats *types.StatsJSON
|
|
|
|
if err := json.Unmarshal(body, &stats); err != nil {
|
|
|
|
return nil, err
|
|
|
|
}
|
2023-07-06 10:04:22 +00:00
|
|
|
var data dto.ContainerStats
|
2023-04-25 14:06:17 +00:00
|
|
|
data.CPUPercent = calculateCPUPercentUnix(stats)
|
2022-10-13 10:24:24 +00:00
|
|
|
data.IORead, data.IOWrite = calculateBlockIO(stats.BlkioStats)
|
|
|
|
data.Memory = float64(stats.MemoryStats.Usage) / 1024 / 1024
|
|
|
|
if cache, ok := stats.MemoryStats.Stats["cache"]; ok {
|
|
|
|
data.Cache = float64(cache) / 1024 / 1024
|
|
|
|
}
|
|
|
|
data.Memory = data.Memory - data.Cache
|
|
|
|
data.NetworkRX, data.NetworkTX = calculateNetwork(stats.Networks)
|
|
|
|
data.ShotTime = stats.Read
|
|
|
|
return &data, nil
|
|
|
|
}
|
|
|
|
|
2023-08-09 03:18:12 +00:00
|
|
|
func (u *ContainerService) LoadContainerLogs(req dto.OperationWithNameAndType) string {
|
2023-08-02 08:47:30 +00:00
|
|
|
filePath := ""
|
|
|
|
switch req.Type {
|
2023-08-16 15:34:15 +00:00
|
|
|
case "image-pull", "image-push", "image-build", "compose-create":
|
2023-08-02 08:47:30 +00:00
|
|
|
filePath = path.Join(global.CONF.System.TmpDir, fmt.Sprintf("docker_logs/%s", req.Name))
|
2023-08-16 15:34:15 +00:00
|
|
|
case "compose-detail":
|
2023-08-02 08:47:30 +00:00
|
|
|
client, err := docker.NewDockerClient()
|
|
|
|
if err != nil {
|
2023-08-09 03:18:12 +00:00
|
|
|
return ""
|
2023-08-02 08:47:30 +00:00
|
|
|
}
|
|
|
|
options := types.ContainerListOptions{All: true}
|
|
|
|
options.Filters = filters.NewArgs()
|
|
|
|
options.Filters.Add("label", fmt.Sprintf("%s=%s", composeProjectLabel, req.Name))
|
|
|
|
containers, err := client.ContainerList(context.Background(), options)
|
|
|
|
if err != nil {
|
2023-08-09 03:18:12 +00:00
|
|
|
return ""
|
2023-08-02 08:47:30 +00:00
|
|
|
}
|
|
|
|
for _, container := range containers {
|
|
|
|
config := container.Labels[composeConfigLabel]
|
|
|
|
workdir := container.Labels[composeWorkdirLabel]
|
|
|
|
if len(config) != 0 && len(workdir) != 0 && strings.Contains(config, workdir) {
|
|
|
|
filePath = config
|
|
|
|
break
|
|
|
|
} else {
|
|
|
|
filePath = workdir
|
|
|
|
break
|
|
|
|
}
|
|
|
|
}
|
|
|
|
if req.Type == "compose-create" {
|
2023-08-09 03:18:12 +00:00
|
|
|
filePath = path.Join(path.Dir(filePath), "compose.log")
|
2023-08-02 08:47:30 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
if _, err := os.Stat(filePath); err != nil {
|
2023-08-09 03:18:12 +00:00
|
|
|
return ""
|
2023-08-02 08:47:30 +00:00
|
|
|
}
|
|
|
|
content, err := os.ReadFile(filePath)
|
|
|
|
if err != nil {
|
2023-08-09 03:18:12 +00:00
|
|
|
return ""
|
2023-08-02 08:47:30 +00:00
|
|
|
}
|
2023-08-09 03:18:12 +00:00
|
|
|
return string(content)
|
2023-08-02 08:47:30 +00:00
|
|
|
}
|
|
|
|
|
2022-10-11 06:20:51 +00:00
|
|
|
func stringsToMap(list []string) map[string]string {
|
2023-10-07 06:30:46 +00:00
|
|
|
var labelMap = make(map[string]string)
|
2022-10-11 06:20:51 +00:00
|
|
|
for _, label := range list {
|
2023-04-26 09:26:12 +00:00
|
|
|
if strings.Contains(label, "=") {
|
|
|
|
sps := strings.SplitN(label, "=", 2)
|
2023-10-07 06:30:46 +00:00
|
|
|
labelMap[sps[0]] = sps[1]
|
2022-10-11 06:20:51 +00:00
|
|
|
}
|
|
|
|
}
|
2023-10-07 06:30:46 +00:00
|
|
|
return labelMap
|
2022-10-11 06:20:51 +00:00
|
|
|
}
|
2023-04-25 14:06:17 +00:00
|
|
|
|
|
|
|
func calculateCPUPercentUnix(stats *types.StatsJSON) float64 {
|
|
|
|
cpuPercent := 0.0
|
|
|
|
cpuDelta := float64(stats.CPUStats.CPUUsage.TotalUsage) - float64(stats.PreCPUStats.CPUUsage.TotalUsage)
|
|
|
|
systemDelta := float64(stats.CPUStats.SystemUsage) - float64(stats.PreCPUStats.SystemUsage)
|
2022-10-13 10:24:24 +00:00
|
|
|
|
|
|
|
if systemDelta > 0.0 && cpuDelta > 0.0 {
|
2023-05-10 06:48:15 +00:00
|
|
|
cpuPercent = (cpuDelta / systemDelta) * 100.0
|
|
|
|
if len(stats.CPUStats.CPUUsage.PercpuUsage) != 0 {
|
|
|
|
cpuPercent = cpuPercent * float64(len(stats.CPUStats.CPUUsage.PercpuUsage))
|
|
|
|
}
|
2022-10-13 10:24:24 +00:00
|
|
|
}
|
|
|
|
return cpuPercent
|
|
|
|
}
|
2023-04-25 14:06:17 +00:00
|
|
|
func calculateMemPercentUnix(memStats types.MemoryStats) float64 {
|
|
|
|
memPercent := 0.0
|
|
|
|
memUsage := float64(memStats.Usage - memStats.Stats["cache"])
|
|
|
|
memLimit := float64(memStats.Limit)
|
|
|
|
if memUsage > 0.0 && memLimit > 0.0 {
|
|
|
|
memPercent = (memUsage / memLimit) * 100.0
|
|
|
|
}
|
|
|
|
return memPercent
|
|
|
|
}
|
2022-10-13 10:24:24 +00:00
|
|
|
func calculateBlockIO(blkio types.BlkioStats) (blkRead float64, blkWrite float64) {
|
|
|
|
for _, bioEntry := range blkio.IoServiceBytesRecursive {
|
|
|
|
switch strings.ToLower(bioEntry.Op) {
|
|
|
|
case "read":
|
|
|
|
blkRead = (blkRead + float64(bioEntry.Value)) / 1024 / 1024
|
|
|
|
case "write":
|
|
|
|
blkWrite = (blkWrite + float64(bioEntry.Value)) / 1024 / 1024
|
|
|
|
}
|
|
|
|
}
|
|
|
|
return
|
|
|
|
}
|
|
|
|
func calculateNetwork(network map[string]types.NetworkStats) (float64, float64) {
|
|
|
|
var rx, tx float64
|
|
|
|
|
|
|
|
for _, v := range network {
|
|
|
|
rx += float64(v.RxBytes) / 1024
|
|
|
|
tx += float64(v.TxBytes) / 1024
|
|
|
|
}
|
|
|
|
return rx, tx
|
|
|
|
}
|
2023-03-28 11:02:11 +00:00
|
|
|
|
2023-04-17 08:08:28 +00:00
|
|
|
func checkImageExist(client *client.Client, image string) bool {
|
|
|
|
images, err := client.ImageList(context.Background(), types.ImageListOptions{})
|
|
|
|
if err != nil {
|
|
|
|
fmt.Println(err)
|
|
|
|
return false
|
|
|
|
}
|
|
|
|
|
|
|
|
for _, img := range images {
|
|
|
|
for _, tag := range img.RepoTags {
|
|
|
|
if tag == image || tag == image+":latest" {
|
|
|
|
return true
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
return false
|
|
|
|
}
|
|
|
|
|
2023-03-28 11:02:11 +00:00
|
|
|
func pullImages(ctx context.Context, client *client.Client, image string) error {
|
|
|
|
out, err := client.ImagePull(ctx, image, types.ImagePullOptions{})
|
|
|
|
if err != nil {
|
|
|
|
return err
|
|
|
|
}
|
|
|
|
defer out.Close()
|
2023-04-07 03:30:10 +00:00
|
|
|
_, err = io.Copy(io.Discard, out)
|
2023-03-28 11:02:11 +00:00
|
|
|
if err != nil {
|
|
|
|
return err
|
|
|
|
}
|
|
|
|
return nil
|
|
|
|
}
|
2023-04-25 14:06:17 +00:00
|
|
|
|
2023-09-21 09:34:22 +00:00
|
|
|
func loadCpuAndMem(client *client.Client, container string) dto.ContainerListStats {
|
|
|
|
data := dto.ContainerListStats{
|
|
|
|
ContainerID: container,
|
|
|
|
}
|
2023-04-25 14:06:17 +00:00
|
|
|
res, err := client.ContainerStats(context.Background(), container, false)
|
|
|
|
if err != nil {
|
2023-09-21 09:34:22 +00:00
|
|
|
return data
|
2023-04-25 14:06:17 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
body, err := io.ReadAll(res.Body)
|
|
|
|
if err != nil {
|
|
|
|
res.Body.Close()
|
2023-09-21 09:34:22 +00:00
|
|
|
return data
|
2023-04-25 14:06:17 +00:00
|
|
|
}
|
|
|
|
res.Body.Close()
|
|
|
|
var stats *types.StatsJSON
|
|
|
|
if err := json.Unmarshal(body, &stats); err != nil {
|
2023-09-21 09:34:22 +00:00
|
|
|
return data
|
2023-04-25 14:06:17 +00:00
|
|
|
}
|
|
|
|
|
2023-09-21 09:34:22 +00:00
|
|
|
data.CPUTotalUsage = stats.CPUStats.CPUUsage.TotalUsage - stats.PreCPUStats.CPUUsage.TotalUsage
|
|
|
|
data.SystemUsage = stats.CPUStats.SystemUsage - stats.PreCPUStats.SystemUsage
|
|
|
|
data.CPUPercent = calculateCPUPercentUnix(stats)
|
|
|
|
data.PercpuUsage = len(stats.CPUStats.CPUUsage.PercpuUsage)
|
|
|
|
|
2023-10-07 06:30:46 +00:00
|
|
|
data.MemoryCache = stats.MemoryStats.Stats["cache"]
|
2023-09-21 09:34:22 +00:00
|
|
|
data.MemoryUsage = stats.MemoryStats.Usage
|
|
|
|
data.MemoryLimit = stats.MemoryStats.Limit
|
|
|
|
data.MemoryPercent = calculateMemPercentUnix(stats.MemoryStats)
|
|
|
|
return data
|
2023-04-25 14:06:17 +00:00
|
|
|
}
|
2023-04-28 14:46:20 +00:00
|
|
|
|
|
|
|
func checkPortStats(ports []dto.PortHelper) (nat.PortMap, error) {
|
|
|
|
portMap := make(nat.PortMap)
|
|
|
|
if len(ports) == 0 {
|
|
|
|
return portMap, nil
|
|
|
|
}
|
|
|
|
for _, port := range ports {
|
2023-05-05 03:17:28 +00:00
|
|
|
if strings.Contains(port.ContainerPort, "-") {
|
|
|
|
if !strings.Contains(port.HostPort, "-") {
|
2023-04-28 14:46:20 +00:00
|
|
|
return portMap, buserr.New(constant.ErrPortRules)
|
|
|
|
}
|
|
|
|
hostStart, _ := strconv.Atoi(strings.Split(port.HostPort, "-")[0])
|
|
|
|
hostEnd, _ := strconv.Atoi(strings.Split(port.HostPort, "-")[1])
|
|
|
|
containerStart, _ := strconv.Atoi(strings.Split(port.ContainerPort, "-")[0])
|
|
|
|
containerEnd, _ := strconv.Atoi(strings.Split(port.ContainerPort, "-")[1])
|
|
|
|
if (hostEnd-hostStart) <= 0 || (containerEnd-containerStart) <= 0 {
|
|
|
|
return portMap, buserr.New(constant.ErrPortRules)
|
|
|
|
}
|
|
|
|
if (containerEnd - containerStart) != (hostEnd - hostStart) {
|
|
|
|
return portMap, buserr.New(constant.ErrPortRules)
|
|
|
|
}
|
|
|
|
for i := 0; i <= hostEnd-hostStart; i++ {
|
|
|
|
bindItem := nat.PortBinding{HostPort: strconv.Itoa(hostStart + i), HostIP: port.HostIP}
|
|
|
|
portMap[nat.Port(fmt.Sprintf("%d/%s", containerStart+i, port.Protocol))] = []nat.PortBinding{bindItem}
|
|
|
|
}
|
|
|
|
for i := hostStart; i <= hostEnd; i++ {
|
|
|
|
if common.ScanPort(i) {
|
|
|
|
return portMap, buserr.WithDetail(constant.ErrPortInUsed, i, nil)
|
|
|
|
}
|
|
|
|
}
|
|
|
|
} else {
|
2023-05-05 03:17:28 +00:00
|
|
|
portItem := 0
|
|
|
|
if strings.Contains(port.HostPort, "-") {
|
|
|
|
portItem, _ = strconv.Atoi(strings.Split(port.HostPort, "-")[0])
|
|
|
|
} else {
|
|
|
|
portItem, _ = strconv.Atoi(port.HostPort)
|
|
|
|
}
|
2023-04-28 14:46:20 +00:00
|
|
|
if common.ScanPort(portItem) {
|
|
|
|
return portMap, buserr.WithDetail(constant.ErrPortInUsed, portItem, nil)
|
|
|
|
}
|
|
|
|
bindItem := nat.PortBinding{HostPort: strconv.Itoa(portItem), HostIP: port.HostIP}
|
|
|
|
portMap[nat.Port(fmt.Sprintf("%s/%s", port.ContainerPort, port.Protocol))] = []nat.PortBinding{bindItem}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
return portMap, nil
|
|
|
|
}
|
2023-06-15 03:00:11 +00:00
|
|
|
|
2023-07-07 15:17:05 +00:00
|
|
|
func loadConfigInfo(req dto.ContainerOperate, config *container.Config, hostConf *container.HostConfig, networkConf *network.NetworkingConfig) error {
|
2023-06-15 03:00:11 +00:00
|
|
|
portMap, err := checkPortStats(req.ExposedPorts)
|
|
|
|
if err != nil {
|
|
|
|
return err
|
|
|
|
}
|
2023-10-07 06:30:46 +00:00
|
|
|
exposed := make(nat.PortSet)
|
2023-06-15 03:00:11 +00:00
|
|
|
for port := range portMap {
|
2023-10-07 06:30:46 +00:00
|
|
|
exposed[port] = struct{}{}
|
2023-06-15 03:00:11 +00:00
|
|
|
}
|
|
|
|
config.Image = req.Image
|
|
|
|
config.Cmd = req.Cmd
|
2023-09-07 08:24:10 +00:00
|
|
|
config.Entrypoint = req.Entrypoint
|
2023-06-15 03:00:11 +00:00
|
|
|
config.Env = req.Env
|
|
|
|
config.Labels = stringsToMap(req.Labels)
|
2023-10-07 06:30:46 +00:00
|
|
|
config.ExposedPorts = exposed
|
|
|
|
config.OpenStdin = req.OpenStdin
|
|
|
|
config.Tty = req.Tty
|
2023-06-15 03:00:11 +00:00
|
|
|
|
2023-07-27 05:58:13 +00:00
|
|
|
if len(req.Network) != 0 {
|
|
|
|
networkConf.EndpointsConfig = map[string]*network.EndpointSettings{req.Network: {}}
|
|
|
|
} else {
|
|
|
|
networkConf = &network.NetworkingConfig{}
|
|
|
|
}
|
2023-07-07 15:17:05 +00:00
|
|
|
|
2023-06-15 03:00:11 +00:00
|
|
|
hostConf.AutoRemove = req.AutoRemove
|
2023-06-16 09:54:11 +00:00
|
|
|
hostConf.CPUShares = req.CPUShares
|
2023-06-15 03:00:11 +00:00
|
|
|
hostConf.PublishAllPorts = req.PublishAllPorts
|
|
|
|
hostConf.RestartPolicy = container.RestartPolicy{Name: req.RestartPolicy}
|
|
|
|
if req.RestartPolicy == "on-failure" {
|
|
|
|
hostConf.RestartPolicy.MaximumRetryCount = 5
|
|
|
|
}
|
2023-07-10 06:45:08 +00:00
|
|
|
hostConf.NanoCPUs = int64(req.NanoCPUs * 1000000000)
|
|
|
|
hostConf.Memory = int64(req.Memory * 1024 * 1024)
|
|
|
|
hostConf.PortBindings = portMap
|
2023-06-15 03:00:11 +00:00
|
|
|
hostConf.Binds = []string{}
|
2023-07-10 06:45:08 +00:00
|
|
|
config.Volumes = make(map[string]struct{})
|
|
|
|
for _, volume := range req.Volumes {
|
|
|
|
config.Volumes[volume.ContainerDir] = struct{}{}
|
|
|
|
hostConf.Binds = append(hostConf.Binds, fmt.Sprintf("%s:%s:%s", volume.SourceDir, volume.ContainerDir, volume.Mode))
|
2023-06-15 03:00:11 +00:00
|
|
|
}
|
|
|
|
return nil
|
|
|
|
}
|
2023-07-27 05:58:13 +00:00
|
|
|
|
|
|
|
func reCreateAfterUpdate(name string, client *client.Client, config *container.Config, hostConf *container.HostConfig, networkConf *types.NetworkSettings) {
|
|
|
|
ctx := context.Background()
|
|
|
|
|
|
|
|
var oldNetworkConf network.NetworkingConfig
|
|
|
|
if networkConf != nil {
|
|
|
|
for networkKey := range networkConf.Networks {
|
|
|
|
oldNetworkConf.EndpointsConfig = map[string]*network.EndpointSettings{networkKey: {}}
|
|
|
|
break
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
oldContainer, err := client.ContainerCreate(ctx, config, hostConf, &oldNetworkConf, &v1.Platform{}, name)
|
|
|
|
if err != nil {
|
|
|
|
global.LOG.Errorf("recreate after container update failed, err: %v", err)
|
|
|
|
return
|
|
|
|
}
|
|
|
|
if err := client.ContainerStart(ctx, oldContainer.ID, types.ContainerStartOptions{}); err != nil {
|
|
|
|
global.LOG.Errorf("restart after container update failed, err: %v", err)
|
|
|
|
}
|
|
|
|
}
|
2023-07-28 10:26:02 +00:00
|
|
|
|
|
|
|
func loadVolumeBinds(binds []string) []dto.VolumeHelper {
|
|
|
|
var datas []dto.VolumeHelper
|
|
|
|
for _, bind := range binds {
|
|
|
|
parts := strings.Split(bind, ":")
|
|
|
|
var volumeItem dto.VolumeHelper
|
|
|
|
if len(parts) > 3 {
|
|
|
|
continue
|
|
|
|
}
|
|
|
|
volumeItem.SourceDir = parts[0]
|
|
|
|
if len(parts) == 1 {
|
|
|
|
volumeItem.ContainerDir = parts[0]
|
|
|
|
volumeItem.Mode = "rw"
|
|
|
|
}
|
|
|
|
if len(parts) == 2 {
|
|
|
|
switch parts[1] {
|
|
|
|
case "r", "ro":
|
|
|
|
volumeItem.ContainerDir = parts[0]
|
|
|
|
volumeItem.Mode = "ro"
|
|
|
|
case "rw":
|
|
|
|
volumeItem.ContainerDir = parts[0]
|
|
|
|
volumeItem.Mode = "rw"
|
|
|
|
default:
|
|
|
|
volumeItem.ContainerDir = parts[1]
|
|
|
|
volumeItem.Mode = "rw"
|
|
|
|
}
|
|
|
|
}
|
|
|
|
if len(parts) == 3 {
|
|
|
|
volumeItem.ContainerDir = parts[1]
|
|
|
|
if parts[2] == "r" {
|
|
|
|
volumeItem.Mode = "ro"
|
|
|
|
} else {
|
|
|
|
volumeItem.Mode = parts[2]
|
|
|
|
}
|
|
|
|
}
|
|
|
|
datas = append(datas, volumeItem)
|
|
|
|
}
|
|
|
|
return datas
|
|
|
|
}
|
2023-09-05 09:32:15 +00:00
|
|
|
|
|
|
|
func simplifyPort(ports []types.Port) []string {
|
|
|
|
var datas []string
|
|
|
|
if len(ports) == 0 {
|
|
|
|
return datas
|
|
|
|
}
|
|
|
|
if len(ports) == 1 {
|
2023-10-08 09:04:18 +00:00
|
|
|
ip := ""
|
|
|
|
if len(ports[0].IP) != 0 {
|
|
|
|
ip = ports[0].IP + ":"
|
|
|
|
}
|
|
|
|
itemPortStr := fmt.Sprintf("%s%v/%s", ip, ports[0].PrivatePort, ports[0].Type)
|
2023-09-05 09:32:15 +00:00
|
|
|
if ports[0].PublicPort != 0 {
|
2023-10-08 09:04:18 +00:00
|
|
|
itemPortStr = fmt.Sprintf("%s%v->%v/%s", ip, ports[0].PublicPort, ports[0].PrivatePort, ports[0].Type)
|
2023-09-05 09:32:15 +00:00
|
|
|
}
|
|
|
|
datas = append(datas, itemPortStr)
|
|
|
|
return datas
|
|
|
|
}
|
|
|
|
|
|
|
|
sort.Slice(ports, func(i, j int) bool {
|
|
|
|
return ports[i].PrivatePort < ports[j].PrivatePort
|
|
|
|
})
|
|
|
|
start := ports[0]
|
|
|
|
|
|
|
|
for i := 1; i < len(ports); i++ {
|
|
|
|
if ports[i].PrivatePort != ports[i-1].PrivatePort+1 || ports[i].IP != ports[i-1].IP || ports[i].PublicPort != ports[i-1].PublicPort+1 || ports[i].Type != ports[i-1].Type {
|
|
|
|
if ports[i-1].PrivatePort == start.PrivatePort {
|
|
|
|
itemPortStr := fmt.Sprintf("%s:%v/%s", start.IP, start.PrivatePort, start.Type)
|
|
|
|
if start.PublicPort != 0 {
|
|
|
|
itemPortStr = fmt.Sprintf("%s:%v->%v/%s", start.IP, start.PublicPort, start.PrivatePort, start.Type)
|
|
|
|
}
|
|
|
|
datas = append(datas, itemPortStr)
|
|
|
|
} else {
|
|
|
|
itemPortStr := fmt.Sprintf("%s:%v-%v/%s", start.IP, start.PrivatePort, ports[i-1].PrivatePort, start.Type)
|
|
|
|
if start.PublicPort != 0 {
|
|
|
|
itemPortStr = fmt.Sprintf("%s:%v-%v->%v-%v/%s", start.IP, start.PublicPort, ports[i-1].PublicPort, start.PrivatePort, ports[i-1].PrivatePort, start.Type)
|
|
|
|
}
|
|
|
|
datas = append(datas, itemPortStr)
|
|
|
|
}
|
|
|
|
start = ports[i]
|
|
|
|
} else if i == len(ports)-1 {
|
|
|
|
if ports[i].PrivatePort == start.PrivatePort {
|
|
|
|
itemPortStr := fmt.Sprintf("%s:%v/%s", start.IP, start.PrivatePort, start.Type)
|
|
|
|
if start.PublicPort != 0 {
|
|
|
|
itemPortStr = fmt.Sprintf("%s:%v->%v/%s", start.IP, start.PublicPort, start.PrivatePort, start.Type)
|
|
|
|
}
|
|
|
|
datas = append(datas, itemPortStr)
|
|
|
|
} else {
|
|
|
|
itemPortStr := fmt.Sprintf("%s:%v-%v/%s", start.IP, start.PrivatePort, ports[i].PrivatePort, start.Type)
|
|
|
|
if start.PublicPort != 0 {
|
|
|
|
itemPortStr = fmt.Sprintf("%s:%v-%v->%v-%v/%s", start.IP, start.PublicPort, ports[i].PublicPort, start.PrivatePort, ports[i].PrivatePort, start.Type)
|
|
|
|
}
|
|
|
|
datas = append(datas, itemPortStr)
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
return datas
|
|
|
|
}
|