1Panel/backend/app/service/image.go

413 lines
11 KiB
Go
Raw Normal View History

package service
import (
2022-10-12 13:42:58 +08:00
"bufio"
"context"
"encoding/base64"
"encoding/json"
2023-03-10 18:05:02 +08:00
"errors"
"fmt"
"io"
"os"
"path"
"strings"
"time"
2022-10-18 18:39:45 +08:00
"github.com/1Panel-dev/1Panel/backend/app/dto"
"github.com/1Panel-dev/1Panel/backend/buserr"
2022-10-18 18:39:45 +08:00
"github.com/1Panel-dev/1Panel/backend/constant"
"github.com/1Panel-dev/1Panel/backend/global"
"github.com/1Panel-dev/1Panel/backend/utils/docker"
"github.com/docker/docker/api/types"
2022-10-12 13:42:58 +08:00
"github.com/docker/docker/pkg/archive"
)
type ImageService struct{}
type IImageService interface {
2023-02-07 18:48:32 +08:00
Page(req dto.SearchWithPage) (int64, interface{}, error)
2022-10-12 18:55:47 +08:00
List() ([]dto.Options, error)
ImageBuild(req dto.ImageBuild) (string, error)
ImagePull(req dto.ImagePull) (string, error)
ImageLoad(req dto.ImageLoad) error
ImageSave(req dto.ImageSave) error
ImagePush(req dto.ImagePush) (string, error)
2022-10-11 17:46:52 +08:00
ImageRemove(req dto.BatchDelete) error
2023-03-28 18:00:06 +08:00
ImageTag(req dto.ImageTag) error
}
func NewIImageService() IImageService {
return &ImageService{}
}
2023-02-07 18:48:32 +08:00
func (u *ImageService) Page(req dto.SearchWithPage) (int64, interface{}, error) {
var (
list []types.ImageSummary
records []dto.ImageInfo
backDatas []dto.ImageInfo
)
client, err := docker.NewDockerClient()
if err != nil {
return 0, nil, err
}
2022-10-12 18:55:47 +08:00
list, err = client.ImageList(context.Background(), types.ImageListOptions{})
if err != nil {
return 0, nil, err
}
2023-02-07 18:48:32 +08:00
if len(req.Info) != 0 {
length, count := len(list), 0
for count < length {
2023-02-07 18:48:32 +08:00
hasTag := false
for _, tag := range list[count].RepoTags {
if strings.Contains(tag, req.Info) {
hasTag = true
break
}
}
if !hasTag {
list = append(list[:count], list[(count+1):]...)
length--
2023-02-07 18:48:32 +08:00
} else {
count++
}
}
}
for _, image := range list {
size := formatFileSize(image.Size)
2022-10-11 17:46:52 +08:00
records = append(records, dto.ImageInfo{
ID: image.ID,
Tags: image.RepoTags,
CreatedAt: time.Unix(image.Created, 0),
Size: size,
})
}
total, start, end := len(records), (req.Page-1)*req.PageSize, req.Page*req.PageSize
if start > total {
backDatas = make([]dto.ImageInfo, 0)
} else {
if end >= total {
end = total
}
backDatas = records[start:end]
}
return int64(total), backDatas, nil
}
2022-10-12 18:55:47 +08:00
func (u *ImageService) List() ([]dto.Options, error) {
var (
list []types.ImageSummary
backDatas []dto.Options
)
client, err := docker.NewDockerClient()
if err != nil {
return nil, err
}
list, err = client.ImageList(context.Background(), types.ImageListOptions{})
if err != nil {
return nil, err
}
for _, image := range list {
for _, tag := range image.RepoTags {
backDatas = append(backDatas, dto.Options{
Option: tag,
})
}
}
return backDatas, nil
}
2022-10-12 13:42:58 +08:00
func (u *ImageService) ImageBuild(req dto.ImageBuild) (string, error) {
client, err := docker.NewDockerClient()
if err != nil {
return "", err
}
fileName := "Dockerfile"
2022-10-12 13:42:58 +08:00
if req.From == "edit" {
2023-03-14 14:28:03 +08:00
dir := fmt.Sprintf("%s/docker/build/%s", constant.DataDir, strings.ReplaceAll(req.Name, ":", "_"))
2022-10-12 13:42:58 +08:00
if _, err := os.Stat(dir); err != nil && os.IsNotExist(err) {
if err = os.MkdirAll(dir, os.ModePerm); err != nil {
return "", err
}
}
2022-10-11 14:20:51 +08:00
pathItem := fmt.Sprintf("%s/Dockerfile", dir)
file, err := os.OpenFile(pathItem, os.O_WRONLY|os.O_CREATE|os.O_TRUNC, 0666)
2022-10-12 13:42:58 +08:00
if err != nil {
return "", err
}
defer file.Close()
write := bufio.NewWriter(file)
_, _ = write.WriteString(string(req.Dockerfile))
write.Flush()
req.Dockerfile = dir
2023-03-14 14:28:03 +08:00
} else {
fileName = path.Base(req.Dockerfile)
req.Dockerfile = path.Dir(req.Dockerfile)
2022-10-12 13:42:58 +08:00
}
tar, err := archive.TarWithOptions(req.Dockerfile+"/", &archive.TarOptions{})
if err != nil {
return "", err
}
opts := types.ImageBuildOptions{
Dockerfile: fileName,
2022-10-12 13:42:58 +08:00
Tags: []string{req.Name},
Remove: true,
Labels: stringsToMap(req.Tags),
}
logName := fmt.Sprintf("%s/build.log", req.Dockerfile)
pathItem := logName
file, err := os.OpenFile(pathItem, os.O_WRONLY|os.O_CREATE|os.O_TRUNC, 0666)
2022-10-12 13:42:58 +08:00
if err != nil {
return "", err
}
go func() {
defer file.Close()
defer tar.Close()
2023-03-14 14:28:03 +08:00
res, err := client.ImageBuild(context.Background(), tar, opts)
2022-10-12 13:42:58 +08:00
if err != nil {
global.LOG.Errorf("build image %s failed, err: %v", req.Name, err)
_, _ = file.WriteString("image build failed!")
2022-10-12 13:42:58 +08:00
return
}
defer res.Body.Close()
body, err := io.ReadAll(res.Body)
2023-03-14 14:28:03 +08:00
if err != nil {
global.LOG.Errorf("build image %s failed, err: %v", req.Name, err)
_, _ = file.WriteString(fmt.Sprintf("build image %s failed, err: %v", req.Name, err))
_, _ = file.WriteString("image build failed!")
return
}
if strings.Contains(string(body), "errorDetail") || strings.Contains(string(body), "error:") {
2023-03-14 14:28:03 +08:00
global.LOG.Errorf("build image %s failed", req.Name)
_, _ = file.Write(body)
_, _ = file.WriteString("image build failed!")
return
}
global.LOG.Infof("build image %s successful!", req.Name)
_, _ = file.Write(body)
_, _ = file.WriteString("image build successful!")
2022-10-12 13:42:58 +08:00
}()
return logName, nil
2022-10-11 14:20:51 +08:00
}
func (u *ImageService) ImagePull(req dto.ImagePull) (string, error) {
client, err := docker.NewDockerClient()
if err != nil {
return "", err
}
dockerLogDir := global.CONF.System.TmpDir + "/docker_logs"
if _, err := os.Stat(dockerLogDir); err != nil && os.IsNotExist(err) {
if err = os.MkdirAll(dockerLogDir, os.ModePerm); err != nil {
return "", err
}
}
imageItemName := strings.ReplaceAll(path.Base(req.ImageName), ":", "_")
pathItem := fmt.Sprintf("%s/image_pull_%s_%s.log", dockerLogDir, imageItemName, time.Now().Format("20060102150405"))
file, err := os.OpenFile(pathItem, os.O_WRONLY|os.O_CREATE|os.O_TRUNC, 0666)
if err != nil {
return "", err
}
if req.RepoID == 0 {
go func() {
defer file.Close()
out, err := client.ImagePull(context.TODO(), req.ImageName, types.ImagePullOptions{})
if err != nil {
global.LOG.Errorf("image %s pull failed, err: %v", req.ImageName, err)
return
}
defer out.Close()
global.LOG.Infof("pull image %s successful!", req.ImageName)
_, _ = io.Copy(file, out)
}()
return pathItem, nil
}
repo, err := imageRepoRepo.Get(commonRepo.WithByID(req.RepoID))
if err != nil {
return "", err
}
options := types.ImagePullOptions{}
if repo.Auth {
authConfig := types.AuthConfig{
Username: repo.Username,
Password: repo.Password,
}
encodedJSON, err := json.Marshal(authConfig)
if err != nil {
return "", err
}
authStr := base64.URLEncoding.EncodeToString(encodedJSON)
options.RegistryAuth = authStr
}
image := repo.DownloadUrl + "/" + req.ImageName
go func() {
defer file.Close()
out, err := client.ImagePull(context.TODO(), image, options)
if err != nil {
_, _ = file.WriteString("image pull failed!")
global.LOG.Errorf("image %s pull failed, err: %v", image, err)
return
}
defer out.Close()
global.LOG.Infof("pull image %s successful!", req.ImageName)
_, _ = io.Copy(file, out)
_, _ = file.WriteString("image pull successful!")
}()
return pathItem, nil
}
func (u *ImageService) ImageLoad(req dto.ImageLoad) error {
file, err := os.Open(req.Path)
if err != nil {
return err
}
defer file.Close()
client, err := docker.NewDockerClient()
if err != nil {
return err
}
2023-03-10 18:05:02 +08:00
res, err := client.ImageLoad(context.TODO(), file, true)
if err != nil {
return err
}
content, err := io.ReadAll(res.Body)
2023-03-10 18:05:02 +08:00
if err != nil {
return err
}
if strings.Contains(string(content), "Error") {
return errors.New(string(content))
}
return nil
}
func (u *ImageService) ImageSave(req dto.ImageSave) error {
2022-10-11 17:46:52 +08:00
client, err := docker.NewDockerClient()
if err != nil {
return err
}
out, err := client.ImageSave(context.TODO(), []string{req.TagName})
if err != nil {
return err
}
defer out.Close()
file, err := os.OpenFile(fmt.Sprintf("%s/%s.tar", req.Path, req.Name), os.O_WRONLY|os.O_CREATE|os.O_EXCL, 0666)
if err != nil {
return err
}
defer file.Close()
2022-10-11 17:46:52 +08:00
if _, err = io.Copy(file, out); err != nil {
return err
}
2022-10-11 17:46:52 +08:00
return nil
}
2022-10-11 17:46:52 +08:00
func (u *ImageService) ImageTag(req dto.ImageTag) error {
client, err := docker.NewDockerClient()
if err != nil {
return err
}
2022-10-11 17:46:52 +08:00
if err := client.ImageTag(context.TODO(), req.SourceID, req.TargetName); err != nil {
return err
}
return nil
}
func (u *ImageService) ImagePush(req dto.ImagePush) (string, error) {
client, err := docker.NewDockerClient()
if err != nil {
return "", err
}
repo, err := imageRepoRepo.Get(commonRepo.WithByID(req.RepoID))
if err != nil {
return "", err
}
options := types.ImagePushOptions{}
if repo.Auth {
authConfig := types.AuthConfig{
Username: repo.Username,
Password: repo.Password,
}
encodedJSON, err := json.Marshal(authConfig)
if err != nil {
return "", err
}
authStr := base64.URLEncoding.EncodeToString(encodedJSON)
options.RegistryAuth = authStr
}
2022-10-11 17:46:52 +08:00
newName := fmt.Sprintf("%s/%s", repo.DownloadUrl, req.Name)
if newName != req.TagName {
if err := client.ImageTag(context.TODO(), req.TagName, newName); err != nil {
return "", err
2022-10-11 14:20:51 +08:00
}
}
dockerLogDir := global.CONF.System.TmpDir + "/docker_logs"
if _, err := os.Stat(dockerLogDir); err != nil && os.IsNotExist(err) {
if err = os.MkdirAll(dockerLogDir, os.ModePerm); err != nil {
return "", err
}
}
imageItemName := strings.ReplaceAll(path.Base(req.Name), ":", "_")
pathItem := fmt.Sprintf("%s/image_push_%s_%s.log", dockerLogDir, imageItemName, time.Now().Format("20060102150405"))
file, err := os.OpenFile(pathItem, os.O_WRONLY|os.O_CREATE|os.O_TRUNC, 0666)
if err != nil {
return "", err
}
go func() {
defer file.Close()
out, err := client.ImagePush(context.TODO(), newName, options)
if err != nil {
2022-10-11 17:46:52 +08:00
global.LOG.Errorf("image %s push failed, err: %v", req.TagName, err)
_, _ = file.WriteString("image push failed!")
return
}
defer out.Close()
global.LOG.Infof("push image %s successful!", req.Name)
_, _ = io.Copy(file, out)
_, _ = file.WriteString("image push successful!")
}()
return pathItem, nil
}
2022-10-11 17:46:52 +08:00
func (u *ImageService) ImageRemove(req dto.BatchDelete) error {
client, err := docker.NewDockerClient()
if err != nil {
return err
}
for _, id := range req.Names {
if _, err := client.ImageRemove(context.TODO(), id, types.ImageRemoveOptions{Force: true, PruneChildren: true}); err != nil {
if strings.Contains(err.Error(), "image is being used") {
if strings.Contains(id, "sha256:") {
return buserr.New(constant.ErrObjectInUsed)
}
return buserr.WithDetail(constant.ErrInUsed, id, nil)
}
2022-10-11 17:46:52 +08:00
return err
}
}
return nil
}
func formatFileSize(fileSize int64) (size string) {
if fileSize < 1024 {
return fmt.Sprintf("%.2fB", float64(fileSize)/float64(1))
} else if fileSize < (1024 * 1024) {
return fmt.Sprintf("%.2fKB", float64(fileSize)/float64(1024))
} else if fileSize < (1024 * 1024 * 1024) {
return fmt.Sprintf("%.2fMB", float64(fileSize)/float64(1024*1024))
} else if fileSize < (1024 * 1024 * 1024 * 1024) {
return fmt.Sprintf("%.2fGB", float64(fileSize)/float64(1024*1024*1024))
} else if fileSize < (1024 * 1024 * 1024 * 1024 * 1024) {
return fmt.Sprintf("%.2fTB", float64(fileSize)/float64(1024*1024*1024*1024))
} else {
return fmt.Sprintf("%.2fEB", float64(fileSize)/float64(1024*1024*1024*1024*1024))
}
}