Files
cairnobs/internal/akamai/papi.go
T
jcoffey-dev db156c4f06
release / release (push) Successful in 7m6s
Cairn OBS
The new Cairn OBS: a self-hosted monitor for networks, hosts and
services. Licensed AGPLv3.
2026-11-14 03:27:09 -07:00

200 lines
6.7 KiB
Go

package akamai
import (
"context"
"net/url"
"slices"
"strings"
"sync"
"time"
)
// Property Manager (docs/akamai.md step 3): each property's versions on
// staging and production, and the newest activation on each network, so
// a failed activation, or one stuck pending, is seen. Field names from
// Akamai's Property Manager API (PAPI v1) reference. Activations' notify
// addresses are never taken.
// PMProperty is a Property Manager property (a delivery configuration;
// GTM's properties are Property).
type PMProperty struct {
ID string `json:"id"` // prp_…
Name string `json:"name"`
Group string `json:"group"` // its group's name
Latest int `json:"latest"`
Staging int `json:"staging"` // the version active there; 0: none
Production int `json:"production"` // the version active there; 0: none
// The newest activation on each network; nil: never activated there.
LastStaging *Activation `json:"last_staging,omitempty"`
LastProduction *Activation `json:"last_production,omitempty"`
Read time.Time `json:"read"` // when its activations were last read
Error string `json:"error,omitempty"`
contract, group string // for the activations' query
}
// Activation is one activation (or deactivation) of a property version.
type Activation struct {
ID string `json:"id"`
Version int `json:"version"`
Type string `json:"type"` // ACTIVATE, DEACTIVATE
Status string `json:"status"` // ACTIVE, FAILED, PENDING, ZONE_1…3, ABORTED, INACTIVE, …
Submitted time.Time `json:"submitted"`
Updated time.Time `json:"updated"`
Note string `json:"note,omitempty"`
}
// Pending says whether the activation hasn't finished.
func (a *Activation) Pending() bool {
switch a.Status {
case "NEW", "PENDING", "ZONE_1", "ZONE_2", "ZONE_3", "PENDING_DEACTIVATION", "PENDING_CANCELLATION":
return true
}
return false
}
type papiGroups struct {
Groups struct {
Items []struct {
GroupID string `json:"groupId"`
GroupName string `json:"groupName"`
ContractIDs []string `json:"contractIds"`
} `json:"items"`
} `json:"groups"`
}
type papiProperties struct {
Properties struct {
Items []struct {
PropertyID string `json:"propertyId"`
PropertyName string `json:"propertyName"`
ContractID string `json:"contractId"`
GroupID string `json:"groupId"`
LatestVersion int `json:"latestVersion"`
StagingVersion *int `json:"stagingVersion"`
ProductionVersion *int `json:"productionVersion"`
} `json:"items"`
} `json:"properties"`
}
type papiActivations struct {
Activations struct {
Items []struct {
ActivationID string `json:"activationId"`
PropertyVersion int `json:"propertyVersion"`
Network string `json:"network"`
ActivationType string `json:"activationType"`
Status string `json:"status"`
SubmitDate time.Time `json:"submitDate"`
UpdateDate time.Time `json:"updateDate"`
Note string `json:"note"`
} `json:"items"`
} `json:"activations"`
}
// activationsRefresh is how long a settled property's activations are
// trusted before they're read again: a property whose versions haven't
// moved, and whose newest activations had finished well, has nothing new
// to say, and an enterprise has hundreds (docs/akamai.md, Scale).
const activationsRefresh = 6 * time.Hour
// propertiesAtOnce is how many properties' activations are read at a time.
const propertiesAtOnce = 4
// readPAPI reads every property the client can see, in each group's
// contracts. Activations are read for a property when its versions moved,
// its newest activation hadn't settled well, or activationsRefresh passed.
func (w *Watcher) readPAPI(ctx context.Context, c Creds, now time.Time, prev []PMProperty) ([]PMProperty, error) {
var gs papiGroups
if err := w.get(ctx, c, "/papi/v1/groups", &gs); err != nil {
return nil, err
}
was := map[string]PMProperty{}
for _, p := range prev {
was[p.ID] = p
}
var out []PMProperty
seen := map[string]bool{}
for _, g := range gs.Groups.Items {
for _, ct := range g.ContractIDs {
var ps papiProperties
q := url.Values{"contractId": {ct}, "groupId": {g.GroupID}}
if err := w.get(ctx, c, "/papi/v1/properties?"+q.Encode(), &ps); err != nil {
return nil, err
}
for _, it := range ps.Properties.Items {
if seen[it.PropertyID] {
continue
}
seen[it.PropertyID] = true
p := PMProperty{ID: it.PropertyID, Name: it.PropertyName, Group: g.GroupName, Latest: it.LatestVersion, contract: ct, group: g.GroupID}
if it.StagingVersion != nil {
p.Staging = *it.StagingVersion
}
if it.ProductionVersion != nil {
p.Production = *it.ProductionVersion
}
out = append(out, p)
}
}
}
var wg sync.WaitGroup
sem := make(chan struct{}, propertiesAtOnce)
for i := range out {
p := &out[i]
if o, ok := was[p.ID]; ok && settled(o, *p, now) {
p.LastStaging, p.LastProduction, p.Read = o.LastStaging, o.LastProduction, o.Read
continue
}
wg.Add(1)
go func() {
defer wg.Done()
sem <- struct{}{}
defer func() { <-sem }()
w.activations(ctx, c, now, p)
}()
}
wg.Wait()
slices.SortFunc(out, func(a, b PMProperty) int { return strings.Compare(a.Name, b.Name) })
return out, nil
}
// settled says whether a property's last reading of its activations still
// stands: read without error, within activationsRefresh, its versions
// unchanged, and its newest activations finished and not failed.
func settled(o, p PMProperty, now time.Time) bool {
if o.Error != "" || o.Read.IsZero() || now.Sub(o.Read) >= activationsRefresh ||
o.Latest != p.Latest || o.Staging != p.Staging || o.Production != p.Production {
return false
}
for _, a := range []*Activation{o.LastStaging, o.LastProduction} {
if a != nil && (a.Pending() || a.Status == "FAILED") {
return false
}
}
return true
}
// activations reads a property's activations and keeps the newest on
// each network.
func (w *Watcher) activations(ctx context.Context, c Creds, now time.Time, p *PMProperty) {
var as papiActivations
q := url.Values{"contractId": {p.contract}, "groupId": {p.group}}
if err := w.get(ctx, c, "/papi/v1/properties/"+url.PathEscape(p.ID)+"/activations?"+q.Encode(), &as); err != nil {
p.Error = err.Error()
return
}
for _, it := range as.Activations.Items {
a := &Activation{ID: it.ActivationID, Version: it.PropertyVersion, Type: it.ActivationType, Status: it.Status,
Submitted: it.SubmitDate, Updated: it.UpdateDate, Note: it.Note}
last := &p.LastStaging
if it.Network == "PRODUCTION" {
last = &p.LastProduction
}
if *last == nil || a.Submitted.After((*last).Submitted) {
*last = a
}
}
p.Read = now
}