fup: add cheddar as a syntax highlighter

This commit is contained in:
Luke Granger-Brown 2021-03-21 18:52:22 +00:00
parent d604c261e0
commit b7cd0d0e29
3 changed files with 213 additions and 4 deletions

View file

@ -9,12 +9,14 @@ import (
"fmt" "fmt"
"log" "log"
"net/http" "net/http"
"os/exec"
"strings" "strings"
"github.com/google/safehtml" "github.com/google/safehtml"
"github.com/spf13/cobra" "github.com/spf13/cobra"
"hg.lukegb.com/lukegb/depot/web/fup/fuphttp" "hg.lukegb.com/lukegb/depot/web/fup/fuphttp"
"hg.lukegb.com/lukegb/depot/web/fup/fupstatic" "hg.lukegb.com/lukegb/depot/web/fup/fupstatic"
"hg.lukegb.com/lukegb/depot/web/fup/minicheddar"
) )
func init() { func init() {
@ -24,6 +26,9 @@ func init() {
serveCmd.Flags().StringVar(&serveStaticRoot, "static-root", "/static/", "Root address from which static assets should be referenced.") serveCmd.Flags().StringVar(&serveStaticRoot, "static-root", "/static/", "Root address from which static assets should be referenced.")
serveCmd.Flags().StringVarP(&serveBind, "listen", "l", ":8191", "Bind address for HTTP server.") serveCmd.Flags().StringVarP(&serveBind, "listen", "l", ":8191", "Bind address for HTTP server.")
serveCmd.Flags().BoolVar(&serveDirectOnly, "direct-only", false, "If set, all file serving will be proxied, even if the backend supports signed URLs.") serveCmd.Flags().BoolVar(&serveDirectOnly, "direct-only", false, "If set, all file serving will be proxied, even if the backend supports signed URLs.")
serveCmd.Flags().StringVar(&serveCheddarPath, "cheddar-path", "cheddar", "Path to 'cheddar' binary to use for syntax highlighting. If it cannot be found, syntax highlighting and markdown rendering will be disabled.")
serveCmd.Flags().StringVar(&serveCheddarAddr, "cheddar-address", "", "If non-empty, will be used instead of attempting to spawn a copy of cheddar.")
} }
var ( var (
@ -31,6 +36,8 @@ var (
serveRoot string serveRoot string
serveStaticRoot string serveStaticRoot string
serveDirectOnly bool serveDirectOnly bool
serveCheddarPath string
serveCheddarAddr string
serveCmd = &cobra.Command{ serveCmd = &cobra.Command{
Use: "serve", Use: "serve",
@ -44,6 +51,11 @@ var (
} }
ctx := context.Background() ctx := context.Background()
highlighter, err := serveCheddar(ctx)
if err != nil {
return fmt.Errorf("spawning cheddar syntax highlighter: %v", err)
}
cfg := &fuphttp.Config{ cfg := &fuphttp.Config{
Templates: fupstatic.Templates, Templates: fupstatic.Templates,
Static: fupstatic.Static, Static: fupstatic.Static,
@ -51,6 +63,7 @@ var (
AppRoot: serveRoot, AppRoot: serveRoot,
StorageURL: bucketURL, StorageURL: bucketURL,
RedirectToBlobstore: !serveDirectOnly, RedirectToBlobstore: !serveDirectOnly,
Highlighter: highlighter,
} }
a, err := fuphttp.New(ctx, cfg) a, err := fuphttp.New(ctx, cfg)
if err != nil { if err != nil {
@ -63,3 +76,17 @@ var (
}, },
} }
) )
func serveCheddar(ctx context.Context) (*minicheddar.Cheddar, error) {
if serveCheddarAddr != "" {
return minicheddar.Remote(serveCheddarAddr), nil
}
cpath, err := exec.LookPath(serveCheddarPath)
if err != nil {
log.Printf("couldn't find cheddar at %q; disabling syntax highlighting", serveCheddarPath)
return nil, nil
}
return minicheddar.Spawn(ctx, cpath)
}

View file

@ -27,6 +27,11 @@ const (
defaultRedirectExpiry = 5 * time.Minute defaultRedirectExpiry = 5 * time.Minute
) )
type Highlighter interface {
Markdown(ctx context.Context, text string) (safehtml.HTML, error)
Code(ctx context.Context, filename, theme, text string) (safehtml.HTML, error)
}
type Config struct { type Config struct {
Templates fs.FS Templates fs.FS
Static fs.FS Static fs.FS
@ -48,6 +53,10 @@ type Config struct {
// FilenameGenerator returns a new filename based on the provided prefix and extension. // FilenameGenerator returns a new filename based on the provided prefix and extension.
FilenameGenerator fngen.FilenameGenerator FilenameGenerator fngen.FilenameGenerator
// Highlighter is used for syntax highlighting and Markdown rendering.
// If nil, then no syntax highlighting or Markdown rendering will be performed.
Highlighter Highlighter
// UseDirectDownload decides whether the "pretty" wrapped page or the direct download page is the most appropriate for a given set of parameters. // UseDirectDownload decides whether the "pretty" wrapped page or the direct download page is the most appropriate for a given set of parameters.
UseDirectDownload func(fileExtension string, mimeType string) bool UseDirectDownload func(fileExtension string, mimeType string) bool
} }
@ -59,6 +68,8 @@ type Application struct {
appRoot string appRoot string
highlighter Highlighter
redirectToBlobstore bool redirectToBlobstore bool
redirectExpiry time.Duration redirectExpiry time.Duration

View file

@ -0,0 +1,171 @@
// SPDX-FileCopyrightText: 2021 Luke Granger-Brown <depot@lukegb.com>
//
// SPDX-License-Identifier: Apache-2.0
package minicheddar
import (
"bytes"
"context"
"encoding/json"
"errors"
"fmt"
"net"
"net/http"
"os/exec"
"time"
"github.com/google/safehtml"
"github.com/google/safehtml/uncheckedconversions"
)
const startupMax = 10 * time.Second
type Cheddar struct {
remote string
stop func()
}
type markdownReqResp struct {
Data string `json:"data"`
}
func (c *Cheddar) Markdown(ctx context.Context, text string) (safehtml.HTML, error) {
buf := new(bytes.Buffer)
if err := json.NewEncoder(buf).Encode(markdownReqResp{Data: text}); err != nil {
return safehtml.HTML{}, fmt.Errorf("encoding markdown rendering request: %w", err)
}
req, err := http.NewRequestWithContext(ctx, "POST", fmt.Sprintf("%s/markdown", c.remote), buf)
if err != nil {
return safehtml.HTML{}, fmt.Errorf("making markdown request object: %w", err)
}
req.Header.Set("Content-type", "application/json")
resp, err := http.DefaultClient.Do(req)
if err != nil {
return safehtml.HTML{}, err
}
defer resp.Body.Close()
if resp.StatusCode != http.StatusOK {
return safehtml.HTML{}, fmt.Errorf("markdown rendering request returned status %s; not OK", resp.StatusCode)
}
var respData markdownReqResp
if err := json.NewDecoder(resp.Body).Decode(&respData); err != nil {
return safehtml.HTML{}, fmt.Errorf("decoding markdown rendering response: %w", err)
}
return uncheckedconversions.HTMLFromStringKnownToSatisfyTypeContract(respData.Data), nil
}
type codeReq struct {
Filepath string `json:"filepath"`
Theme string `json:"theme"`
Code string `json:"code"`
}
type codeResp struct {
IsPlaintext bool `json:"is_plaintext"`
Data string `json:"data"`
}
func (c *Cheddar) Code(ctx context.Context, filename, theme, text string) (safehtml.HTML, error) {
buf := new(bytes.Buffer)
if err := json.NewEncoder(buf).Encode(codeReq{
Filepath: filename,
Theme: theme,
Code: text,
}); err != nil {
return safehtml.HTML{}, fmt.Errorf("encoding code rendering request: %w", err)
}
req, err := http.NewRequestWithContext(ctx, "POST", fmt.Sprintf("%s", c.remote), buf)
if err != nil {
return safehtml.HTML{}, fmt.Errorf("making code request object: %w", err)
}
req.Header.Set("Content-type", "application/json")
resp, err := http.DefaultClient.Do(req)
if err != nil {
return safehtml.HTML{}, err
}
defer resp.Body.Close()
if resp.StatusCode != http.StatusOK {
return safehtml.HTML{}, fmt.Errorf("code rendering request returned status %s; not OK", resp.StatusCode)
}
var respData codeResp
if err := json.NewDecoder(resp.Body).Decode(&respData); err != nil {
return safehtml.HTML{}, fmt.Errorf("decoding code rendering response: %w", err)
}
if respData.IsPlaintext {
return safehtml.HTMLEscaped(respData.Data), nil
}
return uncheckedconversions.HTMLFromStringKnownToSatisfyTypeContract(respData.Data), nil
}
func (c *Cheddar) healthCheck(ctx context.Context) error {
_, err := c.Markdown(ctx, "")
return err
}
func (c *Cheddar) Close() {
if c.stop != nil {
c.stop()
}
}
// Remote connects to an already running instance of Cheddar.
func Remote(url string) *Cheddar {
return &Cheddar{
remote: url,
}
}
// Spawn spawns a new instance of Cheddar listening on some port.
// This is potentially race-y, because it relies on binding, then unbinding and spawning Cheddar.
// But... it should be good enough.
func Spawn(ctx context.Context, cpath string) (*Cheddar, error) {
l, err := net.Listen("tcp", "[::1]:0")
if err != nil {
return nil, fmt.Errorf("finding a port for cheddar: %w", err)
}
addr := l.Addr().(*net.TCPAddr)
port := addr.Port
if err := l.Close(); err != nil {
return nil, fmt.Errorf("closing port-sentinel listener: %w", err)
}
ctx, cancel := context.WithCancel(context.Background())
cmd := exec.CommandContext(ctx, cpath, "--sourcegraph-server", "--listen", fmt.Sprintf("[::1]:%d", port))
if err := cmd.Start(); err != nil {
return nil, fmt.Errorf("launching cheddar: %w", err)
}
c := &Cheddar{
remote: fmt.Sprintf("http://[::1]:%d", port),
stop: cancel,
}
startupCtx, startupCancel := context.WithTimeout(ctx, startupMax)
defer startupCancel()
// Give cheddar a bit to start up before we start healthchecking it.
time.Sleep(1 * time.Millisecond)
for {
if err := c.healthCheck(startupCtx); errors.Is(err, context.DeadlineExceeded) {
cancel() // Kill the subprocess.
return nil, err
} else if err == nil {
break
}
time.Sleep(10 * time.Millisecond)
}
return c, nil
}