77 lines
3.4 KiB
Go
77 lines
3.4 KiB
Go
package membership
|
|
|
|
import (
|
|
"bytes"
|
|
"encoding/json"
|
|
"errors"
|
|
"fmt"
|
|
)
|
|
|
|
// The grants part's state memberships (buscompose.GrantsMembershipsState) holds, at `<node>.<module>`, the bare
|
|
// membership as the assignments stream carries it. The writer and every reader use this one codec, so the two sides
|
|
// cannot drift: until 2026-10-30 the grants part wrote its own wrapper ({node, module, digest, membership, published,
|
|
// retired}) there while the tool runner read the value as a bare membership, and served nothing (issue 774).
|
|
|
|
// GrantsBucket is the grants part's state memberships (buscompose.GrantsMembershipsBucket, which a test keeps agreeing),
|
|
// and GrantsKey an assignment's key in it, `<node>.<module>`: where a runtime reads its membership (FollowMembership).
|
|
const GrantsBucket = "mesh-grants_memberships"
|
|
|
|
// GrantsKey is an assignment's key in GrantsBucket.
|
|
func GrantsKey(node, module string) string { return node + "." + module }
|
|
|
|
// EncodeGrantsMembership is the value of a membership's key in the grants part's memberships: the bare membership.
|
|
func EncodeGrantsMembership(m Membership) []byte {
|
|
raw, _ := json.Marshal(m) // a Membership holds nothing json cannot write
|
|
return raw
|
|
}
|
|
|
|
// DecodeGrantsMembership reads a value of the grants part's memberships (BareGrantsMembership) as a Membership.
|
|
func DecodeGrantsMembership(raw []byte) (Membership, error) {
|
|
var m Membership
|
|
body, err := BareGrantsMembership(raw)
|
|
if err != nil {
|
|
return m, err
|
|
}
|
|
err = json.Unmarshal(body, &m)
|
|
return m, err
|
|
}
|
|
|
|
// BareGrantsMembership is the bare membership a value of the grants part's memberships holds, for a reader that
|
|
// decodes it into a type of its own. It accepts the bare membership and, for the transition, the wrapper the grants
|
|
// part wrote before (a top-level object whose "membership" is an object), answering the membership inside it only when
|
|
// its "published" says "published" or "unchanged". A value that is not a JSON object, a wrapper of a membership held
|
|
// back or saying nothing of its publishing, or a membership naming no node or no module, is an error, never an empty
|
|
// or unpublished membership.
|
|
func BareGrantsMembership(raw []byte) (json.RawMessage, error) {
|
|
var probe struct {
|
|
Membership json.RawMessage `json:"membership"`
|
|
Published *string `json:"published"`
|
|
}
|
|
if err := json.Unmarshal(raw, &probe); err != nil {
|
|
return nil, fmt.Errorf("not a membership: %w", err)
|
|
}
|
|
body := raw
|
|
if inner := bytes.TrimSpace(probe.Membership); len(inner) > 0 {
|
|
if inner[0] != '{' {
|
|
return nil, errors.New("not a membership: its membership is no object")
|
|
}
|
|
// The old wrapper was written for a membership held back too, its composed and unpublished membership inside:
|
|
// only one published (or unchanged) is the stream's, so any other is refused and the reader keeps the stream's.
|
|
switch {
|
|
case probe.Published == nil:
|
|
return nil, errors.New("not a published membership: the wrapper says nothing of its publishing")
|
|
case *probe.Published != "published" && *probe.Published != "unchanged":
|
|
return nil, fmt.Errorf("not a published membership: the wrapper says %q", *probe.Published)
|
|
}
|
|
body = inner
|
|
}
|
|
var m Membership
|
|
if err := json.Unmarshal(body, &m); err != nil {
|
|
return nil, fmt.Errorf("not a membership: %w", err)
|
|
}
|
|
if m.Node == "" || m.Module == "" {
|
|
return nil, errors.New("not a membership: it names no node or no module")
|
|
}
|
|
return json.RawMessage(body), nil
|
|
}
|