Add relay-only replicate engine mode

f377186→main· Soph·3mo ago·7 files·+692 added/-20 removed

Sessions

be84133ec5bbView transcript

Changes

7

• internal

• planner

• Mplanner.go+99

• Mplanner_test.go+64

• Mrelay.go+38

• strategy/replicate

• Areplicate.go+106

• Areplicate_test.go+118

• syncer

• Mintegration_test.go+99/-7

• Msyncer.go+168/-13

160 unmodified lines

// BuildReplicationPlans generates overwrite-oriented plans for replication mode.
// Divergent refs are updated directly rather than blocked.
func BuildReplicationPlans(
    desired map[plumbing.ReferenceName]DesiredRef,
    targetRefs map[plumbing.ReferenceName]plumbing.Hash,
    managed map[plumbing.ReferenceName]ManagedTarget,
    cfg PlanConfig,
) ([]BranchPlan, error) {
    managed = copyManagedTargets(managed)
    if cfg.Prune {
        for targetRef := range targetRefs {
            if _, ok := managed[targetRef]; ok {
                continue
            }
            switch {
            case targetRef.IsTag() && cfg.IncludeTags:
                managed[targetRef] = ManagedTarget{Kind: RefKindTag, Label: targetRef.Short()}
            case targetRef.IsBranch() && len(cfg.Mappings) == 0 && len(cfg.Branches) == 0:
                managed[targetRef] = ManagedTarget{Kind: RefKindBranch, Label: targetRef.Short()}
            }
        }
    }

targetNames := make([]plumbing.ReferenceName, 0, len(managed))
    for name := range managed {
        targetNames = append(targetNames, name)
    }
    sort.Slice(targetNames, func(i, j int) bool { return targetNames[i] < targetNames[j] })

plans := make([]BranchPlan, 0, len(targetNames))
    for _, targetRef := range targetNames {
        info := managed[targetRef]
        want, existsInDesired := desired[targetRef]
        targetHash, existsOnTarget := targetRefs[targetRef]

if !existsInDesired {
            if cfg.Prune && existsOnTarget {
                plans = append(plans, BranchPlan{
                    Branch:     info.Label,
                    TargetRef:  targetRef,
                    TargetHash: targetHash,
                    Kind:       info.Kind,
                    Action:     ActionDelete,
                    Reason:     fmt.Sprintf("%s -> <deleted>", ShortHash(targetHash)),
                })
            }
            continue
        }

plans = append(plans, PlanReplicationRef(want, targetHash, existsOnTarget))
    }

sort.Slice(plans, func(i, j int) bool {
        return plans[i].TargetRef.String() < plans[j].TargetRef.String()
    })
    return plans, nil
}