Files
skillshare/internal/sync/sync.go
T

410 lines
11 KiB
Go

package sync
import (
"fmt"
"io"
"os"
"path/filepath"
"skillshare/internal/config"
"skillshare/internal/utils"
)
// TargetStatus represents the state of a target
type TargetStatus int
const (
StatusUnknown TargetStatus = iota
StatusLinked // Target is a symlink pointing to source
StatusNotExist // Target doesn't exist
StatusHasFiles // Target exists with files (needs migration)
StatusConflict // Target is a symlink pointing elsewhere
StatusBroken // Target is a broken symlink
StatusMerged // Target uses merge mode (individual skill symlinks)
)
func (s TargetStatus) String() string {
switch s {
case StatusLinked:
return "linked"
case StatusNotExist:
return "not exist"
case StatusHasFiles:
return "has files"
case StatusConflict:
return "conflict"
case StatusBroken:
return "broken"
case StatusMerged:
return "merged"
default:
return "unknown"
}
}
// CheckStatus checks the status of a target
func CheckStatus(targetPath, sourcePath string) TargetStatus {
info, err := os.Lstat(targetPath)
if err != nil {
if os.IsNotExist(err) {
return StatusNotExist
}
return StatusUnknown
}
// Check if it's a symlink
if info.Mode()&os.ModeSymlink != 0 {
link, err := os.Readlink(targetPath)
if err != nil {
return StatusUnknown
}
// Check if symlink points to our source
absLink := link
if !filepath.IsAbs(link) {
absLink = filepath.Join(filepath.Dir(targetPath), link)
}
absSource, _ := filepath.Abs(sourcePath)
absLink, _ = filepath.Abs(absLink)
if absLink == absSource {
// Verify the link is not broken
if _, err := os.Stat(targetPath); err != nil {
return StatusBroken
}
return StatusLinked
}
return StatusConflict
}
// It's a directory with files
if info.IsDir() {
return StatusHasFiles
}
return StatusUnknown
}
// MigrateToSource moves files from target to source, then creates symlink
func MigrateToSource(targetPath, sourcePath string) error {
// Ensure source parent directory exists
if err := os.MkdirAll(filepath.Dir(sourcePath), 0755); err != nil {
return fmt.Errorf("failed to create source parent: %w", err)
}
// Check if source already exists
if _, err := os.Stat(sourcePath); err == nil {
// Source exists - merge files
if err := mergeDirectories(targetPath, sourcePath); err != nil {
return fmt.Errorf("failed to merge directories: %w", err)
}
// Remove original target
if err := os.RemoveAll(targetPath); err != nil {
return fmt.Errorf("failed to remove target after merge: %w", err)
}
} else {
// Source doesn't exist - just move
if err := os.Rename(targetPath, sourcePath); err != nil {
// Cross-device? Try copy then delete
if err := copyDirectory(targetPath, sourcePath); err != nil {
return fmt.Errorf("failed to copy to source: %w", err)
}
if err := os.RemoveAll(targetPath); err != nil {
return fmt.Errorf("failed to remove original after copy: %w", err)
}
}
}
return nil
}
// CreateSymlink creates a symlink from target to source
func CreateSymlink(targetPath, sourcePath string) error {
// Ensure target parent exists
if err := os.MkdirAll(filepath.Dir(targetPath), 0755); err != nil {
return fmt.Errorf("failed to create target parent: %w", err)
}
// Create symlink
if err := os.Symlink(sourcePath, targetPath); err != nil {
return fmt.Errorf("failed to create symlink: %w", err)
}
return nil
}
// SyncTarget performs the sync operation for a single target
func SyncTarget(name string, target config.TargetConfig, sourcePath string, dryRun bool) error {
status := CheckStatus(target.Path, sourcePath)
switch status {
case StatusLinked:
// Already correct
return nil
case StatusNotExist:
if dryRun {
fmt.Printf("[dry-run] Would create symlink: %s -> %s\n", target.Path, sourcePath)
return nil
}
return CreateSymlink(target.Path, sourcePath)
case StatusHasFiles:
if dryRun {
fmt.Printf("[dry-run] Would migrate files from %s to %s, then create symlink\n", target.Path, sourcePath)
return nil
}
if err := MigrateToSource(target.Path, sourcePath); err != nil {
return err
}
return CreateSymlink(target.Path, sourcePath)
case StatusConflict:
link, _ := os.Readlink(target.Path)
return fmt.Errorf("target is symlink to different location: %s -> %s", target.Path, link)
case StatusBroken:
if dryRun {
fmt.Printf("[dry-run] Would remove broken symlink and recreate: %s\n", target.Path)
return nil
}
os.Remove(target.Path)
return CreateSymlink(target.Path, sourcePath)
default:
return fmt.Errorf("unknown target status: %s", status)
}
}
// mergeDirectories copies files from src to dst, skipping existing files
func mergeDirectories(src, dst string) error {
return filepath.Walk(src, func(path string, info os.FileInfo, err error) error {
if err != nil {
return err
}
relPath, _ := filepath.Rel(src, path)
dstPath := filepath.Join(dst, relPath)
if info.IsDir() {
return os.MkdirAll(dstPath, info.Mode())
}
// Skip if destination exists
if _, err := os.Stat(dstPath); err == nil {
fmt.Printf(" skip (exists): %s\n", relPath)
return nil
}
return copyFile(path, dstPath)
})
}
// copyDirectory copies a directory recursively
func copyDirectory(src, dst string) error {
return filepath.Walk(src, func(path string, info os.FileInfo, err error) error {
if err != nil {
return err
}
relPath, _ := filepath.Rel(src, path)
dstPath := filepath.Join(dst, relPath)
if info.IsDir() {
return os.MkdirAll(dstPath, info.Mode())
}
return copyFile(path, dstPath)
})
}
// copyFile copies a single file
func copyFile(src, dst string) error {
srcFile, err := os.Open(src)
if err != nil {
return err
}
defer srcFile.Close()
srcInfo, err := srcFile.Stat()
if err != nil {
return err
}
dstFile, err := os.OpenFile(dst, os.O_CREATE|os.O_WRONLY|os.O_TRUNC, srcInfo.Mode())
if err != nil {
return err
}
defer dstFile.Close()
_, err = io.Copy(dstFile, srcFile)
return err
}
// MergeResult holds the result of a merge sync operation
type MergeResult struct {
Linked []string // Skills that were symlinked
Skipped []string // Skills that already exist in target (kept local)
Updated []string // Skills that had broken symlinks fixed
}
// SyncTargetMerge performs merge mode sync - creates symlinks for each skill individually
// while preserving target-specific skills
func SyncTargetMerge(name string, target config.TargetConfig, sourcePath string, dryRun bool) (*MergeResult, error) {
result := &MergeResult{}
// Check if target is currently a symlink (symlink mode) - need to convert to merge mode
info, err := os.Lstat(target.Path)
if err == nil && info.Mode()&os.ModeSymlink != 0 {
// Target is a symlink - remove it to convert to merge mode
if dryRun {
fmt.Printf("[dry-run] Would convert from symlink mode to merge mode: %s\n", target.Path)
} else {
if err := os.Remove(target.Path); err != nil {
return nil, fmt.Errorf("failed to remove symlink for merge conversion: %w", err)
}
}
}
// Ensure target directory exists
if !dryRun {
if err := os.MkdirAll(target.Path, 0755); err != nil {
return nil, fmt.Errorf("failed to create target directory: %w", err)
}
}
// Read skills from source
sourceEntries, err := os.ReadDir(sourcePath)
if err != nil {
return nil, fmt.Errorf("failed to read source directory: %w", err)
}
for _, entry := range sourceEntries {
// Skip hidden files/directories
if utils.IsHidden(entry.Name()) {
continue
}
// Only process directories (skills are directories)
if !entry.IsDir() {
continue
}
skillName := entry.Name()
sourceSkillPath := filepath.Join(sourcePath, skillName)
targetSkillPath := filepath.Join(target.Path, skillName)
// Check if skill exists in target
targetInfo, err := os.Lstat(targetSkillPath)
if err == nil {
// Something exists at target path
if targetInfo.Mode()&os.ModeSymlink != 0 {
// It's a symlink - check if it points to source
link, _ := os.Readlink(targetSkillPath)
absLink, _ := filepath.Abs(link)
absSource, _ := filepath.Abs(sourceSkillPath)
if absLink == absSource {
// Already correctly linked
result.Linked = append(result.Linked, skillName)
continue
}
// Symlink points elsewhere - broken or wrong
if dryRun {
fmt.Printf("[dry-run] Would fix symlink: %s\n", skillName)
} else {
os.Remove(targetSkillPath)
if err := os.Symlink(sourceSkillPath, targetSkillPath); err != nil {
return nil, fmt.Errorf("failed to create symlink for %s: %w", skillName, err)
}
}
result.Updated = append(result.Updated, skillName)
} else {
// It's a real directory - skip (preserve local skill)
result.Skipped = append(result.Skipped, skillName)
}
} else if os.IsNotExist(err) {
// Doesn't exist - create symlink
if dryRun {
fmt.Printf("[dry-run] Would create symlink: %s -> %s\n", targetSkillPath, sourceSkillPath)
} else {
if err := os.Symlink(sourceSkillPath, targetSkillPath); err != nil {
return nil, fmt.Errorf("failed to create symlink for %s: %w", skillName, err)
}
}
result.Linked = append(result.Linked, skillName)
} else {
return nil, fmt.Errorf("failed to check target skill %s: %w", skillName, err)
}
}
return result, nil
}
// CheckStatusMerge checks the status of a target in merge mode
func CheckStatusMerge(targetPath, sourcePath string) (TargetStatus, int, int) {
// Returns: status, linked count, local count
info, err := os.Lstat(targetPath)
if err != nil {
if os.IsNotExist(err) {
return StatusNotExist, 0, 0
}
return StatusUnknown, 0, 0
}
// If it's a symlink to source, it's using symlink mode not merge
if info.Mode()&os.ModeSymlink != 0 {
link, _ := os.Readlink(targetPath)
absLink, _ := filepath.Abs(link)
absSource, _ := filepath.Abs(sourcePath)
if absLink == absSource {
return StatusLinked, 0, 0
}
return StatusConflict, 0, 0
}
if !info.IsDir() {
return StatusUnknown, 0, 0
}
// Count linked vs local skills
linkedCount := 0
localCount := 0
entries, _ := os.ReadDir(targetPath)
for _, entry := range entries {
if utils.IsHidden(entry.Name()) {
continue
}
if !entry.IsDir() && entry.Type()&os.ModeSymlink == 0 {
continue
}
skillPath := filepath.Join(targetPath, entry.Name())
info, err := os.Lstat(skillPath)
if err != nil {
continue
}
if info.Mode()&os.ModeSymlink != 0 {
// It's a symlink - check if it points to source
link, _ := os.Readlink(skillPath)
if filepath.Dir(link) == sourcePath || filepath.Dir(filepath.Join(filepath.Dir(skillPath), link)) == sourcePath {
linkedCount++
} else {
localCount++
}
} else {
localCount++
}
}
if linkedCount > 0 {
return StatusMerged, linkedCount, localCount
}
return StatusHasFiles, 0, localCount
}