added live time network backup and restore

This commit is contained in:
wt committed 2025-08-02 17:34:26 +07:00
1 parent 3bef3f76e9
commit 1e3cc446e0
3 files changed
+276 -194

No files matched your search

+125 -97
View File
@@ -3,8 +3,10 @@ package cmd
import ( import (
"archive/tar" "archive/tar"
"compress/gzip" "compress/gzip"
"encoding/binary"
"fmt" "fmt"
"io" "io"
"net"
"os" "os"
"path/filepath" "path/filepath"
"runtime" "runtime"
@@ -44,23 +46,24 @@ var createCmd = &cobra.Command{
} }
type model struct { type model struct {
progress progress.Model progress progress.Model
source string source string
target string target string
totalBytes int64 totalBytes int64
processed int64 processed int64
done bool done bool
err error err error
startTime time.Time startTime time.Time
progressCh chan int64 progressCh chan int64
isDirectory bool isDirectory bool
isNetworkTarget bool
} }
type progressMsg int64 type progressMsg int64
type doneMsg struct{} type doneMsg struct{}
type errorMsg struct{ err error } type errorMsg struct{ err error }
// getFileSize возвращает размер файла, диска или директории // getPathSize возвращает размер файла, диска или директории
func getPathSize(path string) (int64, error) { func getPathSize(path string) (int64, error) {
fileInfo, err := os.Stat(path) fileInfo, err := os.Stat(path)
if err != nil { if err != nil {
@@ -121,26 +124,35 @@ func initialModel(src, dst string) (*model, error) {
progress.WithWidth(40), progress.WithWidth(40),
) )
// Проверяем, является ли источник директорией
srcInfo, err := os.Stat(src) srcInfo, err := os.Stat(src)
if err != nil { if err != nil {
return nil, err return nil, err
} }
isDirectory := srcInfo.IsDir()
// Добавляем расширение .tar.gz для директорий networkTarget := isNetworkAddress(dst)
targetPath := dst targetPath := dst
if srcInfo.IsDir() && filepath.Ext(targetPath) != ".tar.gz" {
targetPath += ".tar.gz" if !networkTarget {
if isDirectory {
if filepath.Ext(targetPath) != ".tar.gz" {
targetPath += ".tar.gz"
}
} else { // Это файл или диск
if filepath.Ext(targetPath) != ".gz" {
targetPath += ".gz"
}
}
} }
return &model{ return &model{
progress: p, progress: p,
source: src, source: src,
target: targetPath, target: targetPath,
totalBytes: totalBytes, totalBytes: totalBytes,
startTime: time.Now(), startTime: time.Now(),
progressCh: make(chan int64, 100), progressCh: make(chan int64, 100),
isDirectory: srcInfo.IsDir(), isDirectory: isDirectory,
isNetworkTarget: networkTarget,
}, nil }, nil
} }
@@ -151,57 +163,58 @@ func (m *model) Init() tea.Cmd {
) )
} }
// 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 { func (m *model) startBackup() tea.Msg {
go func() { 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 { if m.isDirectory {
err := m.backupDirectory() backupErr = m.backupDirectory(targetWriter)
if err != nil { } else {
m.progressCh <- -1 backupErr = m.backupFileOrDisk(targetWriter)
return
}
m.progressCh <- -2
return
} }
m.target += ".gz"
// Обработка файлов и дисков if backupErr != nil {
srcFile, err := os.Open(m.source) m.err = backupErr
if err != nil {
m.progressCh <- -1 m.progressCh <- -1
return return
} }
defer srcFile.Close()
dstFile, err := os.Create(m.target)
if err != nil {
m.progressCh <- -1
return
}
defer dstFile.Close()
gzipWriter := gzip.NewWriter(dstFile)
defer gzipWriter.Close()
buf := make([]byte, 32*1024) // 32KB buffer
for {
n, err := srcFile.Read(buf)
if n > 0 {
_, writeErr := gzipWriter.Write(buf[:n])
if writeErr != nil {
m.progressCh <- -1
return
}
m.progressCh <- int64(n)
}
if err == io.EOF {
break
}
if err != nil {
m.progressCh <- -1
return
}
}
m.progressCh <- -2 // Сигнал завершения m.progressCh <- -2 // Сигнал завершения
}() }()
@@ -209,14 +222,37 @@ func (m *model) startBackup() tea.Msg {
return nil return nil
} }
func (m *model) backupDirectory() error { func (m *model) backupFileOrDisk(w io.Writer) error {
dstFile, err := os.Create(m.target) srcFile, err := os.Open(m.source)
if err != nil { if err != nil {
return err return err
} }
defer dstFile.Close() defer srcFile.Close()
gzipWriter := gzip.NewWriter(dstFile) 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() defer gzipWriter.Close()
tarWriter := tar.NewWriter(gzipWriter) tarWriter := tar.NewWriter(gzipWriter)
@@ -227,37 +263,31 @@ func (m *model) backupDirectory() error {
return err return err
} }
// Создаем заголовок для файла/директории
header, err := tar.FileInfoHeader(fi, file) header, err := tar.FileInfoHeader(fi, file)
if err != nil { if err != nil {
return err return err
} }
// Устанавливаем относительный путь
relPath, err := filepath.Rel(m.source, file) relPath, err := filepath.Rel(m.source, file)
if err != nil { if err != nil {
return err return err
} }
header.Name = relPath header.Name = relPath
// Пишем заголовок в архив
if err := tarWriter.WriteHeader(header); err != nil { if err := tarWriter.WriteHeader(header); err != nil {
return err return err
} }
// Если это не обычный файл, пропускаем запись данных
if !fi.Mode().IsRegular() { if !fi.Mode().IsRegular() {
return nil return nil
} }
// Открываем файл для чтения
srcFile, err := os.Open(file) srcFile, err := os.Open(file)
if err != nil { if err != nil {
return err return err
} }
defer srcFile.Close() defer srcFile.Close()
// Копируем содержимое файла в архив
buf := make([]byte, 32*1024) buf := make([]byte, 32*1024)
for { for {
n, err := srcFile.Read(buf) n, err := srcFile.Read(buf)
@@ -267,16 +297,13 @@ func (m *model) backupDirectory() error {
} }
m.progressCh <- int64(n) m.progressCh <- int64(n)
} }
if err == io.EOF { if err == io.EOF {
break break
} }
if err != nil { if err != nil {
return err return err
} }
} }
return nil return nil
}) })
} }
@@ -286,7 +313,7 @@ func (m *model) progressListener() tea.Msg {
case n := <-m.progressCh: case n := <-m.progressCh:
switch { switch {
case n == -1: // Ошибка case n == -1: // Ошибка
return errorMsg{fmt.Errorf("backup error")} return errorMsg{m.err}
case n == -2: // Завершение case n == -2: // Завершение
return doneMsg{} return doneMsg{}
default: // Прогресс default: // Прогресс
@@ -309,21 +336,15 @@ func (m *model) Update(msg tea.Msg) (tea.Model, tea.Cmd) {
return m, nil return m, nil
case progressMsg: case progressMsg:
// Обновляем прогрессбар
progressVal := float64(msg) / float64(m.totalBytes) progressVal := float64(msg) / float64(m.totalBytes)
if progressVal > 1.0 { if progressVal > 1.0 {
progressVal = 1.0 progressVal = 1.0
} }
// Создаем команду для обновления прогрессбара
cmd := m.progress.SetPercent(progressVal) cmd := m.progress.SetPercent(progressVal)
// Продолжаем слушать обновления
return m, tea.Batch(cmd, m.progressListener) return m, tea.Batch(cmd, m.progressListener)
case doneMsg: case doneMsg:
m.done = true m.done = true
// Устанавливаем 100% и завершаем
cmd := m.progress.SetPercent(1.0) cmd := m.progress.SetPercent(1.0)
return m, tea.Batch(cmd, tea.Quit) return m, tea.Batch(cmd, tea.Quit)
@@ -342,27 +363,34 @@ func (m *model) View() string {
if m.done { if m.done {
duration := time.Since(m.startTime) duration := time.Since(m.startTime)
ratio := float64(m.processed) / float64(m.totalBytes) * 100 // ratio := float64(m.processed) / float64(m.totalBytes) * 100
backupType := "file/disk" backupType := "File/disk"
if m.isDirectory { if m.isDirectory {
backupType = "directory" backupType = "Directory"
}
if m.isNetworkTarget {
backupType += " network"
} }
return fmt.Sprintf("\n✅ %s backup complete!\n\n"+ return fmt.Sprintf("\n✅ %s backup complete!\n\n"+
"Source: %s\n"+ "Source: %s\n"+
"Backup: %s\n"+ "Target: %s\n"+
"Size: %s → %s (%.1f%%)\n"+ "Size: %s\n"+
"Time: %v\n\n", "Time: %v\n\n",
backupType, m.source, m.target, backupType, m.source, m.target,
formatBytes(m.totalBytes), formatBytes(m.processed), ratio, formatBytes(m.processed),
duration.Round(time.Millisecond)) duration.Round(time.Millisecond))
} }
backupType := "Backing up" operation := "Backing up"
if m.isDirectory { if m.isDirectory {
backupType = "Archiving" operation = "Archiving"
} }
title := fmt.Sprintf("%s %s → %s", backupType, m.source, m.target) if m.isNetworkTarget {
operation = "Sending"
}
title := fmt.Sprintf("%s %s → %s", operation, m.source, m.target)
progressVal := float64(m.processed) / float64(m.totalBytes) progressVal := float64(m.processed) / float64(m.totalBytes)
progressView := m.progress.ViewAs(progressVal) progressView := m.progress.ViewAs(progressVal)
stats := fmt.Sprintf("%s / %s (%.1f%%)", formatBytes(m.processed), formatBytes(m.totalBytes), progressVal*100) stats := fmt.Sprintf("%s / %s (%.1f%%)", formatBytes(m.processed), formatBytes(m.totalBytes), progressVal*100)
@@ -380,7 +408,7 @@ func (m *model) View() string {
func init() { func init() {
rootCmd.AddCommand(createCmd) rootCmd.AddCommand(createCmd)
createCmd.Flags().StringVarP(&source, "source", "s", "", "Source file, directory or disk (e.g., /dev/sda) (required)") 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 (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("source")
createCmd.MarkFlagRequired("target") createCmd.MarkFlagRequired("target")
} }
+142 -96
View File
@@ -3,8 +3,10 @@ package cmd
import ( import (
"archive/tar" "archive/tar"
"compress/gzip" "compress/gzip"
"encoding/binary"
"fmt" "fmt"
"io" "io"
"net"
"os" "os"
"path/filepath" "path/filepath"
"runtime" "runtime"
@@ -26,7 +28,7 @@ var (
var restoreCmd = &cobra.Command{ var restoreCmd = &cobra.Command{
Use: "restore", Use: "restore",
Short: "Restore a backup", Short: "Restore a backup",
Long: "Restore a backup from an archive to a file, disk, or directory.", Long: "Restore a backup from a local archive or network stream to a file, disk, or directory.",
Run: func(cmd *cobra.Command, args []string) { Run: func(cmd *cobra.Command, args []string) {
model, err := initialRestoreModel(restoreSource, restoreTarget) model, err := initialRestoreModel(restoreSource, restoreTarget)
if err != nil { if err != nil {
@@ -43,16 +45,18 @@ var restoreCmd = &cobra.Command{
} }
type restoreModel struct { type restoreModel struct {
progress progress.Model progress progress.Model
source string source string
target string target string
totalBytes int64 totalBytes int64
processed int64 processed int64
done bool done bool
err error err error
startTime time.Time startTime time.Time
progressCh chan int64 progressCh chan int64
isDirectory bool isDirectory bool
isNetworkSource bool
statusMessage string
} }
type restoreProgressMsg int64 type restoreProgressMsg int64
@@ -60,36 +64,50 @@ type restoreDoneMsg struct{}
type restoreErrorMsg struct{ err error } type restoreErrorMsg struct{ err error }
func initialRestoreModel(src, dst string) (*restoreModel, error) { func initialRestoreModel(src, dst string) (*restoreModel, error) {
fileInfo, err := os.Stat(src) isNetwork := isNetworkAddress(src)
if err != nil {
return nil, err
}
p := progress.New( p := progress.New(
progress.WithDefaultGradient(), progress.WithDefaultGradient(),
progress.WithWidth(40), progress.WithWidth(40),
) )
isDirectory := strings.HasSuffix(src, ".tar.gz") var totalBytes int64 = 1 // Placeholder for network source, to avoid division by zero.
var isDir bool
targetPath := dst targetPath := dst
status := "Initializing..."
if isDirectory && targetPath == "" { if isNetwork {
targetPath, err = os.Getwd() if targetPath == "" {
return nil, fmt.Errorf("target flag -t is required for a network source")
}
status = fmt.Sprintf("Listening on %s...", src)
} else {
fileInfo, err := os.Stat(src)
if err != nil { if err != nil {
return nil, fmt.Errorf("failed to get current directory: %w", err) return nil, fmt.Errorf("failed to stat source %s: %w", src, err)
}
totalBytes = fileInfo.Size()
isDir = strings.HasSuffix(src, ".tar.gz")
if isDir && targetPath == "" {
targetPath, err = os.Getwd()
if err != nil {
return nil, fmt.Errorf("failed to get current directory: %w", err)
}
} else if !isDir && targetPath == "" {
return nil, fmt.Errorf("target flag -t is required for file or disk restoration")
} }
} else if !isDirectory && targetPath == "" {
return nil, fmt.Errorf("target flag is required for file or disk restoration")
} }
return &restoreModel{ return &restoreModel{
progress: p, progress: p,
source: src, source: src,
target: targetPath, target: targetPath,
totalBytes: fileInfo.Size(), totalBytes: totalBytes,
startTime: time.Now(), startTime: time.Now(),
progressCh: make(chan int64, 100), progressCh: make(chan int64, 100),
isDirectory: isDirectory, isDirectory: isDir,
isNetworkSource: isNetwork,
statusMessage: status,
}, nil }, nil
} }
@@ -100,85 +118,108 @@ func (m *restoreModel) Init() tea.Cmd {
) )
} }
func (m *restoreModel) startRestore() tea.Msg { func (m *restoreModel) getSourceReader() (io.ReadCloser, error) {
go func() { if m.isNetworkSource {
if m.isDirectory { listener, err := net.Listen("tcp", m.source)
if err := m.restoreDirectory(); err != nil { if err != nil {
m.progressCh <- -1 // Error signal return nil, fmt.Errorf("failed to listen on %s: %w", m.source, err)
return }
} defer listener.Close() // Close listener after accepting one connection
m.progressCh <- -2 // Done signal
return m.statusMessage = fmt.Sprintf("Waiting for connection on %s", m.source)
// This is a blocking call
conn, err := listener.Accept()
if err != nil {
return nil, fmt.Errorf("failed to accept connection: %w", err)
}
m.statusMessage = "Client connected. Receiving data..."
// Protocol: Read 8 bytes for size, 1 byte for type
if err := binary.Read(conn, binary.BigEndian, &m.totalBytes); err != nil {
conn.Close()
return nil, fmt.Errorf("failed to read backup size: %w", err)
}
if m.totalBytes == 0 {
m.totalBytes = 1 // Avoid division by zero for empty files
} }
// Fallback to original file/disk restoration logic typeByte := make([]byte, 1)
srcFile, err := os.Open(m.source) if _, err := io.ReadFull(conn, typeByte); err != nil {
conn.Close()
return nil, fmt.Errorf("failed to read backup type: %w", err)
}
m.isDirectory = (typeByte[0] == 1)
return conn, nil
}
// Logic for local file
m.statusMessage = fmt.Sprintf("Opening archive %s", m.source)
return os.Open(m.source)
}
func (m *restoreModel) startRestore() tea.Msg {
go func() {
sourceReader, err := m.getSourceReader()
if err != nil { if err != nil {
m.err = err
m.progressCh <- -1 m.progressCh <- -1
return return
} }
defer srcFile.Close() defer sourceReader.Close()
progressReader := &restoreProgressReader{ progressReader := &restoreProgressReader{
reader: srcFile, reader: sourceReader,
total: m.totalBytes,
progressCh: m.progressCh, progressCh: m.progressCh,
} }
gzipReader, err := gzip.NewReader(progressReader) var restoreErr error
if err != nil { if m.isDirectory {
m.progressCh <- -1 restoreErr = m.restoreDirectory(progressReader)
return
}
defer gzipReader.Close()
var dstFile *os.File
if isBlockDevice(m.target) {
dstFile, err = os.OpenFile(m.target, os.O_WRONLY|os.O_SYNC, 0)
if err != nil {
m.progressCh <- -1
return
}
} else { } else {
dstFile, err = os.Create(m.target) restoreErr = m.restoreFileOrDisk(progressReader)
if err != nil {
m.progressCh <- -1
return
}
} }
defer dstFile.Close()
_, err = io.Copy(dstFile, gzipReader) if restoreErr != nil {
if err != nil { m.err = restoreErr
m.progressCh <- -1 m.progressCh <- -1
return return
} }
if err := dstFile.Sync(); err != nil { m.progressCh <- -2 // Done signal
m.progressCh <- -1
return
}
m.progressCh <- -2 // Сигнал завершения
}() }()
return nil return nil
} }
func (m *restoreModel) restoreDirectory() error { func (m *restoreModel) restoreFileOrDisk(r io.Reader) error {
srcFile, err := os.Open(m.source) gzipReader, err := gzip.NewReader(r)
if err != nil { if err != nil {
return err return err
} }
defer srcFile.Close() defer gzipReader.Close()
progressReader := &restoreProgressReader{ var dstFile *os.File
reader: srcFile, if isBlockDevice(m.target) {
total: m.totalBytes, dstFile, err = os.OpenFile(m.target, os.O_WRONLY|os.O_SYNC, 0)
progressCh: m.progressCh, } else {
if err := os.MkdirAll(filepath.Dir(m.target), 0755); err != nil {
return err
}
dstFile, err = os.Create(m.target)
} }
if err != nil {
return err
}
defer dstFile.Close()
gzipReader, err := gzip.NewReader(progressReader) if _, err = io.Copy(dstFile, gzipReader); err != nil {
return err
}
return dstFile.Sync()
}
func (m *restoreModel) restoreDirectory(r io.Reader) error {
gzipReader, err := gzip.NewReader(r)
if err != nil { if err != nil {
return err return err
} }
@@ -210,11 +251,14 @@ func (m *restoreModel) restoreDirectory() error {
if err != nil { if err != nil {
return err return err
} }
if _, err := io.Copy(outFile, tarReader); err != nil { _, copyErr := io.Copy(outFile, tarReader)
outFile.Close() closeErr := outFile.Close()
return err if copyErr != nil {
return copyErr
}
if closeErr != nil {
return closeErr
} }
outFile.Close()
} }
} }
return nil return nil
@@ -222,7 +266,6 @@ func (m *restoreModel) restoreDirectory() error {
type restoreProgressReader struct { type restoreProgressReader struct {
reader io.Reader reader io.Reader
total int64
progressCh chan int64 progressCh chan int64
read int64 read int64
} }
@@ -241,7 +284,10 @@ func (m *restoreModel) restoreProgressListener() tea.Msg {
case n := <-m.progressCh: case n := <-m.progressCh:
switch { switch {
case n == -1: // Ошибка case n == -1: // Ошибка
return restoreErrorMsg{fmt.Errorf("restoration error")} if m.err == nil {
m.err = fmt.Errorf("unknown restoration error")
}
return restoreErrorMsg{m.err}
case n == -2: // Завершение case n == -2: // Завершение
return restoreDoneMsg{} return restoreDoneMsg{}
default: // Прогресс default: // Прогресс
@@ -268,9 +314,7 @@ func (m *restoreModel) Update(msg tea.Msg) (tea.Model, tea.Cmd) {
if progressVal > 1.0 { if progressVal > 1.0 {
progressVal = 1.0 progressVal = 1.0
} }
cmd := m.progress.SetPercent(progressVal) cmd := m.progress.SetPercent(progressVal)
return m, tea.Batch(cmd, m.restoreProgressListener) return m, tea.Batch(cmd, m.restoreProgressListener)
case restoreDoneMsg: case restoreDoneMsg:
@@ -282,7 +326,6 @@ func (m *restoreModel) Update(msg tea.Msg) (tea.Model, tea.Cmd) {
m.err = msg.err m.err = msg.err
return m, tea.Quit return m, tea.Quit
} }
return m, nil return m, nil
} }
@@ -298,13 +341,19 @@ func (m *restoreModel) View() string {
restoreType = "Directory" restoreType = "Directory"
} }
return fmt.Sprintf("\n✅ %s restoration complete!\n\n"+ return fmt.Sprintf("\n✅ %s restoration complete!\n\n"+
"Archive: %s → %s\n"+ "Source: %s\n"+
"Target: %s\n"+
"Time: %v\n\n", "Time: %v\n\n",
restoreType, m.source, m.target, restoreType, m.source, m.target,
duration.Round(time.Millisecond)) duration.Round(time.Millisecond))
} }
title := fmt.Sprintf("Restoring %s → %s", m.source, m.target) // Show status message before progress starts
if m.processed == 0 && (m.isNetworkSource || m.statusMessage != "") {
return m.statusMessage + "\n\nPress Ctrl+C to cancel"
}
title := fmt.Sprintf("Restoring from %s → %s", m.source, m.target)
progressVal := float64(m.processed) / float64(m.totalBytes) progressVal := float64(m.processed) / float64(m.totalBytes)
progressView := m.progress.ViewAs(progressVal) progressView := m.progress.ViewAs(progressVal)
stats := fmt.Sprintf("%s / %s (%.1f%%)", formatBytes(m.processed), formatBytes(m.totalBytes), progressVal*100) stats := fmt.Sprintf("%s / %s (%.1f%%)", formatBytes(m.processed), formatBytes(m.totalBytes), progressVal*100)
@@ -323,23 +372,20 @@ func isBlockDevice(path string) bool {
if runtime.GOOS != "linux" { if runtime.GOOS != "linux" {
return false return false
} }
fileInfo, err := os.Stat(path) fileInfo, err := os.Stat(path)
if err != nil { if err != nil {
return false return false
} }
stat, ok := fileInfo.Sys().(*syscall.Stat_t) stat, ok := fileInfo.Sys().(*syscall.Stat_t)
if !ok { if !ok {
return false return false
} }
return (stat.Mode & syscall.S_IFMT) == syscall.S_IFBLK return (stat.Mode & syscall.S_IFMT) == syscall.S_IFBLK
} }
func init() { func init() {
rootCmd.AddCommand(restoreCmd) rootCmd.AddCommand(restoreCmd)
restoreCmd.Flags().StringVarP(&restoreSource, "source", "s", "", "Source archive (required)") restoreCmd.Flags().StringVarP(&restoreSource, "source", "s", "", "Source archive or network address (e.g., /path/to/archive.tar.gz or 0.0.0.0:8080) (required)")
restoreCmd.Flags().StringVarP(&restoreTarget, "target", "t", "", "Target file, disk, or directory. Defaults to current directory for archives.") restoreCmd.Flags().StringVarP(&restoreTarget, "target", "t", "", "Target file, disk, or directory. Required for network sources.")
restoreCmd.MarkFlagRequired("source") restoreCmd.MarkFlagRequired("source")
} }
+9 -1
View File
@@ -1,6 +1,14 @@
package cmd package cmd
import "fmt" import (
"fmt"
"strings"
)
// isNetworkAddress checks if the address is in host:port format
func isNetworkAddress(addr string) bool {
return strings.Contains(addr, ":")
}
func formatBytes(b int64) string { func formatBytes(b int64) string {
const unit = 1024 const unit = 1024