safcm: move sync_changes.go and term.go to frontend package

[safcm/safcm.git] / cmd / safcm / sync_sync.go

diff --git a/cmd/safcm/sync_sync.go b/cmd/safcm/sync_sync.go
index e84b7f416c07b84df027f017c826d8b381324d4a..7e4d225705eb46dae48c851d033d7364d4eff8cf 100644 (file)
--- a/cmd/safcm/sync_sync.go
+++ b/cmd/safcm/sync_sync.go
@@ -19,13 +19,14 @@ package main
 
 import (
        "fmt"
+       "math"
        "os"
-       "path/filepath"
        "sort"
        "strings"
 
        "ruderich.org/simon/safcm"
        "ruderich.org/simon/safcm/cmd/safcm/config"
+       "ruderich.org/simon/safcm/frontend"
        "ruderich.org/simon/safcm/rpc"
 )
 
@@ -44,26 +45,14 @@ func (s *Sync) hostSync(conn *rpc.Conn, detectedGroups []string) error {
        }
 
        // Display changes
-       var changes []string
-       if len(resp.FileChanges) > 0 {
-               changes = append(changes,
-                       s.formatFileChanges(resp.FileChanges))
+       c := frontend.Changes{
+               DryRun: s.config.DryRun,
+               Quiet:  s.config.Quiet,
+               IsTTY:  s.isTTY,
        }
-       if len(resp.PackageChanges) > 0 {
-               changes = append(changes,
-                       s.formatPackageChanges(resp.PackageChanges))
-       }
-       if len(resp.ServiceChanges) > 0 {
-               changes = append(changes,
-                       s.formatServiceChanges(resp.ServiceChanges))
-       }
-       if len(resp.CommandChanges) > 0 {
-               changes = append(changes,
-                       s.formatCommandChanges(resp.CommandChanges))
-       }
-       if len(changes) > 0 {
-               s.logf(safcm.LogInfo, true, "%s",
-                       "\n"+strings.Join(changes, "\n"))
+       changes := c.FormatChanges(resp)
+       if changes != "" {
+               s.log(safcm.LogInfo, true, changes)
        }
 
        if resp.Error != "" {
@@ -82,8 +71,8 @@ func (s *Sync) hostSyncReq(detectedGroups []string) (
                return empty, err
        }
        {
-               // Don't leak internal group order which is confusing without
-               // knowing the implementation details.
+               // Don't leak internal group priority which is confusing
+               // without knowing the implementation details.
                groupsSorted := make([]string, len(groups))
                copy(groupsSorted, groups)
                sort.Strings(groupsSorted)
@@ -99,16 +88,16 @@ func (s *Sync) hostSyncReq(detectedGroups []string) (
                sort.Slice(priorities, func(i, j int) bool {
                        a := priorities[i]
                        b := priorities[j]
-                       return groupPriority[a] < groupPriority[b]
+                       return groupPriority[a] > groupPriority[b]
                })
-               s.logVerbosef("host group priorities (desc. order): %v",
+               s.logVerbosef("host group priorities (descending): %v",
                        strings.Join(priorities, " "))
        }
 
        allFiles := make(map[string]*safcm.File)
        allPackagesMap := make(map[string]bool) // map to deduplicate
        allServicesMap := make(map[string]bool) // map to deduplicate
-       var allCommands []string
+       var allCommands []*safcm.Command
 
        for _, group := range groups {
                // Skip non-existent group directories
@@ -202,21 +191,21 @@ func (s *Sync) resolveHostGroups(detectedGroups []string) (
                return nil, nil, err
        }
 
-       // Early entries have higher priorities
+       // Early entries in "group_priority" have higher priorities
        groupPriority := make(map[string]int)
-       for i, x := range s.config.GroupOrder {
-               groupPriority[x] = i + 1
+       for i, x := range s.config.GroupPriority {
+               groupPriority[x] = len(s.config.GroupPriority) - i
        }
        // Host itself always has highest priority
-       groupPriority[s.host.Name] = -1
+       groupPriority[s.host.Name] = math.MaxInt32
 
        // Sort groups after priority and name
        sort.Slice(groups, func(i, j int) bool {
                a := groups[i]
                b := groups[j]
-               if groupPriority[a] > groupPriority[b] {
+               if groupPriority[a] < groupPriority[b] {
                        return true
-               } else if groupPriority[a] < groupPriority[b] {
+               } else if groupPriority[a] > groupPriority[b] {
                        return false
                } else {
                        return a < b
@@ -236,7 +225,7 @@ func (s *Sync) checkFileConflict(group string, path string, file *safcm.File,
 
        newPrio := groupPriority[group]
        oldPrio := groupPriority[old.OrigGroup]
-       if oldPrio > newPrio {
+       if oldPrio < newPrio {
                if old.Mode.IsDir() && file.Mode.IsDir() &&
                        old.TriggerCommands != nil {
                        s.logDebugf("files: %q: "+
@@ -244,7 +233,7 @@ func (s *Sync) checkFileConflict(group string, path string, file *safcm.File,
                                path, group, old.OrigGroup)
                }
                return nil
-       } else if oldPrio < newPrio {
+       } else if oldPrio > newPrio {
                // Should never happen, groups are sorted by priority
                panic("invalid group priorities")
        }
@@ -257,8 +246,8 @@ func (s *Sync) checkFileConflict(group string, path string, file *safcm.File,
                return nil
        }
 
-       return fmt.Errorf("groups %s and %s both provide file %q\n"+
-               "Use 'group_order' in config.yaml to declare preference",
+       return fmt.Errorf("groups %s and %s both provide %q\n"+
+               "Use 'group_priority' in config.yaml to declare preference",
                group, old.OrigGroup, path)
 }
 
@@ -271,11 +260,12 @@ func resolveFileDirConflicts(files map[string]*safcm.File) {
                return paths[i] < paths[j]
        })
 
-       const sep = string(filepath.Separator)
+       // Slash separated paths are used for the configuration
+       const sep = "/"
 
-       // Remove invalid paths which can result from group_order overriding
-       // paths from another group (e.g. "/foo" as file from one group and
-       // "/foo/bar" from another).
+       // Remove invalid paths which can result from group_priority
+       // overriding paths from another group (e.g. "/foo" as file from one
+       // group and "/foo/bar" from another).
        var last *safcm.File
        for _, x := range paths {
                file := files[x]