465 lines
11 KiB
Go
465 lines
11 KiB
Go
package topdata
|
|
|
|
import (
|
|
"crypto/sha1"
|
|
"encoding/base64"
|
|
"encoding/json"
|
|
"errors"
|
|
"fmt"
|
|
"io"
|
|
"net/http"
|
|
"os"
|
|
"path/filepath"
|
|
"slices"
|
|
"strings"
|
|
"time"
|
|
|
|
"gitea.westgate.pw/ShadowsOverWestgate/sow-tools/internal/project"
|
|
)
|
|
|
|
const (
|
|
defaultDeployManifestName = ".wiki_deploy_manifest.json"
|
|
defaultEditSummary = "Auto-generated from native builder"
|
|
defaultNotesDelimiter = "===== Notes ====="
|
|
)
|
|
|
|
var defaultManagedNamespaces = []string{"classes", "feat", "itemtypes", "races", "skills", "spells"}
|
|
|
|
type DeployWikiOptions struct {
|
|
SourceDir string
|
|
Endpoint string
|
|
Username string
|
|
Password string
|
|
Version string
|
|
Namespaces []string
|
|
NotesDelimiter string
|
|
ManifestPath string
|
|
DryRun bool
|
|
}
|
|
|
|
type deployResult struct {
|
|
LocalPages int
|
|
Updated int
|
|
Deleted int
|
|
Skipped int
|
|
Manifest string
|
|
}
|
|
|
|
type deployPlan struct {
|
|
PageID string
|
|
Content string
|
|
OldContent string
|
|
}
|
|
|
|
type manifestEntry struct {
|
|
Hash string `json:"hash"`
|
|
}
|
|
|
|
func DeployWikiWithOptions(p *project.Project, opts DeployWikiOptions, progress func(string)) (deployResult, error) {
|
|
if progress == nil {
|
|
progress = func(string) {}
|
|
}
|
|
|
|
if opts.SourceDir == "" {
|
|
opts.SourceDir = wikiOutputPagesDir(p)
|
|
}
|
|
if _, err := os.Stat(opts.SourceDir); err != nil {
|
|
return deployResult{}, fmt.Errorf("wiki source directory not found: %w", err)
|
|
}
|
|
|
|
if opts.Endpoint == "" {
|
|
return deployResult{}, errors.New("DOKUWIKI_RPC_ENDPOINT is required")
|
|
}
|
|
if opts.Username == "" {
|
|
return deployResult{}, errors.New("DOKUWIKI_RPC_USERNAME is required")
|
|
}
|
|
if opts.Password == "" {
|
|
return deployResult{}, errors.New("DOKUWIKI_RPC_PASSWORD is required")
|
|
}
|
|
|
|
namespaces := opts.Namespaces
|
|
if len(namespaces) == 0 {
|
|
namespaces = defaultManagedNamespaces
|
|
}
|
|
|
|
notesDelimiter := opts.NotesDelimiter
|
|
if notesDelimiter == "" {
|
|
notesDelimiter = defaultNotesDelimiter
|
|
}
|
|
|
|
manifestPath := opts.ManifestPath
|
|
if manifestPath == "" {
|
|
manifestPath = filepath.Join(filepath.Dir(opts.SourceDir), defaultDeployManifestName)
|
|
}
|
|
|
|
localPages, err := collectLocalPages(opts.SourceDir, namespaces)
|
|
if err != nil {
|
|
return deployResult{}, err
|
|
}
|
|
|
|
manifest := loadDeployManifest(manifestPath)
|
|
client := newDokuWikiClient(opts.Endpoint, opts.Username, opts.Password)
|
|
|
|
deployments, stalePages, err := planDeploy(localPages, client, namespaces, notesDelimiter, manifest)
|
|
if err != nil {
|
|
return deployResult{}, err
|
|
}
|
|
|
|
progress(fmt.Sprintf("Deploying %d pages...", len(deployments)))
|
|
|
|
editSummary := defaultEditSummary
|
|
if opts.Version != "" {
|
|
editSummary = fmt.Sprintf("%s (%s)", defaultEditSummary, opts.Version)
|
|
}
|
|
|
|
if !opts.DryRun {
|
|
for _, plan := range deployments {
|
|
if err := client.putPage(plan.PageID, plan.Content, editSummary); err != nil {
|
|
return deployResult{}, err
|
|
}
|
|
}
|
|
for _, pageID := range stalePages {
|
|
if err := client.deletePage(pageID, editSummary); err != nil {
|
|
return deployResult{}, err
|
|
}
|
|
}
|
|
|
|
currentHashes := computePageHashes(localPages, notesDelimiter)
|
|
saveDeployManifest(manifestPath, currentHashes)
|
|
}
|
|
|
|
updated := len(deployments)
|
|
deleted := len(stalePages)
|
|
skipped := len(localPages) - updated
|
|
|
|
result := deployResult{
|
|
LocalPages: len(localPages),
|
|
Updated: updated,
|
|
Deleted: deleted,
|
|
Skipped: skipped,
|
|
Manifest: manifestPath,
|
|
}
|
|
|
|
progress(fmt.Sprintf("Updated: %d, Skipped: %d, Deleted: %d", updated, skipped, deleted))
|
|
|
|
return result, nil
|
|
}
|
|
|
|
func collectLocalPages(sourceDir string, namespaces []string) (map[string]string, error) {
|
|
pages := map[string]string{}
|
|
for _, ns := range namespaces {
|
|
nsDir := filepath.Join(sourceDir, ns)
|
|
if !isDir(nsDir) {
|
|
continue
|
|
}
|
|
if err := filepath.WalkDir(nsDir, func(path string, d os.DirEntry, err error) error {
|
|
if err != nil {
|
|
return err
|
|
}
|
|
if d.IsDir() {
|
|
return nil
|
|
}
|
|
if filepath.Ext(path) != ".txt" {
|
|
return nil
|
|
}
|
|
rel, err := filepath.Rel(sourceDir, path)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
pageID := strings.TrimSuffix(rel, ".txt")
|
|
pageID = strings.ReplaceAll(pageID, string(filepath.Separator), ":")
|
|
pageID = strings.ToLower(pageID)
|
|
content, err := os.ReadFile(path)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
pages[pageID] = string(content)
|
|
return nil
|
|
}); err != nil {
|
|
return nil, err
|
|
}
|
|
}
|
|
return pages, nil
|
|
}
|
|
|
|
func computePageHash(content, notesDelimiter string) string {
|
|
generatedBody, _ := splitNotesSection(content, notesDelimiter)
|
|
h := sha1.New()
|
|
h.Write([]byte(generatedBody))
|
|
return fmt.Sprintf("%x", h.Sum(nil))
|
|
}
|
|
|
|
func computePageHashes(pages map[string]string, notesDelimiter string) map[string]string {
|
|
hashes := map[string]string{}
|
|
for pageID, content := range pages {
|
|
hashes[pageID] = computePageHash(content, notesDelimiter)
|
|
}
|
|
return hashes
|
|
}
|
|
|
|
func splitNotesSection(content, notesDelimiter string) (string, string) {
|
|
lines := strings.Split(content, notesDelimiter)
|
|
if len(lines) <= 1 {
|
|
return strings.TrimSpace(content), ""
|
|
}
|
|
body := strings.TrimSpace(strings.Join(lines[:len(lines)-1], notesDelimiter))
|
|
notes := strings.TrimSpace(strings.Join(lines[1:], notesDelimiter))
|
|
return body, notes
|
|
}
|
|
|
|
func loadDeployManifest(path string) map[string]string {
|
|
if _, err := os.Stat(path); err != nil {
|
|
return map[string]string{}
|
|
}
|
|
data, err := os.ReadFile(path)
|
|
if err != nil {
|
|
return map[string]string{}
|
|
}
|
|
var doc struct {
|
|
Pages map[string]string `json:"pages"`
|
|
}
|
|
if err := json.Unmarshal(data, &doc); err != nil {
|
|
return map[string]string{}
|
|
}
|
|
result := map[string]string{}
|
|
for k, v := range doc.Pages {
|
|
result[k] = v
|
|
}
|
|
return result
|
|
}
|
|
|
|
func saveDeployManifest(path string, hashes map[string]string) {
|
|
os.MkdirAll(filepath.Dir(path), 0755)
|
|
doc := struct {
|
|
Pages map[string]string `json:"pages"`
|
|
}{
|
|
Pages: hashes,
|
|
}
|
|
data, _ := json.MarshalIndent(doc, "", " ")
|
|
os.WriteFile(path, append(data, '\n'), 0644)
|
|
}
|
|
|
|
func planDeploy(
|
|
localPages map[string]string,
|
|
client *dokuWikiClient,
|
|
namespaces []string,
|
|
notesDelimiter string,
|
|
previousHashes map[string]string,
|
|
) ([]deployPlan, []string, error) {
|
|
var deployments []deployPlan
|
|
remotePages := map[string]string{}
|
|
|
|
for pageID, content := range localPages {
|
|
hash := computePageHash(content, notesDelimiter)
|
|
if previousHashes[pageID] == hash {
|
|
continue
|
|
}
|
|
|
|
oldContent, err := client.getPage(pageID)
|
|
if err != nil {
|
|
if !errors.Is(err, errPageNotFound) {
|
|
return nil, nil, err
|
|
}
|
|
oldContent = ""
|
|
}
|
|
remotePages[pageID] = oldContent
|
|
|
|
merged := mergePageContent(content, oldContent, notesDelimiter)
|
|
if merged != oldContent {
|
|
deployments = append(deployments, deployPlan{
|
|
PageID: pageID,
|
|
Content: merged,
|
|
OldContent: oldContent,
|
|
})
|
|
}
|
|
}
|
|
|
|
remoteIDs := map[string]bool{}
|
|
for pageID := range remotePages {
|
|
remoteIDs[pageID] = true
|
|
}
|
|
|
|
for _, ns := range namespaces {
|
|
pages, err := client.listNamespacePages(ns)
|
|
if err != nil {
|
|
continue
|
|
}
|
|
for _, pageID := range pages {
|
|
remoteIDs[pageID] = true
|
|
}
|
|
}
|
|
|
|
var stale []string
|
|
for pageID := range remoteIDs {
|
|
if _, exists := localPages[pageID]; !exists {
|
|
stale = append(stale, pageID)
|
|
}
|
|
}
|
|
slices.Sort(stale)
|
|
|
|
return deployments, stale, nil
|
|
}
|
|
|
|
func mergePageContent(generated, existing, notesDelimiter string) string {
|
|
_, existingNotes := splitNotesSection(existing, notesDelimiter)
|
|
generatedBody, _ := splitNotesSection(generated, notesDelimiter)
|
|
|
|
if existingNotes == "" {
|
|
return generated
|
|
}
|
|
|
|
return strings.TrimSpace(generatedBody) + "\n\n" + notesDelimiter + "\n\n" + existingNotes + "\n"
|
|
}
|
|
|
|
type dokuWikiClient struct {
|
|
endpoint string
|
|
username string
|
|
password string
|
|
timeout time.Duration
|
|
retryAttempts int
|
|
retryBackoff time.Duration
|
|
requestDelay time.Duration
|
|
}
|
|
|
|
var errPageNotFound = errors.New("page not found")
|
|
|
|
func newDokuWikiClient(endpoint, username, password string) *dokuWikiClient {
|
|
endpoint = strings.TrimRight(endpoint, "/")
|
|
if strings.HasSuffix(endpoint, "/doku.php") {
|
|
endpoint = strings.TrimSuffix(endpoint, "/doku.php") + "/lib/exe/jsonrpc.php"
|
|
}
|
|
return &dokuWikiClient{
|
|
endpoint: endpoint,
|
|
username: username,
|
|
password: password,
|
|
timeout: 30 * time.Second,
|
|
retryAttempts: 3,
|
|
retryBackoff: 500 * time.Millisecond,
|
|
requestDelay: 50 * time.Millisecond,
|
|
}
|
|
}
|
|
|
|
func (c *dokuWikiClient) getPage(pageID string) (string, error) {
|
|
result, err := c.rpc("wiki.getPage", []any{pageID})
|
|
if err != nil {
|
|
return "", err
|
|
}
|
|
if result == nil {
|
|
return "", errPageNotFound
|
|
}
|
|
s, ok := result.(string)
|
|
if !ok {
|
|
return "", nil
|
|
}
|
|
return s, nil
|
|
}
|
|
|
|
func (c *dokuWikiClient) putPage(pageID, content, summary string) error {
|
|
_, err := c.rpc("wiki.putPage", []any{pageID, content, map[string]any{"sum": summary}})
|
|
return err
|
|
}
|
|
|
|
func (c *dokuWikiClient) deletePage(pageID, summary string) error {
|
|
_, err := c.rpc("wiki.putPage", []any{pageID, "", map[string]any{"sum": summary, "minor": false}})
|
|
return err
|
|
}
|
|
|
|
func (c *dokuWikiClient) listNamespacePages(namespace string) ([]string, error) {
|
|
result, err := c.rpc("dokuwiki.getPagelist", []any{namespace, map[string]any{}})
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
items, ok := result.([]any)
|
|
if !ok {
|
|
return nil, nil
|
|
}
|
|
var pages []string
|
|
for _, item := range items {
|
|
switch v := item.(type) {
|
|
case string:
|
|
pages = append(pages, v)
|
|
case map[string]any:
|
|
if id, ok := v["id"].(string); ok {
|
|
pages = append(pages, id)
|
|
}
|
|
}
|
|
}
|
|
return pages, nil
|
|
}
|
|
|
|
func (c *dokuWikiClient) rpc(method string, params []any) (any, error) {
|
|
var last error
|
|
for attempt := 1; attempt <= c.retryAttempts; attempt++ {
|
|
result, err := c.rpcOnce(method, params)
|
|
if err == nil {
|
|
return result, nil
|
|
}
|
|
last = err
|
|
if attempt < c.retryAttempts {
|
|
time.Sleep(c.retryBackoff * time.Duration(attempt))
|
|
}
|
|
}
|
|
return nil, fmt.Errorf("%s failed after %d attempts: %w", method, c.retryAttempts, last)
|
|
}
|
|
|
|
func (c *dokuWikiClient) rpcOnce(method string, params []any) (any, error) {
|
|
if c.requestDelay > 0 {
|
|
time.Sleep(c.requestDelay)
|
|
}
|
|
|
|
payload := map[string]any{
|
|
"jsonrpc": "2.0",
|
|
"method": method,
|
|
"params": params,
|
|
"id": 1,
|
|
}
|
|
body, err := json.Marshal(payload)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
|
|
token := base64.StdEncoding.EncodeToString([]byte(c.username + ":" + c.password))
|
|
req, err := http.NewRequest("POST", c.endpoint, strings.NewReader(string(body)))
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
req.Header.Set("Authorization", "Basic "+token)
|
|
req.Header.Set("Content-Type", "application/json")
|
|
req.Header.Set("Accept", "application/json")
|
|
|
|
resp, err := http.DefaultClient.Do(req)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
defer resp.Body.Close()
|
|
|
|
data, err := io.ReadAll(resp.Body)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
|
|
var result map[string]any
|
|
if err := json.Unmarshal(data, &result); err != nil {
|
|
preview := strings.TrimSpace(string(data))
|
|
if len(preview) > 200 {
|
|
preview = preview[:200] + "..."
|
|
}
|
|
return nil, fmt.Errorf("non-JSON response: %s", preview)
|
|
}
|
|
|
|
if errMsg, ok := result["error"].(any); ok && errMsg != nil {
|
|
return nil, fmt.Errorf("RPC error: %v", errMsg)
|
|
}
|
|
|
|
if resp.StatusCode >= 400 {
|
|
return nil, fmt.Errorf("HTTP %d", resp.StatusCode)
|
|
}
|
|
|
|
return result["result"], nil
|
|
}
|
|
|
|
func isDir(path string) bool {
|
|
info, err := os.Stat(path)
|
|
return err == nil && info.IsDir()
|
|
}
|