137 lines
3.1 KiB
Go
137 lines
3.1 KiB
Go
package backup
|
|
|
|
import (
|
|
"fmt"
|
|
"github.com/apex/log"
|
|
"github.com/pterodactyl/wings/api"
|
|
"github.com/pterodactyl/wings/server/filesystem"
|
|
"io"
|
|
"net/http"
|
|
"os"
|
|
"strconv"
|
|
)
|
|
|
|
type S3Backup struct {
|
|
Backup
|
|
}
|
|
|
|
var _ BackupInterface = (*S3Backup)(nil)
|
|
|
|
// Generates a new backup on the disk, moves it into the S3 bucket via the provided
|
|
// presigned URL, and then deletes the backup from the disk.
|
|
func (s *S3Backup) Generate(basePath, ignore string) (*ArchiveDetails, error) {
|
|
defer s.Remove()
|
|
|
|
a := &filesystem.Archive{
|
|
BasePath: basePath,
|
|
Ignore: ignore,
|
|
}
|
|
|
|
if err := a.Create(s.Path()); err != nil {
|
|
return nil, err
|
|
}
|
|
|
|
rc, err := os.Open(s.Path())
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
defer rc.Close()
|
|
|
|
if err := s.generateRemoteRequest(rc); err != nil {
|
|
return nil, err
|
|
}
|
|
|
|
return s.Details(), nil
|
|
}
|
|
|
|
// Removes a backup from the system.
|
|
func (s *S3Backup) Remove() error {
|
|
return os.Remove(s.Path())
|
|
}
|
|
|
|
// Reader provides a wrapper around an existing io.Reader
|
|
// but implements io.Closer in order to satisfy an io.ReadCloser.
|
|
type Reader struct {
|
|
io.Reader
|
|
}
|
|
|
|
func (Reader) Close() error {
|
|
return nil
|
|
}
|
|
|
|
// Generates the remote S3 request and begins the upload.
|
|
func (s *S3Backup) generateRemoteRequest(rc io.ReadCloser) error {
|
|
defer rc.Close()
|
|
|
|
size, err := s.Backup.Size()
|
|
if err != nil {
|
|
return err
|
|
}
|
|
|
|
urls, err := api.New().GetBackupRemoteUploadURLs(s.Backup.Uuid, size)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
|
|
l := log.WithFields(log.Fields{
|
|
"backup_id": s.Uuid,
|
|
"adapter": "s3",
|
|
})
|
|
|
|
l.Info("attempting to upload backup..")
|
|
|
|
handlePart := func(part string, size int64) (string, error) {
|
|
r, err := http.NewRequest(http.MethodPut, part, nil)
|
|
if err != nil {
|
|
return "", err
|
|
}
|
|
|
|
r.ContentLength = size
|
|
r.Header.Add("Content-Length", strconv.Itoa(int(size)))
|
|
r.Header.Add("Content-Type", "application/x-gzip")
|
|
|
|
// Limit the reader to the size of the part.
|
|
r.Body = Reader{Reader: io.LimitReader(rc, size)}
|
|
|
|
// This http request can block forever due to it not having a timeout,
|
|
// but we are uploading up to 5GB of data, so there is not really
|
|
// a good way to handle a timeout on this.
|
|
res, err := http.DefaultClient.Do(r)
|
|
if err != nil {
|
|
return "", err
|
|
}
|
|
defer res.Body.Close()
|
|
|
|
// Handle non-200 status codes.
|
|
if res.StatusCode != http.StatusOK {
|
|
return "", fmt.Errorf("failed to put S3 object part, %d:%s", res.StatusCode, res.Status)
|
|
}
|
|
|
|
// Get the ETag from the uploaded part, this should be sent with the CompleteMultipartUpload request.
|
|
return res.Header.Get("ETag"), nil
|
|
}
|
|
|
|
partCount := len(urls.Parts)
|
|
for i, part := range urls.Parts {
|
|
// Get the size for the current part.
|
|
var partSize int64
|
|
if i+1 < partCount {
|
|
partSize = urls.PartSize
|
|
} else {
|
|
// This is the remaining size for the last part,
|
|
// there is not a minimum size limit for the last part.
|
|
partSize = size - (int64(i) * urls.PartSize)
|
|
}
|
|
|
|
// Attempt to upload the part.
|
|
if _, err := handlePart(part, partSize); err != nil {
|
|
l.WithField("part_id", part).WithError(err).Warn("failed to upload part")
|
|
return err
|
|
}
|
|
}
|
|
|
|
l.WithField("parts", partCount).Info("backup has been successfully uploaded")
|
|
|
|
return nil
|
|
}
|