190 lines
4.6 KiB
Go
190 lines
4.6 KiB
Go
// Package draft owns retained, private Markdown drafts shared by both interfaces.
|
||
package draft
|
||
|
||
import (
|
||
"encoding/json"
|
||
"fmt"
|
||
"io"
|
||
"os"
|
||
"path/filepath"
|
||
"sort"
|
||
"strings"
|
||
)
|
||
|
||
type Draft struct {
|
||
Path string `json:"path"`
|
||
Name string `json:"name"`
|
||
Server string `json:"server,omitempty"`
|
||
CreateOnly bool `json:"create_only"`
|
||
BaseVersion int `json:"base_version,omitempty"`
|
||
}
|
||
|
||
func Directory() (string, error) {
|
||
if dir := os.Getenv("PIPELINES_DRAFT_DIR"); dir != "" {
|
||
return filepath.Abs(dir)
|
||
}
|
||
cache, err := os.UserCacheDir()
|
||
return filepath.Join(cache, "pipelines", "drafts"), err
|
||
}
|
||
|
||
func Create(name, source, server string, fresh bool, base int) (Draft, error) {
|
||
dir, err := Directory()
|
||
if err != nil {
|
||
return Draft{}, err
|
||
}
|
||
if err = os.MkdirAll(dir, 0700); err != nil {
|
||
return Draft{}, err
|
||
}
|
||
f, err := os.CreateTemp(dir, "pipeline-*.md")
|
||
if err != nil {
|
||
return Draft{}, err
|
||
}
|
||
path := f.Name()
|
||
_, writeErr := f.WriteString(source)
|
||
closeErr := f.Close()
|
||
if writeErr != nil {
|
||
return Draft{}, writeErr
|
||
}
|
||
if closeErr != nil {
|
||
return Draft{}, closeErr
|
||
}
|
||
d := Draft{Path: path, Name: name, Server: server, CreateOnly: fresh, BaseVersion: base}
|
||
data, _ := json.MarshalIndent(d, "", " ")
|
||
err = os.WriteFile(path+".json", data, 0600)
|
||
return d, err
|
||
}
|
||
|
||
func Read(path string) (string, error) {
|
||
f, err := os.Open(path)
|
||
if err != nil {
|
||
return "", err
|
||
}
|
||
defer f.Close()
|
||
info, err := f.Stat()
|
||
if err != nil {
|
||
return "", err
|
||
}
|
||
if !info.Mode().IsRegular() || info.Size() > 1<<20 {
|
||
return "", fmt.Errorf("draft must be a regular file no larger than 1 MiB")
|
||
}
|
||
// Bound the read even if an editor grows the file after Stat.
|
||
data, err := io.ReadAll(io.LimitReader(f, (1<<20)+1))
|
||
if err != nil {
|
||
return "", err
|
||
}
|
||
if len(data) > 1<<20 {
|
||
return "", fmt.Errorf("draft exceeds 1 MiB")
|
||
}
|
||
return string(data), nil
|
||
}
|
||
|
||
func Load(path string) (Draft, error) {
|
||
absolute, err := filepath.Abs(path)
|
||
if err != nil {
|
||
return Draft{}, err
|
||
}
|
||
data, err := os.ReadFile(absolute + ".json")
|
||
if err != nil {
|
||
return Draft{}, err
|
||
}
|
||
var d Draft
|
||
if err = json.Unmarshal(data, &d); err != nil {
|
||
return d, err
|
||
}
|
||
d.Path = absolute // Never trust a metadata file to redirect submission to another source.
|
||
return d, nil
|
||
}
|
||
|
||
func List() ([]Draft, error) {
|
||
dir, err := Directory()
|
||
if err != nil {
|
||
return nil, err
|
||
}
|
||
paths, err := filepath.Glob(filepath.Join(dir, "pipeline-*.md.json"))
|
||
if err != nil {
|
||
return nil, err
|
||
}
|
||
sort.Strings(paths)
|
||
items := []Draft{}
|
||
for _, path := range paths {
|
||
d, err := Load(path[:len(path)-5])
|
||
if err != nil {
|
||
return nil, err
|
||
}
|
||
items = append(items, d)
|
||
}
|
||
return items, nil
|
||
}
|
||
|
||
// SetName updates only retained metadata, preserving source and publication scope.
|
||
func SetName(path, name string) error {
|
||
name = strings.TrimSpace(name)
|
||
if name == "" || len(name) > 200 || strings.ContainsAny(name, "\r\n\x00") {
|
||
return fmt.Errorf("pipeline name must be 1–200 bytes without line breaks or NUL")
|
||
}
|
||
d, err := Load(path)
|
||
if err != nil {
|
||
return err
|
||
}
|
||
metadata := d.Path + ".json"
|
||
info, err := os.Lstat(metadata)
|
||
if err != nil {
|
||
return err
|
||
}
|
||
if !info.Mode().IsRegular() {
|
||
return fmt.Errorf("draft metadata must be a regular file, not a symlink")
|
||
}
|
||
d.Name = name
|
||
data, err := json.MarshalIndent(d, "", " ")
|
||
if err != nil {
|
||
return err
|
||
}
|
||
f, err := os.CreateTemp(filepath.Dir(metadata), ".draft-name-*")
|
||
if err != nil {
|
||
return err
|
||
}
|
||
defer os.Remove(f.Name())
|
||
_, writeErr := f.Write(data)
|
||
closeErr := f.Close()
|
||
if writeErr != nil {
|
||
return writeErr
|
||
}
|
||
if closeErr != nil {
|
||
return closeErr
|
||
}
|
||
return os.Rename(f.Name(), metadata)
|
||
}
|
||
|
||
// Delete only a selected, managed cache draft and its sidecar. Never recurse,
|
||
// follow a file symlink, or delete an arbitrary external submission source.
|
||
func Delete(path string) error {
|
||
dir, err := Directory()
|
||
if err != nil {
|
||
return err
|
||
}
|
||
absolute, err := filepath.Abs(path)
|
||
if err != nil {
|
||
return err
|
||
}
|
||
name := filepath.Base(absolute)
|
||
if filepath.Dir(absolute) != filepath.Clean(dir) || !strings.HasPrefix(name, "pipeline-") || !strings.HasSuffix(name, ".md") {
|
||
return fmt.Errorf("only managed drafts inside %s can be deleted", dir)
|
||
}
|
||
for _, file := range []string{absolute + ".json", absolute} {
|
||
info, err := os.Lstat(file)
|
||
if os.IsNotExist(err) && file == absolute {
|
||
continue
|
||
}
|
||
if err != nil {
|
||
return err
|
||
}
|
||
if !info.Mode().IsRegular() {
|
||
return fmt.Errorf("draft and metadata must be regular files, not symlinks or directories")
|
||
}
|
||
}
|
||
if err := os.Remove(absolute); err != nil && !os.IsNotExist(err) {
|
||
return err
|
||
}
|
||
return os.Remove(absolute + ".json")
|
||
}
|