refactor(output): relocate tarball creation logic to output

Author: Vinayak-RZ

.gitattributes

@@ -20,7 +20,7 @@ var DotfilePaths = []string{
 
 type Dotfile struct {
 	Path     string
-	RelPath  string
+	RealPath  string
 	IsDir    bool
 	IsBinary bool
 	Mode     os.FileMode
@@ -61,10 +61,10 @@ func ScanDotfiles() ([]Dotfile, error) {
 			continue
 		}
 
-		relPath, _ := filepath.Rel(home, full)
+		realPath, _ := filepath.Rel(home, full)
 		entry := Dotfile{
 			Path:    full,
-			RelPath: relPath,
+			RealPath: realPath,
 			IsDir:   info.IsDir(),
 			Mode:    info.Mode(),
 		}

system/backup/dotfile_scanner.go

@@ -1,13 +1,10 @@
 package backup
 
 import (
-	"archive/tar"
-	"compress/gzip"
-	"encoding/json"
 	"fmt"
-	"io"
 	"os"
 	"time"
+	"github.com/mdgspace/sysreplicate/system/output"
 )
 
 type BackupMetadata struct {
@@ -23,55 +20,25 @@ func NewDotfileBackupManager() *DotfileBackupManager {
 }
 
 func (db *DotfileBackupManager) CreateDotfileBackup(outputTar string) error {
+	// Scan dotfiles
 	files, err := ScanDotfiles()
 	if err != nil {
 		return fmt.Errorf("error scanning dotfiles: %w", err)
 	}
 
+	// Get hostname
 	hostname, _ := os.Hostname()
 
-	meta := BackupMetadata{
+	// Create backup metadata
+	meta := &BackupMetadata{
 		Timestamp: time.Now(),
 		Hostname:  hostname,
 		Files:     files,
 	}
 
-	tarFile, err := os.Create(outputTar)
-	if err != nil {
-		return fmt.Errorf("failed to create tar file: %w", err)
-	}
-	defer tarFile.Close()
-
-	gzipWriter := gzip.NewWriter(tarFile)
-	defer gzipWriter.Close()
-	tarWriter := tar.NewWriter(gzipWriter)
-	defer tarWriter.Close()
-
-	// Write metadata JSON
-	metaBytes, _ := json.MarshalIndent(meta, "", "  ")
-	tarWriter.WriteHeader(&tar.Header{
-		Name: "backup.json",
-		Mode: 0644,
-		Size: int64(len(metaBytes)),
-	})
-	tarWriter.Write(metaBytes)
-
-	// Add dotfiles
-	for _, f := range files {
-		if f.IsDir {
-			continue
-		}
-		file, err := os.Open(f.Path)
-		if err != nil {
-			continue
-		}
-		defer file.Close()
-
-		info, _ := file.Stat()
-		hdr, _ := tar.FileInfoHeader(info, "")
-		hdr.Name = f.RelPath
-		tarWriter.WriteHeader(hdr)
-		io.Copy(tarWriter, file)
+	// Delegate tarball creation to utility
+	if err := CreateDotfilesBackupTarball(meta, outputTar); err != nil {
+		return fmt.Errorf("failed to create backup tarball: %w", err)
 	}
 
 	fmt.Println("Backup complete:", outputTar)

system/backup/dotfiles_backup.go

@@ -3,7 +3,7 @@ package system
 import (
 	"fmt"
 	"log"
-
+	"os"
 	"github.com/mdgspace/sysreplicate/system/backup"
 )
 
@@ -33,9 +33,15 @@ func RunDotfileBackup() {
 	// Create a backup manager
 	manager := backup.NewDotfileBackupManager()
 
-	//Output to dist directory
+	// Output path
 	outputPath := "dist/dotfile-backup.tar.gz"
 
+	// Ensure "dist" directory exists
+	if err := os.MkdirAll("dist", os.ModePerm); err != nil {
+		fmt.Printf("Failed to create output directory: %v\n", err)
+		return
+	}
+
 	// Run the backup
 	err := manager.CreateDotfileBackup(outputPath)
 	if err != nil {

system/backup_integration.go

@@ -4,13 +4,15 @@ import (
 	"archive/tar"
 	"compress/gzip"
 	"encoding/json"
+	"fmt"
+	"io"
 	"os"
 	"time"
 )
 
-//backupData structure for tarball creation
+// backupData structure for tarball creation
 type BackupData struct {
-	Timestamp     time.Time                `json:"timestamp"`
+	Timestamp     time.Time               `json:"timestamp"`
 	SystemInfo    SystemInfo              `json:"system_info"`
 	EncryptedKeys map[string]EncryptedKey `json:"encrypted_keys"`
 	EncryptionKey []byte                  `json:"encryption_key"`
@@ -30,12 +32,20 @@ type EncryptedKey struct {
 }
 
 type Dotfile struct {
-	Path     string `json:"path"`
-	Content  string `json:"content"`
-	Mode     uint32 `json:"mode"`
-	IsBinary bool   `json:"is_binary"`
+	Path     string
+	RealPath string
+	IsDir    bool
+	IsBinary bool
+	Mode     os.FileMode
+	Content  string // ignore for the binary files
 }
-//create a compressed tarball with the backup data
+type BackupMetadata struct {
+	Timestamp time.Time `json:"timestamp"`
+	Hostname  string    `json:"hostname"`
+	Files     []Dotfile `json:"files"`
+}
+
+// create a compressed tarball with the backup data
 func CreateBackupTarball(backupData *BackupData, tarballPath string) error {
 	//create tarball file
 	file, err := os.Create(tarballPath)
@@ -75,3 +85,94 @@ func CreateBackupTarball(backupData *BackupData, tarballPath string) error {
 
 	return nil
 }
+
+func CreateDotfilesBackupTarball(meta *BackupMetadata, tarballPath string) error {
+	// Create the tarball file
+	file, err := os.Create(tarballPath)
+	if err != nil {
+		return fmt.Errorf("failed to create tarball: %w", err)
+	}
+	defer file.Close()
+
+
+	gzipWriter := gzip.NewWriter(file)
+	defer gzipWriter.Close()
+	tarWriter := tar.NewWriter(gzipWriter)
+	defer tarWriter.Close()
+
+	jsonData, err := json.MarshalIndent(meta, "", "  ")
+	if err != nil {
+		return fmt.Errorf("failed to marshal metadata: %w", err)
+	}
+
+	// Add metadata as backup.json
+	header := &tar.Header{
+		Name: "backup.json",
+		Mode: 0644,
+		Size: int64(len(jsonData)),
+	}
+	if err := tarWriter.WriteHeader(header); err != nil {
+		return fmt.Errorf("failed to write header for metadata: %w", err)
+	}
+	if _, err := tarWriter.Write(jsonData); err != nil {
+		return fmt.Errorf("failed to write metadata to tar: %w", err)
+	}
+
+	// Add dotfiles
+	for _, f := range meta.Files {
+		if f.IsDir {
+			continue
+		}
+
+		if f.IsBinary {
+			// Read file from disk
+			fileHandle, err := os.Open(f.Path)
+			if err != nil {
+				fmt.Fprintf(os.Stderr, "warning: failed to open binary file %s: %v\n", f.Path, err)
+				continue
+			}
+			defer fileHandle.Close()
+
+			info, err := fileHandle.Stat()
+			if err != nil {
+				fmt.Fprintf(os.Stderr, "warning: failed to stat %s: %v\n", f.Path, err)
+				continue
+			}
+
+			hdr, err := tar.FileInfoHeader(info, "")
+			if err != nil {
+				fmt.Fprintf(os.Stderr, "warning: failed to get tar header for %s: %v\n", f.Path, err)
+				continue
+			}
+			hdr.Name = f.RealPath
+			hdr.Mode = int64(f.Mode)
+
+			if err := tarWriter.WriteHeader(hdr); err != nil {
+				fmt.Fprintf(os.Stderr, "warning: failed to write tar header for %s: %v\n", f.Path, err)
+				continue
+			}
+			if _, err := io.Copy(tarWriter, fileHandle); err != nil {
+				fmt.Fprintf(os.Stderr, "warning: failed to copy binary file %s: %v\n", f.Path, err)
+				continue
+			}
+		} else {
+			// Use in-memory content
+			contentBytes := []byte(f.Content)
+			hdr := &tar.Header{
+				Name: f.RealPath,
+				Mode: int64(f.Mode),
+				Size: int64(len(contentBytes)),
+			}
+			if err := tarWriter.WriteHeader(hdr); err != nil {
+				fmt.Fprintf(os.Stderr, "warning: failed to write header for text file %s: %v\n", f.Path, err)
+				continue
+			}
+			if _, err := tarWriter.Write(contentBytes); err != nil {
+				fmt.Fprintf(os.Stderr, "warning: failed to write text file %s: %v\n", f.Path, err)
+				continue
+			}
+		}
+	}
+
+	return nil
+}