Something went wrong. Try again.
This repository has no description
Something went wrong. Try again.
12 kB · 450 lines
Go
at next
123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451package branding
import ( "archive/zip" "bytes" "context" "encoding/json" "errors" "fmt" "io" "mime" "path" "sort" "strings"
"gopkg.in/yaml.v3" "gorm.io/gorm"
"stream.place/streamplace/pkg/statedb")
// A bundle is a zip with branding.yaml at its root plus one file per image// asset. The YAML is the source of truth and is meant to be hand-edited://// version: 1// branding: # only what is set on the node// siteTitle: Sample// primaryColor: "#11e8b2"// navLinks: # JSON keys are real YAML structures// - {label: Home, url: https://example.com, icon: home}// mainLogo: mainLogo.svg # image keys name a file in the zip// defaults: # informational: the app's default for every key// primaryColor: "#6366f1"// ...//// Import replaces: keys absent from the bundle are removed from the node// (or kept, with merge). Every value goes through the same validation as// the admin API, so a bad color or an oversized image is rejected by name.
const ( BundleVersion = 1 yamlName = "branding.yaml" // MaxBundleSize caps an uploaded bundle. MaxBundleSize = 8 * 1024 * 1024)
// Doc is the YAML document.type Doc struct { Version int `yaml:"version"` Branding map[string]interface{} `yaml:"branding"` Defaults map[string]string `yaml:"defaults,omitempty"`}
// Change is one key's transition in an import.type Change struct { Key string `json:"key"` Action string `json:"action"` // added | changed | removed | unchanged // Detail is a short human summary: the new text value, or "<mime> <n>B". Detail string `json:"detail,omitempty"`}
// Report is what an import (or dry run) produced.type Report struct { Applied bool `json:"applied"` Changes []Change `json:"changes"` Warnings []string `json:"warnings,omitempty"`}
var extByMime = map[string]string{ "image/svg+xml": ".svg", "image/png": ".png", "image/jpeg": ".jpg", "image/webp": ".webp", "image/x-icon": ".ico", "image/vnd.microsoft.icon": ".ico", "image/gif": ".gif",}
func fileNameFor(key, mimeType string) string { ext, ok := extByMime[strings.ToLower(strings.TrimSpace(mimeType))] if !ok { exts, _ := mime.ExtensionsByType(mimeType) if len(exts) > 0 { ext = exts[0] } else { ext = ".bin" } } return key + ext}
func mimeFor(name, declared string) string { if declared != "" { return declared } switch strings.ToLower(path.Ext(name)) { case ".svg": return "image/svg+xml" case ".png": return "image/png" case ".jpg", ".jpeg": return "image/jpeg" case ".webp": return "image/webp" case ".ico": return "image/x-icon" case ".gif": return "image/gif" } return "application/octet-stream"}
// Export builds a bundle of everything set on broadcasterID.func Export(ctx context.Context, state *statedb.StatefulDB, broadcasterID string) ([]byte, error) { keys, err := state.ListBrandingKeys(broadcasterID) if err != nil { return nil, err } sort.Strings(keys)
doc := Doc{Version: BundleVersion, Branding: map[string]interface{}{}, Defaults: map[string]string{}} for _, s := range Specs { if s.Kind != KindImage && s.Default != "" { doc.Defaults[s.Key] = s.Default } }
var buf bytes.Buffer zw := zip.NewWriter(&buf) for _, key := range keys { blob, err := state.GetBrandingBlob(broadcasterID, key) if err != nil { if errors.Is(err, gorm.ErrRecordNotFound) { continue } return nil, err } spec, known := Lookup(key) if !known { // Unknown to this build: still round-trip it, as text if it is. if blob.MimeType == TextMime { doc.Branding[key] = string(blob.Data) } continue } if spec.Kind == KindImage { if len(blob.Data) == 0 { continue } name := fileNameFor(key, blob.MimeType) w, err := zw.Create(name) if err != nil { return nil, err } if _, err := w.Write(blob.Data); err != nil { return nil, err } doc.Branding[key] = name continue } v := strings.TrimSpace(string(blob.Data)) if v == "" { continue } if spec.Kind == KindJSON { var parsed interface{} if err := json.Unmarshal([]byte(v), &parsed); err == nil { doc.Branding[key] = parsed continue } } doc.Branding[key] = v }
yw, err := zw.Create(yamlName) if err != nil { return nil, err } header := "# Streamplace branding bundle. Edit branding: and re-import; defaults: is\n# informational. Image keys name files in this zip.\n" if _, err := io.WriteString(yw, header); err != nil { return nil, err } enc := yaml.NewEncoder(yw) enc.SetIndent(2) if err := enc.Encode(&doc); err != nil { return nil, err } if err := enc.Close(); err != nil { return nil, err } if err := zw.Close(); err != nil { return nil, err } return buf.Bytes(), nil}
// parsed is a bundle after reading and validation, ready to apply.type parsed struct { text map[string][]byte // key -> canonical value (non-empty) images map[string]struct { data []byte mime string } warnings []string}
// Parse reads and validates a bundle without touching the database.func Parse(zipBytes []byte) (*parsed, error) { if len(zipBytes) > MaxBundleSize { return nil, fmt.Errorf("bundle is larger than %d bytes", MaxBundleSize) } zr, err := zip.NewReader(bytes.NewReader(zipBytes), int64(len(zipBytes))) if err != nil { return nil, fmt.Errorf("not a zip file: %w", err) } files := map[string]*zip.File{} var yamlFile *zip.File for _, f := range zr.File { name := path.Clean(f.Name) if strings.HasPrefix(name, "../") || strings.HasPrefix(name, "/") || f.FileInfo().IsDir() { continue } if path.Base(name) == yamlName && yamlFile == nil { yamlFile = f continue } files[path.Base(name)] = f } if yamlFile == nil { return nil, fmt.Errorf("bundle has no %s", yamlName) } read := func(f *zip.File, limit int) ([]byte, error) { rc, err := f.Open() if err != nil { return nil, err } defer rc.Close() bs, err := io.ReadAll(io.LimitReader(rc, int64(limit)+1)) if err != nil { return nil, err } if len(bs) > limit { return nil, fmt.Errorf("%s is larger than %d bytes", f.Name, limit) } return bs, nil } ybs, err := read(yamlFile, 256*1024) if err != nil { return nil, err } var doc Doc if err := yaml.Unmarshal(ybs, &doc); err != nil { return nil, fmt.Errorf("%s: %w", yamlName, err) } if doc.Version == 0 { doc.Version = BundleVersion } if doc.Version > BundleVersion { return nil, fmt.Errorf("bundle version %d is newer than this node understands (%d)", doc.Version, BundleVersion) }
p := &parsed{text: map[string][]byte{}, images: map[string]struct { data []byte mime string }{}} keys := make([]string, 0, len(doc.Branding)) for k := range doc.Branding { keys = append(keys, k) } sort.Strings(keys) for _, key := range keys { raw := doc.Branding[key] spec, known := Lookup(key) if !known { p.warnings = append(p.warnings, fmt.Sprintf("%s: unknown key, kept as text", key)) spec = Spec{Key: key, Kind: KindText, MaxSize: jsonMax} } if raw == nil { continue } if spec.Kind == KindImage { name, ok := raw.(string) if !ok { return nil, fmt.Errorf("%s: expected a file name", key) } f, ok := files[path.Base(name)] if !ok { return nil, fmt.Errorf("%s: file %q not in bundle", key, name) } data, err := read(f, spec.MaxSize) if err != nil { return nil, fmt.Errorf("%s: %w", key, err) } p.images[key] = struct { data []byte mime string }{data: data, mime: mimeFor(name, "")} continue } var text string switch v := raw.(type) { case string: text = v case bool, int, int64, float64: text = fmt.Sprint(v) default: // JSON-valued keys arrive as YAML structures. bs, err := json.Marshal(yamlToJSON(v)) if err != nil { return nil, fmt.Errorf("%s: %w", key, err) } text = string(bs) } if len(text) > spec.MaxSize { return nil, fmt.Errorf("%s is larger than %d bytes", key, spec.MaxSize) } canon, err := Normalize(key, []byte(text)) if err != nil { return nil, err } if len(canon) == 0 { continue } p.text[key] = canon } return p, nil}
// yamlToJSON converts yaml.v3's map[string]interface{} / []interface{}// trees (already string-keyed in v3) into something json.Marshal accepts.func yamlToJSON(v interface{}) interface{} { switch t := v.(type) { case map[string]interface{}: out := map[string]interface{}{} for k, val := range t { out[k] = yamlToJSON(val) } return out case map[interface{}]interface{}: out := map[string]interface{}{} for k, val := range t { out[fmt.Sprint(k)] = yamlToJSON(val) } return out case []interface{}: out := make([]interface{}, len(t)) for i, val := range t { out[i] = yamlToJSON(val) } return out } return v}
// Import applies a bundle to broadcasterID. With merge, keys absent from// the bundle are left alone; otherwise they are removed. With dryRun the// report is computed and nothing is written.func Import(ctx context.Context, state *statedb.StatefulDB, broadcasterID string, zipBytes []byte, merge, dryRun bool) (*Report, error) { p, err := Parse(zipBytes) if err != nil { return nil, err } existingKeys, err := state.ListBrandingKeys(broadcasterID) if err != nil { return nil, err } existing := map[string]*statedb.BrandingBlob{} for _, k := range existingKeys { b, err := state.GetBrandingBlob(broadcasterID, k) if err == nil && (len(b.Data) > 0) { existing[k] = b } }
report := &Report{Warnings: p.warnings, Changes: []Change{}} type write struct { key, mime string data []byte } var writes []write var removes []string
for key, val := range p.text { if cur, ok := existing[key]; ok && sameText(key, cur.Data, val) { report.Changes = append(report.Changes, Change{Key: key, Action: "unchanged"}) continue } action := "added" if _, ok := existing[key]; ok { action = "changed" } detail := string(val) if len(detail) > 80 { detail = detail[:77] + "..." } report.Changes = append(report.Changes, Change{Key: key, Action: action, Detail: detail}) writes = append(writes, write{key: key, mime: TextMime, data: val}) } for key, img := range p.images { if cur, ok := existing[key]; ok && bytes.Equal(cur.Data, img.data) { report.Changes = append(report.Changes, Change{Key: key, Action: "unchanged"}) continue } action := "added" if _, ok := existing[key]; ok { action = "changed" } report.Changes = append(report.Changes, Change{Key: key, Action: action, Detail: fmt.Sprintf("%s %dB", img.mime, len(img.data))}) writes = append(writes, write{key: key, mime: img.mime, data: img.data}) } if !merge { for key := range existing { if _, inText := p.text[key]; inText { continue } if _, inImg := p.images[key]; inImg { continue } report.Changes = append(report.Changes, Change{Key: key, Action: "removed"}) removes = append(removes, key) } } sort.Slice(report.Changes, func(i, j int) bool { return report.Changes[i].Key < report.Changes[j].Key })
if dryRun { return report, nil } // All or nothing: a failure partway through must not leave the node on a // mix of the old branding and the new. bw := make([]statedb.BrandingWrite, 0, len(writes)) for _, w := range writes { bw = append(bw, statedb.BrandingWrite{Key: w.key, MimeType: w.mime, Data: w.data}) } if err := state.ApplyBrandingWrites(broadcasterID, bw, removes); err != nil { return nil, err } report.Applied = true return report, nil}
// sameText compares a stored text value with a canonical incoming one,// treating JSON keys semantically (older rows may hold uncanonicalized JSON).func sameText(key string, stored, incoming []byte) bool { if spec, ok := Lookup(key); ok && spec.Kind == KindJSON { if c, err := CanonicalJSON(stored); err == nil { return bytes.Equal(c, incoming) } } return bytes.Equal(bytes.TrimSpace(stored), incoming)}