Files
archie/internal/domain/workintake/envelope.go
T

138 lines
4.2 KiB
Go

// Package workintake turns discovered issues into task envelopes and defines
// their routing kinds and subjects.
package workintake
import (
"encoding/json"
"fmt"
"strconv"
"strings"
"github.com/samcharles93/archie-core/internal/domain/org"
)
// dedupKeyPrefix namespaces idempotency keys so they cannot collide with
// another producer's on a shared broker.
const dedupKeyPrefix = "archie:"
// TaskEnvelope is the wire payload announcing a discovered issue.
//
// Publishing once took seven positional parameters, six of them strings,
// which made a transposed argument a silent bug. Callers build this struct.
type TaskEnvelope struct {
Owner string `json:"owner"`
Repo string `json:"repo"`
Number int `json:"number"`
Title string `json:"title"`
Body string `json:"body"`
// Labels are the issue's labels. On the wire this stays a
// comma-separated string for compatibility with already-queued messages,
// but in Go it is a slice.
Labels []string `json:"-"`
// LabelsRaw is the comma-separated wire form, kept in sync by the JSON
// methods. Callers should use Labels.
LabelsRaw string `json:"labels"`
// Identity is the archie identity whose forge poll discovered the issue,
// empty for single-identity deployments. Carried so the consuming daemon
// enqueues the task under the right owner.
Identity string `json:"identity,omitempty"`
// Org is the org the identity serves, resolved by the producer before
// publishing.
// Empty means the default org of a single-operator install.
Org org.OrgID `json:"org,omitempty"`
// Kind is the routing category, chosen by the publisher. Empty means
// KindDefault, which is also what messages queued before this field
// existed decode to.
Kind Kind `json:"kind,omitempty"`
}
// envelopeWire avoids infinite recursion in the JSON methods below.
type envelopeWire TaskEnvelope
// MarshalJSON flattens Labels into the comma-separated wire field.
func (t TaskEnvelope) MarshalJSON() ([]byte, error) {
t.LabelsRaw = strings.Join(t.Labels, ",")
data, err := json.Marshal(envelopeWire(t))
if err != nil {
return nil, fmt.Errorf("marshal task envelope: %w", err)
}
return data, nil
}
// UnmarshalJSON expands the comma-separated wire field into Labels.
func (t *TaskEnvelope) UnmarshalJSON(data []byte) error {
var wire envelopeWire
if err := json.Unmarshal(data, &wire); err != nil {
return fmt.Errorf("unmarshal task envelope: %w", err)
}
*t = TaskEnvelope(wire)
t.Labels = SplitLabels(t.LabelsRaw)
return nil
}
// Encode renders the envelope for transport.
func (t TaskEnvelope) Encode() ([]byte, error) {
data, err := json.Marshal(t)
if err != nil {
return nil, fmt.Errorf("encode task %s: %w", t.Ref(), err)
}
return data, nil
}
// DecodeTask parses a transported envelope.
func DecodeTask(data []byte) (TaskEnvelope, error) {
var envelope TaskEnvelope
if err := json.Unmarshal(data, &envelope); err != nil {
return TaskEnvelope{}, fmt.Errorf("decode task envelope: %w", err)
}
return envelope, nil
}
// Ref identifies the issue for logs and error messages.
func (t TaskEnvelope) Ref() string {
return t.Owner + "/" + t.Repo + "#" + strconv.Itoa(t.Number)
}
// IdempotencyKey identifies this issue for dedup:
// org/identity/owner/repo/number.
func (t TaskEnvelope) IdempotencyKey() string {
return dedupKeyPrefix + string(t.org()) + "/" + t.Identity + "/" +
t.Owner + "/" + t.Repo + "/" + strconv.Itoa(t.Number)
}
// org resolves the envelope's org, defaulting to the default org a record of
// a single-operator install belongs to.
func (t TaskEnvelope) org() org.OrgID {
if t.Org == "" {
return org.DefaultOrgID
}
return t.Org
}
// Subject returns the address this envelope routes to.
func (t TaskEnvelope) Subject() string { return SubjectForKind(t.Kind) }
// SplitLabels parses the comma-separated wire form, dropping empties so
// "bug,,feature" and a trailing comma do not produce blank labels.
func SplitLabels(raw string) []string {
if raw == "" {
return nil
}
parts := strings.Split(raw, ",")
labels := make([]string, 0, len(parts))
for _, part := range parts {
if trimmed := strings.TrimSpace(part); trimmed != "" {
labels = append(labels, trimmed)
}
}
if len(labels) == 0 {
return nil
}
return labels
}