package forgemsg import ( "encoding/json" "fmt" "reflect" ) // ForgeGroupEndEvent is the name of a delivery group's end on the forge bridge's stream (novox/hq ADR 0633 §4): the // bridge publishes it once every approved member of the group is merged, after the last member's merged message. It // has three parts, so no repository's forge event (`forge...`) is ever this name. const ForgeGroupEndEvent = "forge.group.merged" // GroupMerge is one merged member of a delivery group: the repository as `/`, its pull request and the // merge commit the forge made of it. type GroupMerge struct { Repository string `json:"repository"` Number int `json:"number"` Merge string `json:"merge"` } // ForgeGroupEnd is the body of ForgeGroupEndEvent: the group and every member merged in it on its base, with its merge commit. // The indexer takes the members it holds in as one source revision once it hears it (ADR 0633 §4). type ForgeGroupEnd struct { V int `json:"v"` Group string `json:"group"` // Base is the watched branch the members merged into: a group's end is said once per base (design 47 G §715). Base string `json:"base,omitempty"` Members []GroupMerge `json:"members"` } func (e ForgeGroupEnd) check() error { if e.Group == "" { return fmt.Errorf("delivery: a group's end names its group") } if len(e.Members) == 0 { return fmt.Errorf("delivery: the end of the group %q names no member merged in it", e.Group) } seen := map[string]bool{} for _, m := range e.Members { if err := checkRepository(m.Repository); err != nil { return err } if m.Number <= 0 || m.Merge == "" { return fmt.Errorf("delivery: the member %s of the group %q's end needs its pull request number and merge commit", m.Repository, e.Group) } k := fmt.Sprintf("%s#%d", m.Repository, m.Number) if seen[k] { return fmt.Errorf("delivery: the end of the group %q names its member %s twice", e.Group, k) } seen[k] = true } return nil } // EncodeForgeGroupEnd is e as JSON at Version; it refuses an end with no group or no member, and a member without its // pull request or merge commit. func EncodeForgeGroupEnd(e ForgeGroupEnd) ([]byte, error) { if err := e.check(); err != nil { return nil, err } e.V = Version return json.Marshal(e) } // DecodeForgeGroupEnd reads a group's end; it refuses an unknown version (ErrUnknownVersion) and what // EncodeForgeGroupEnd refuses. func DecodeForgeGroupEnd(data []byte) (ForgeGroupEnd, error) { var e ForgeGroupEnd if err := decode(data, &e); err != nil { return ForgeGroupEnd{}, err } if err := e.check(); err != nil { return ForgeGroupEnd{}, err } return e, nil } // SameForgeGroupEnd says whether two group ends are the same value. func SameForgeGroupEnd(a, b ForgeGroupEnd) bool { return reflect.DeepEqual(a, b) }