415 lines
8.7 KiB
Go
415 lines
8.7 KiB
Go
package cmd
|
|
|
|
import (
|
|
"archive/tar"
|
|
"compress/gzip"
|
|
"encoding/binary"
|
|
"fmt"
|
|
"io"
|
|
"net"
|
|
"os"
|
|
"path/filepath"
|
|
"runtime"
|
|
"syscall"
|
|
"time"
|
|
"unsafe"
|
|
|
|
"github.com/charmbracelet/bubbles/progress"
|
|
tea "github.com/charmbracelet/bubbletea"
|
|
"github.com/charmbracelet/lipgloss"
|
|
"github.com/spf13/cobra"
|
|
"golang.org/x/sys/unix"
|
|
)
|
|
|
|
var (
|
|
source string
|
|
target string
|
|
)
|
|
|
|
var createCmd = &cobra.Command{
|
|
Use: "create",
|
|
Short: "Create a new backup",
|
|
Long: "Create a new backup of a file, directory, or disk",
|
|
Run: func(cmd *cobra.Command, args []string) {
|
|
model, err := initialModel(source, target)
|
|
if err != nil {
|
|
fmt.Println("Error:", err)
|
|
os.Exit(1)
|
|
}
|
|
|
|
p := tea.NewProgram(model, tea.WithAltScreen())
|
|
if _, err := p.Run(); err != nil {
|
|
fmt.Println("Error:", err)
|
|
os.Exit(1)
|
|
}
|
|
},
|
|
}
|
|
|
|
type model struct {
|
|
progress progress.Model
|
|
source string
|
|
target string
|
|
totalBytes int64
|
|
processed int64
|
|
done bool
|
|
err error
|
|
startTime time.Time
|
|
progressCh chan int64
|
|
isDirectory bool
|
|
isNetworkTarget bool
|
|
}
|
|
|
|
type progressMsg int64
|
|
type doneMsg struct{}
|
|
type errorMsg struct{ err error }
|
|
|
|
// getPathSize возвращает размер файла, диска или директории
|
|
func getPathSize(path string) (int64, error) {
|
|
fileInfo, err := os.Stat(path)
|
|
if err != nil {
|
|
return 0, err
|
|
}
|
|
|
|
// Для Linux: проверка, является ли источник блочным устройством
|
|
if runtime.GOOS == "linux" {
|
|
stat, ok := fileInfo.Sys().(*syscall.Stat_t)
|
|
if ok && (stat.Mode&syscall.S_IFMT) == syscall.S_IFBLK {
|
|
f, err := os.Open(path)
|
|
if err != nil {
|
|
return 0, err
|
|
}
|
|
defer f.Close()
|
|
|
|
var size uint64
|
|
_, _, errno := unix.Syscall(
|
|
unix.SYS_IOCTL,
|
|
f.Fd(),
|
|
unix.BLKGETSIZE64,
|
|
uintptr(unsafe.Pointer(&size)),
|
|
)
|
|
if errno != 0 {
|
|
return 0, fmt.Errorf("ioctl BLKGETSIZE64 failed: %v", errno)
|
|
}
|
|
return int64(size), nil
|
|
}
|
|
}
|
|
|
|
// Для директорий
|
|
if fileInfo.IsDir() {
|
|
var total int64
|
|
err := filepath.Walk(path, func(_ string, info os.FileInfo, err error) error {
|
|
if err != nil {
|
|
return err
|
|
}
|
|
if !info.IsDir() {
|
|
total += info.Size()
|
|
}
|
|
return nil
|
|
})
|
|
return total, err
|
|
}
|
|
|
|
// Для обычных файлов
|
|
return fileInfo.Size(), nil
|
|
}
|
|
|
|
func initialModel(src, dst string) (*model, error) {
|
|
totalBytes, err := getPathSize(src)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
|
|
p := progress.New(
|
|
progress.WithDefaultGradient(),
|
|
progress.WithWidth(40),
|
|
)
|
|
|
|
srcInfo, err := os.Stat(src)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
isDirectory := srcInfo.IsDir()
|
|
networkTarget := isNetworkAddress(dst)
|
|
targetPath := dst
|
|
|
|
if !networkTarget {
|
|
if isDirectory {
|
|
if filepath.Ext(targetPath) != ".tar.gz" {
|
|
targetPath += ".tar.gz"
|
|
}
|
|
} else { // Это файл или диск
|
|
if filepath.Ext(targetPath) != ".gz" {
|
|
targetPath += ".gz"
|
|
}
|
|
}
|
|
}
|
|
|
|
return &model{
|
|
progress: p,
|
|
source: src,
|
|
target: targetPath,
|
|
totalBytes: totalBytes,
|
|
startTime: time.Now(),
|
|
progressCh: make(chan int64, 100),
|
|
isDirectory: isDirectory,
|
|
isNetworkTarget: networkTarget,
|
|
}, nil
|
|
}
|
|
|
|
func (m *model) Init() tea.Cmd {
|
|
return tea.Batch(
|
|
m.startBackup,
|
|
m.progressListener,
|
|
)
|
|
}
|
|
|
|
// getTargetWriter создает io.WriteCloser для файла или сетевого подключения
|
|
func (m *model) getTargetWriter() (io.WriteCloser, error) {
|
|
if m.isNetworkTarget {
|
|
conn, err := net.DialTimeout("tcp", m.target, 10*time.Second)
|
|
if err != nil {
|
|
return nil, fmt.Errorf("failed to connect to %s: %w", m.target, err)
|
|
}
|
|
|
|
// Протокол: сначала отправляем 8 байт (размер) и 1 байт (тип)
|
|
// 1. Общий размер (int64)
|
|
if err := binary.Write(conn, binary.BigEndian, m.totalBytes); err != nil {
|
|
conn.Close()
|
|
return nil, fmt.Errorf("failed to send backup size: %w", err)
|
|
}
|
|
// 2. Тип бэкапа (1 = директория, 0 = файл/диск)
|
|
var typeByte byte = 0
|
|
if m.isDirectory {
|
|
typeByte = 1
|
|
}
|
|
if _, err := conn.Write([]byte{typeByte}); err != nil {
|
|
conn.Close()
|
|
return nil, fmt.Errorf("failed to send backup type: %w", err)
|
|
}
|
|
|
|
return conn, nil
|
|
}
|
|
// Логика для локального файла
|
|
return os.Create(m.target)
|
|
}
|
|
|
|
func (m *model) startBackup() tea.Msg {
|
|
go func() {
|
|
targetWriter, err := m.getTargetWriter()
|
|
if err != nil {
|
|
m.err = err
|
|
m.progressCh <- -1
|
|
return
|
|
}
|
|
defer targetWriter.Close()
|
|
|
|
var backupErr error
|
|
if m.isDirectory {
|
|
backupErr = m.backupDirectory(targetWriter)
|
|
} else {
|
|
backupErr = m.backupFileOrDisk(targetWriter)
|
|
}
|
|
|
|
if backupErr != nil {
|
|
m.err = backupErr
|
|
m.progressCh <- -1
|
|
return
|
|
}
|
|
|
|
m.progressCh <- -2 // Сигнал завершения
|
|
}()
|
|
|
|
return nil
|
|
}
|
|
|
|
func (m *model) backupFileOrDisk(w io.Writer) error {
|
|
srcFile, err := os.Open(m.source)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
defer srcFile.Close()
|
|
|
|
gzipWriter := gzip.NewWriter(w)
|
|
defer gzipWriter.Close()
|
|
|
|
buf := make([]byte, 32*1024) // 32KB buffer
|
|
for {
|
|
n, err := srcFile.Read(buf)
|
|
if n > 0 {
|
|
if _, writeErr := gzipWriter.Write(buf[:n]); writeErr != nil {
|
|
return writeErr
|
|
}
|
|
m.progressCh <- int64(n)
|
|
}
|
|
if err == io.EOF {
|
|
break
|
|
}
|
|
if err != nil {
|
|
return err
|
|
}
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (m *model) backupDirectory(w io.Writer) error {
|
|
gzipWriter := gzip.NewWriter(w)
|
|
defer gzipWriter.Close()
|
|
|
|
tarWriter := tar.NewWriter(gzipWriter)
|
|
defer tarWriter.Close()
|
|
|
|
return filepath.Walk(m.source, func(file string, fi os.FileInfo, err error) error {
|
|
if err != nil {
|
|
return err
|
|
}
|
|
|
|
header, err := tar.FileInfoHeader(fi, file)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
|
|
relPath, err := filepath.Rel(m.source, file)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
header.Name = relPath
|
|
|
|
if err := tarWriter.WriteHeader(header); err != nil {
|
|
return err
|
|
}
|
|
|
|
if !fi.Mode().IsRegular() {
|
|
return nil
|
|
}
|
|
|
|
srcFile, err := os.Open(file)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
defer srcFile.Close()
|
|
|
|
buf := make([]byte, 32*1024)
|
|
for {
|
|
n, err := srcFile.Read(buf)
|
|
if n > 0 {
|
|
if _, err := tarWriter.Write(buf[:n]); err != nil {
|
|
return err
|
|
}
|
|
m.progressCh <- int64(n)
|
|
}
|
|
if err == io.EOF {
|
|
break
|
|
}
|
|
if err != nil {
|
|
return err
|
|
}
|
|
}
|
|
return nil
|
|
})
|
|
}
|
|
|
|
func (m *model) progressListener() tea.Msg {
|
|
select {
|
|
case n := <-m.progressCh:
|
|
switch {
|
|
case n == -1: // Ошибка
|
|
return errorMsg{m.err}
|
|
case n == -2: // Завершение
|
|
return doneMsg{}
|
|
default: // Прогресс
|
|
m.processed += n
|
|
return progressMsg(m.processed)
|
|
}
|
|
}
|
|
}
|
|
|
|
func (m *model) Update(msg tea.Msg) (tea.Model, tea.Cmd) {
|
|
switch msg := msg.(type) {
|
|
case tea.KeyMsg:
|
|
if msg.Type == tea.KeyCtrlC {
|
|
return m, tea.Quit
|
|
}
|
|
return m, nil
|
|
|
|
case tea.WindowSizeMsg:
|
|
m.progress.Width = msg.Width - 4
|
|
return m, nil
|
|
|
|
case progressMsg:
|
|
progressVal := float64(msg) / float64(m.totalBytes)
|
|
if progressVal > 1.0 {
|
|
progressVal = 1.0
|
|
}
|
|
cmd := m.progress.SetPercent(progressVal)
|
|
return m, tea.Batch(cmd, m.progressListener)
|
|
|
|
case doneMsg:
|
|
m.done = true
|
|
cmd := m.progress.SetPercent(1.0)
|
|
return m, tea.Batch(cmd, tea.Quit)
|
|
|
|
case errorMsg:
|
|
m.err = msg.err
|
|
return m, tea.Quit
|
|
}
|
|
|
|
return m, nil
|
|
}
|
|
|
|
func (m *model) View() string {
|
|
if m.err != nil {
|
|
return fmt.Sprintf("\n❌ Error: %v\n\n", m.err)
|
|
}
|
|
|
|
if m.done {
|
|
duration := time.Since(m.startTime)
|
|
// ratio := float64(m.processed) / float64(m.totalBytes) * 100
|
|
backupType := "File/disk"
|
|
if m.isDirectory {
|
|
backupType = "Directory"
|
|
}
|
|
if m.isNetworkTarget {
|
|
backupType += " network"
|
|
}
|
|
|
|
return fmt.Sprintf("\n✅ %s backup complete!\n\n"+
|
|
"Source: %s\n"+
|
|
"Target: %s\n"+
|
|
"Size: %s\n"+
|
|
"Time: %v\n\n",
|
|
backupType, m.source, m.target,
|
|
formatBytes(m.processed),
|
|
duration.Round(time.Millisecond))
|
|
}
|
|
|
|
operation := "Backing up"
|
|
if m.isDirectory {
|
|
operation = "Archiving"
|
|
}
|
|
if m.isNetworkTarget {
|
|
operation = "Sending"
|
|
}
|
|
|
|
title := fmt.Sprintf("%s %s → %s", operation, m.source, m.target)
|
|
progressVal := float64(m.processed) / float64(m.totalBytes)
|
|
progressView := m.progress.ViewAs(progressVal)
|
|
stats := fmt.Sprintf("%s / %s (%.1f%%)", formatBytes(m.processed), formatBytes(m.totalBytes), progressVal*100)
|
|
|
|
return lipgloss.JoinVertical(lipgloss.Left,
|
|
title,
|
|
"",
|
|
progressView,
|
|
"",
|
|
stats,
|
|
"\nPress Ctrl+C to cancel",
|
|
)
|
|
}
|
|
|
|
func init() {
|
|
rootCmd.AddCommand(createCmd)
|
|
createCmd.Flags().StringVarP(&source, "source", "s", "", "Source file, directory or disk (e.g., /dev/sda) (required)")
|
|
createCmd.Flags().StringVarP(&target, "target", "t", "", "Target backup file or network address (e.g., /path/to/backup.tar.gz or 127.0.0.1:8080) (required)")
|
|
createCmd.MarkFlagRequired("source")
|
|
createCmd.MarkFlagRequired("target")
|
|
}
|