simplify checkpoint policy state

0d5ec03· pfleidi·3w ago·7 files·+40 added/-63 removed

Share remote baseline loading between policy sync and update.

Keep checkpoint policy state focused on data by removing test-only format knowledge, target labels, and preformatted warning text.

Sessions

0e1a4e82890cView transcript

Changes

7

• cmd/entire/cli

• checkpointpolicy

• Mformat.go+2/-13

• Mformat_test.go-2

• Mremote.go+30/-25

• Mremote_test.go-1

• Mstore.go-1

• Mupdate.go+2/-20

52 unmodified lines

53
54
55
56
57
58
59
60
56
57
58
18 unmodified lines

77
78
79
80
81
82
86
87
88
89
90
91
92
93
83
84
85

52 unmodified lines

return compareInt(a.Major, b.Major)
}

func KnowsFormat(format CheckpointFormat) bool {
    _, ok := knownFormats[format]
    return ok
}

func CanRead(format CheckpointFormat) bool {
    return readFormats[format]
}

18 unmodified lines

CheckpointFamilyRefs:   1,
}

var branchV1Format = CheckpointFormat{Family: CheckpointFamilyBranch, Major: 1}

var (
    branchV1Format = CheckpointFormat{Family: CheckpointFamilyBranch, Major: 1}
    refsV1Format   = CheckpointFormat{Family: CheckpointFamilyRefs, Major: 1}

knownFormats = map[CheckpointFormat]struct{}{
        branchV1Format: {},
        refsV1Format:   {},
    }

readFormats = map[CheckpointFormat]bool{
        branchV1Format: true,
    }

Mcmd/entire/cli/checkpointpolicy/format.go+2/-13

44 unmodified lines

45
46
47
48
48
49
50
51
53
52
53
54

44 unmodified lines

refsV1, err := checkpointpolicy.ParseFormat("refs-v1")
    require.NoError(t, err)

require.True(t, checkpointpolicy.KnowsFormat(branchV1))
    require.True(t, checkpointpolicy.CanRead(branchV1))
    require.True(t, checkpointpolicy.CanWrite(branchV1))
    require.Equal(t, checkpoint.CheckpointVersionBranchV1, branchV1.String())

require.True(t, checkpointpolicy.KnowsFormat(refsV1))
    require.False(t, checkpointpolicy.CanRead(refsV1))
    require.False(t, checkpointpolicy.CanWrite(refsV1))
    require.Negative(t, checkpointpolicy.Compare(branchV1, refsV1))

Mcmd/entire/cli/checkpointpolicy/format_test.go-2

20 unmodified lines

21
22
23
24
24
25
26
13 unmodified lines

40
41
42
44
43
44
46
45
46
47
48
50
51
52
53
54
49
50
51
52
17 unmodified lines

70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
80
97
98
99
83
100
101
102
103
104
88
105
106
107
108
109
93
110
111
112
113
97
98
99
100
101
102
103
104
105
106
107
108
109
114
115
116
117

20 unmodified lines

type Target struct {
    Remote string
    Label  string
    Dir    string
}

13 unmodified lines

if target, dedicated, err := remote.ConfiguredURL(ctx, baseRemote, dir); err != nil {
        return Target{}, fmt.Errorf("resolve checkpoint remote URL: %w", err)
    } else if dedicated {
        return Target{Remote: target, Label: "checkpoint remote", Dir: dir}, nil
    }
    target, dedicated, err := remote.PushURL(ctx, baseRemote)
target, _, err := remote.PushURL(ctx, baseRemote)
if err != nil {
        return Target{}, fmt.Errorf("resolve checkpoint push URL: %w", err)
    }
    label := baseRemote
    if dedicated {
        label = "checkpoint remote"
    }
    return Target{Remote: target, Label: label, Dir: dir}, nil
    return Target{Remote: target, Dir: dir}, nil
}

func CheckRemote(ctx context.Context, target Target) (RemoteState, error) {
17 unmodified lines

return State{}, err
}

baseline, remoteFound, err := remoteBaseline(ctx, repo, target, local)
    if err != nil {
        return State{}, err
    }
    if !remoteFound || local.Hash == baseline.Hash {
        if err := SetRef(repo, RefName, baseline.Hash); err != nil {
            return State{}, err
        }
        baseline.Source = SourceRemote
        return baseline, nil
    }

if local.Hash.IsZero() || isAncestorOf(ctx, repo, local.Hash, baseline.Hash) {
        if err := SetRef(repo, RefName, baseline.Hash); err != nil {
            return State{}, err
        }
        baseline.Source = SourceRemote
        return baseline, nil
    }

local.Source = SourceLocalDiverged
    local.RemoteHash = baseline.RemoteHash
    return local, nil
}

func remoteBaseline(ctx context.Context, repo *git.Repository, target Target, local State) (State, bool, error) {
    remoteState, err := CheckRemote(ctx, target)
    if err != nil {
        return State{}, err
        return State{}, false, err
    }
    if !remoteState.Exists {
        return local, nil
        return local, false, nil
    }
    if local.Hash == remoteState.Hash {
        local.Source = SourceRemote
        local.RemoteHash = remoteState.Hash
        return local, nil
        return local, true, nil
    }

fetched, err := fetchRemotePolicy(ctx, repo, target)
    if err != nil {
        return State{}, err
        return State{}, false, err
    }
    fetched.RemoteHash = remoteState.Hash
    defer removeFetchRef(repo)

if local.Hash.IsZero() || isAncestorOf(ctx, repo, local.Hash, fetched.Hash) {
        if err := SetRef(repo, RefName, fetched.Hash); err != nil {
            return State{}, err
        }
        fetched.Source = SourceRemote
        return fetched, nil
    }

local.Source = SourceLocalDiverged
    local.RemoteHash = remoteState.Hash
    local.Warning = fmt.Sprintf("local checkpoint policy %s diverges from remote %s", local.Hash, remoteState.Hash)
    return local, nil
    return fetched, true, nil
}

func Push(ctx context.Context, target Target) error {

Mcmd/entire/cli/checkpointpolicy/remote.go+30/-25

130 unmodified lines

131
132
133
134
134
135
136

130 unmodified lines

target, err := checkpointpolicy.ResolveTarget(t.Context(), "origin")
    require.NoError(t, err)
    require.Equal(t, "git@github.com:org/checkpoints.git", target.Remote)
    require.Equal(t, "checkpoint remote", target.Label)
    wantDir, err := filepath.EvalSymlinks(localDir)
    require.NoError(t, err)
    gotDir, err := filepath.EvalSymlinks(target.Dir)

Mcmd/entire/cli/checkpointpolicy/remote_test.go-1

31 unmodified lines

32
33
34
35
35
36
37

31 unmodified lines

Source     Source
    Hash       plumbing.Hash
    RemoteHash plumbing.Hash
    Warning    string
}

func ReadLocal(ctx context.Context, repo *git.Repository) (State, error) {

Mcmd/entire/cli/checkpointpolicy/store.go-1

51 unmodified lines

52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
55
56
57
58
59

51 unmodified lines

return State{}, err
    }

remoteState, err := CheckRemote(ctx, target)
    if err != nil {
        return State{}, err
    }
    if !remoteState.Exists {
        return local, nil
    }
    if local.Hash == remoteState.Hash {
        local.Source = SourceRemote
        local.RemoteHash = remoteState.Hash
        return local, nil
    }

fetched, err := fetchRemotePolicy(ctx, repo, target)
    if err != nil {
        return State{}, err
    }
    fetched.RemoteHash = remoteState.Hash
    defer removeFetchRef(repo)
    return fetched, nil
    baseline, _, err := remoteBaseline(ctx, repo, target, local)
    return baseline, err
}

func rejectDowngrades(before, after Policy, opts UpdateOptions) error {

Mcmd/entire/cli/checkpointpolicy/update.go+2/-20

72 unmodified lines

73
74
75
76
76
77
78
79
80
81
82
83
84

72 unmodified lines

func warnOrLogCheckpointPolicyDiverged(ctx context.Context, state checkpointpolicy.State) {
    if interactive.CanPromptInteractively() {
        fmt.Fprintf(stderrWriter, "[entire] Could not reconcile checkpoint policy: %s\n", state.Warning)
        fmt.Fprintf(
            stderrWriter,
            "[entire] Could not reconcile checkpoint policy: local checkpoint policy %s diverges from remote %s\n",
            state.Hash,
            state.RemoteHash,
        )
        return
    }
    logging.Warn(ctx, "checkpoint policy diverged; skipping checkpoint push",

Mcmd/entire/cli/strategy/checkpoint_policy.go+6/-1