506 lines
12 KiB
Go
506 lines
12 KiB
Go
package main
|
|
|
|
import (
|
|
"bytes"
|
|
"encoding/json"
|
|
"errors"
|
|
"fmt"
|
|
"html/template"
|
|
"io"
|
|
"io/ioutil"
|
|
"local/gziphttp"
|
|
"local/router"
|
|
"local/simpleserve/simpleserve"
|
|
"log"
|
|
"net/http"
|
|
"os"
|
|
"path"
|
|
"regexp"
|
|
"strings"
|
|
|
|
"github.com/google/uuid"
|
|
)
|
|
|
|
type Server struct {
|
|
router *router.Router
|
|
root string
|
|
}
|
|
|
|
func NewServer(root string) *Server {
|
|
return &Server{
|
|
router: router.New(),
|
|
root: root,
|
|
}
|
|
}
|
|
|
|
func (server *Server) Routes() error {
|
|
wildcard := func(s string) string {
|
|
return strings.TrimSuffix(s, "/") + "/" + router.Wildcard
|
|
}
|
|
wildcards := func(s string) string {
|
|
return wildcard(s) + router.Wildcard
|
|
}
|
|
_ = wildcards
|
|
for path, handler := range map[string]func(http.ResponseWriter, *http.Request) error{
|
|
"/": server.rootHandler,
|
|
"/api/v0/tree": server.apiV0TreeHandler,
|
|
"/api/v0/media": server.apiV0MediaHandler,
|
|
wildcard("/api/v0/media"): server.apiV0MediaIDHandler,
|
|
wildcards("/api/v0/files"): server.apiV0FilesHandler,
|
|
"/api/v0/search": server.apiV0SearchHandler,
|
|
"/ui": server.rootHandler,
|
|
"/ui/search": server.uiSearchHandler,
|
|
wildcards("/ui/files"): server.uiFilesHandler,
|
|
} {
|
|
log.Printf("listening for %s", path)
|
|
if err := server.router.Add(path, server.tryCatchHttpHandler(handler)); err != nil {
|
|
return err
|
|
}
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (server *Server) ServeHTTP(w http.ResponseWriter, r *http.Request) {
|
|
server.router.ServeHTTP(w, r)
|
|
}
|
|
|
|
func (server *Server) tryCatchHttpHandler(handler func(http.ResponseWriter, *http.Request) error) http.HandlerFunc {
|
|
return func(w http.ResponseWriter, r *http.Request) {
|
|
if gziphttp.Can(r) {
|
|
w2 := gziphttp.New(w)
|
|
defer w2.Close()
|
|
w = w2
|
|
}
|
|
if err := handler(w, r); err != nil {
|
|
http.Error(w, err.Error(), http.StatusInternalServerError)
|
|
log.Printf("failed handling %s: %v", r.URL.String(), err)
|
|
}
|
|
}
|
|
}
|
|
|
|
func (server *Server) apiV0TreeHandler(w http.ResponseWriter, r *http.Request) error {
|
|
tree := server.tree()
|
|
branches, err := tree.GetRootMeta()
|
|
if err != nil {
|
|
return err
|
|
}
|
|
return json.NewEncoder(w).Encode(branches)
|
|
}
|
|
|
|
func ensureAndWrite(p string, b []byte) error {
|
|
if err := os.MkdirAll(path.Dir(p), os.ModePerm); err != nil {
|
|
return err
|
|
}
|
|
return ioutil.WriteFile(p, b, os.ModePerm)
|
|
}
|
|
|
|
func (server *Server) apiV0MediaHandler(w http.ResponseWriter, r *http.Request) error {
|
|
id := uuid.New().String()
|
|
filePath, err := server.postContentHandler(server.diskMediaPath(id), w, r)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
return json.NewEncoder(w).Encode(map[string]map[string]string{
|
|
"data": map[string]string{
|
|
"filePath": path.Join("/api/v0/media", path.Base(filePath)),
|
|
},
|
|
})
|
|
}
|
|
|
|
func (server *Server) apiV0MediaIDHandler(w http.ResponseWriter, r *http.Request) error {
|
|
switch r.Method {
|
|
case http.MethodGet:
|
|
return server.apiV0MediaIDGetHandler(w, r)
|
|
case http.MethodPut:
|
|
return server.apiV0MediaIDPutHandler(w, r)
|
|
case http.MethodDelete:
|
|
return server.apiV0MediaIDDelHandler(w, r)
|
|
}
|
|
http.NotFound(w, r)
|
|
return nil
|
|
}
|
|
|
|
func (server *Server) apiV0MediaIDPutHandler(w http.ResponseWriter, r *http.Request) error {
|
|
panic("not impl")
|
|
}
|
|
|
|
func (server *Server) apiV0MediaIDDelHandler(w http.ResponseWriter, r *http.Request) error {
|
|
id := path.Base(r.URL.Path)
|
|
os.Remove(server.diskMediaPath(id))
|
|
return nil
|
|
}
|
|
|
|
func (server *Server) apiV0MediaIDGetHandler(w http.ResponseWriter, r *http.Request) error {
|
|
id := path.Base(r.URL.Path)
|
|
return server.getContentHandler(server.diskMediaPath(id), w, r)
|
|
}
|
|
|
|
func (server *Server) getContentHandler(filePath string, w http.ResponseWriter, r *http.Request) error {
|
|
if r.Method != http.MethodGet {
|
|
return errors.New("not found")
|
|
}
|
|
f, err := os.Open(filePath)
|
|
if os.IsNotExist(err) {
|
|
http.NotFound(w, r)
|
|
return nil
|
|
}
|
|
if err != nil {
|
|
return err
|
|
}
|
|
defer f.Close()
|
|
simpleserve.SetContentTypeIfMedia(w, r)
|
|
io.Copy(w, f)
|
|
return nil
|
|
}
|
|
|
|
func (server *Server) postContentHandler(filePath string, w http.ResponseWriter, r *http.Request) (string, error) {
|
|
if r.Method != http.MethodPost {
|
|
return "", errors.New("not found")
|
|
}
|
|
if strings.HasPrefix(r.Header.Get("Content-Type"), "multipart/form-data") {
|
|
kb := int64(1 << 10)
|
|
mb := kb << 10
|
|
if err := r.ParseMultipartForm(10 * mb); err != nil {
|
|
return "", err
|
|
}
|
|
if len(r.MultipartForm.File) != 1 {
|
|
return "", errors.New("not exactly 1 file found in request")
|
|
}
|
|
for _, infos := range r.MultipartForm.File {
|
|
if len(infos) != 1 {
|
|
return "", errors.New("not exactly 1 file info found in request")
|
|
}
|
|
ext := path.Ext(infos[0].Filename)
|
|
if h, ok := infos[0].Header["Content-Type"]; ok {
|
|
ext = path.Base(h[0])
|
|
}
|
|
filePath += "." + ext
|
|
f, err := infos[0].Open()
|
|
if err != nil {
|
|
return "", err
|
|
}
|
|
defer f.Close()
|
|
r.Body = f
|
|
}
|
|
} else if strings.HasPrefix(r.Header.Get("Content-Type"), "application/x-www-form-urlencoded") {
|
|
if err := r.ParseForm(); err != nil {
|
|
return "", err
|
|
}
|
|
return "", fmt.Errorf("parse form: %+v", r.PostForm)
|
|
}
|
|
return filePath, server.putContentHandler(filePath, w, r)
|
|
}
|
|
|
|
func (server *Server) putContentHandler(filePath string, w http.ResponseWriter, r *http.Request) error {
|
|
defer r.Body.Close()
|
|
b, err := ioutil.ReadAll(r.Body)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
return ensureAndWrite(filePath, b)
|
|
}
|
|
|
|
func (server *Server) uiSearchHandler(w http.ResponseWriter, r *http.Request) error {
|
|
t, err := server.uiSubTemplates()
|
|
if err != nil {
|
|
return err
|
|
}
|
|
t, err = t.ParseFiles(path.Join(server.root, "ui", "search.ctmpl"))
|
|
if err != nil {
|
|
return err
|
|
}
|
|
idsTitles, err := server._apiV0SearchHandler(r.URL.Query().Get("q"))
|
|
if err != nil {
|
|
return err
|
|
}
|
|
data := make([]struct {
|
|
Title string
|
|
ID ID
|
|
}, len(idsTitles))
|
|
for i := range idsTitles {
|
|
data[i].ID = NewID(idsTitles[i][0])
|
|
data[i].Title = idsTitles[i][1]
|
|
}
|
|
tree := server.tree()
|
|
branches, err := tree.GetRootMeta()
|
|
if err != nil {
|
|
return err
|
|
}
|
|
branchesJSON, err := json.Marshal(branches)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
return t.Lookup("search").Execute(w, map[string]interface{}{
|
|
"Results": data,
|
|
"Tree": string(branchesJSON),
|
|
})
|
|
}
|
|
|
|
func (server *Server) uiFilesHandler(w http.ResponseWriter, r *http.Request) error {
|
|
id := NewID(strings.TrimPrefix(r.URL.Path, "/ui/files"))
|
|
if id == "" {
|
|
return server.rootHandler(w, r)
|
|
}
|
|
t, err := server.uiSubTemplates()
|
|
if err != nil {
|
|
return err
|
|
}
|
|
t, err = t.ParseFiles(path.Join(server.root, "ui", "files.ctmpl"))
|
|
if err != nil {
|
|
return err
|
|
}
|
|
tree := server.tree()
|
|
branches, err := tree.GetRootMeta()
|
|
if err != nil {
|
|
return err
|
|
}
|
|
branchesJSON, err := json.Marshal(branches)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
var parent Leaf
|
|
if id.Pop() != "" {
|
|
parent, err = tree.Get(id.Pop())
|
|
if err != nil {
|
|
return fmt.Errorf("failed to get pid %q: %v", id.Pop(), err)
|
|
}
|
|
}
|
|
leaf, err := tree.Get(id)
|
|
if err != nil {
|
|
leaf.Meta.Title = "My New File"
|
|
}
|
|
data := map[string]interface{}{
|
|
"This": map[string]interface{}{
|
|
"Title": leaf.Meta.Title,
|
|
"ReadOnly": leaf.Meta.ReadOnly,
|
|
"Content": leaf.Content,
|
|
"ID": id.String(),
|
|
"PID": id.Pop().String(),
|
|
"PTitle": parent.Meta.Title,
|
|
},
|
|
"Tree": string(branchesJSON),
|
|
}
|
|
return t.Lookup("files").Execute(w, data)
|
|
}
|
|
|
|
func (server *Server) uiSubTemplates() (*template.Template, error) {
|
|
templateFiles := []string{}
|
|
var loadTemplateFilesFromDir func(string) error
|
|
loadTemplateFilesFromDir = func(root string) error {
|
|
entries, err := os.ReadDir(root)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
for _, entry := range entries {
|
|
entryPath := path.Join(root, entry.Name())
|
|
if entry.IsDir() {
|
|
if err := loadTemplateFilesFromDir(entryPath); err != nil {
|
|
return err
|
|
}
|
|
} else if !strings.HasPrefix(path.Base(entryPath), "_") {
|
|
} else if strings.HasSuffix(entryPath, ".ctmpl") {
|
|
templateFiles = append(templateFiles, entryPath)
|
|
}
|
|
}
|
|
return nil
|
|
}
|
|
if err := loadTemplateFilesFromDir(path.Join(server.root, "ui")); err != nil {
|
|
return nil, err
|
|
}
|
|
return template.ParseFiles(templateFiles...)
|
|
}
|
|
|
|
func (server *Server) rootHandler(w http.ResponseWriter, r *http.Request) error {
|
|
http.Redirect(w, r, "/ui/files/"+uuid.New().String()[:5], 302)
|
|
return nil
|
|
}
|
|
|
|
func (server *Server) tree() Tree {
|
|
return NewTree(path.Join(server.root, "files"))
|
|
}
|
|
|
|
func (server *Server) diskMediaPath(id string) string {
|
|
return path.Join(server.root, "media", id)
|
|
}
|
|
|
|
func (server *Server) apiV0FilesHandler(w http.ResponseWriter, r *http.Request) error {
|
|
switch r.Method {
|
|
case http.MethodPost:
|
|
return server.apiV0FilesPostHandler(w, r)
|
|
case http.MethodGet:
|
|
return server.apiV0FilesIDGetHandler(w, r)
|
|
case http.MethodPut:
|
|
return server.apiV0FilesIDPutHandler(w, r)
|
|
case http.MethodDelete:
|
|
return server.apiV0FilesIDDelHandler(w, r)
|
|
}
|
|
http.NotFound(w, r)
|
|
return nil
|
|
}
|
|
|
|
func (server *Server) apiV0FilesPostHandler(w http.ResponseWriter, r *http.Request) error {
|
|
f, err := ioutil.TempFile(os.TempDir(), "filesPost*")
|
|
if err != nil {
|
|
return err
|
|
}
|
|
f.Close()
|
|
defer os.Remove(f.Name())
|
|
|
|
filePath, err := server.postContentHandler(f.Name(), w, r)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
defer os.Remove(filePath)
|
|
|
|
b, err := ioutil.ReadFile(filePath)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
r.Body = io.NopCloser(bytes.NewReader(b))
|
|
|
|
pid := server.fileId(r)
|
|
id := NewID(pid).Push(strings.Split(uuid.New().String(), "-")[0])
|
|
leaf, err := NewHTTPRequestLeaf(r)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
if err := server.tree().Put(id, leaf); err != nil {
|
|
return err
|
|
}
|
|
return json.NewEncoder(w).Encode(map[string]map[string]string{
|
|
"data": map[string]string{
|
|
"filePath": path.Join("/api/v0/files/", id.URLSafeString()),
|
|
},
|
|
})
|
|
}
|
|
|
|
func (server *Server) apiV0FilesIDGetHandler(w http.ResponseWriter, r *http.Request) error {
|
|
id := NewID(server.fileId(r))
|
|
if id.String() == "" {
|
|
return fmt.Errorf("no id found: %+v", id)
|
|
}
|
|
|
|
leaf, err := server.tree().Get(id)
|
|
if os.IsNotExist(err) {
|
|
http.NotFound(w, r)
|
|
return nil
|
|
} else if err != nil {
|
|
return err
|
|
}
|
|
|
|
return leaf.WriteHTTP(w)
|
|
}
|
|
|
|
func (server *Server) apiV0FilesIDDelHandler(w http.ResponseWriter, r *http.Request) error {
|
|
id := NewID(server.fileId(r))
|
|
if id.String() == "" {
|
|
return fmt.Errorf("no id found: %+v", id)
|
|
}
|
|
|
|
leaf, err := server.tree().Get(id)
|
|
if os.IsNotExist(err) {
|
|
return nil
|
|
} else if err != nil {
|
|
return err
|
|
}
|
|
leaf.Meta.Deleted = true
|
|
|
|
return server.tree().Put(id, leaf)
|
|
}
|
|
|
|
func (server *Server) fileId(r *http.Request) string {
|
|
return strings.Trim(
|
|
strings.TrimPrefix(
|
|
strings.Trim(r.URL.Path, "/"),
|
|
"api/v0/files",
|
|
),
|
|
"/",
|
|
)
|
|
}
|
|
|
|
func (server *Server) apiV0FilesIDPutHandler(w http.ResponseWriter, r *http.Request) error {
|
|
id := NewID(server.fileId(r))
|
|
if id.String() == "" {
|
|
return fmt.Errorf("no id found: %+v", id)
|
|
}
|
|
|
|
leaf, err := server.tree().Get(id)
|
|
if os.IsNotExist(err) {
|
|
} else if err != nil {
|
|
return err
|
|
}
|
|
|
|
updatedLeaf, err := NewHTTPRequestLeaf(r)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
leaf = leaf.Merge(updatedLeaf)
|
|
|
|
if err := server.tree().Put(id, leaf); err != nil {
|
|
return err
|
|
}
|
|
return json.NewEncoder(w).Encode(map[string]map[string]string{
|
|
"data": map[string]string{
|
|
"filePath": path.Join("/api/v0/files/", id.URLSafeString()),
|
|
},
|
|
})
|
|
}
|
|
|
|
func (server *Server) apiV0SearchHandler(w http.ResponseWriter, r *http.Request) error {
|
|
query := r.URL.Query().Get("q")
|
|
idsTitles, err := server._apiV0SearchHandler(query)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
result := make([]string, len(idsTitles))
|
|
for i := range idsTitles {
|
|
result[i] = idsTitles[i][0]
|
|
}
|
|
return json.NewEncoder(w).Encode(result)
|
|
}
|
|
|
|
func (server *Server) _apiV0SearchHandler(query string) ([][2]string, error) {
|
|
queries := strings.Split(query, " ")
|
|
if len(queries) == 0 {
|
|
return [][2]string{}, nil
|
|
}
|
|
patterns := []*regexp.Regexp{}
|
|
unsafepattern := regexp.MustCompile(`[^a-zA-Z0-9]`)
|
|
for _, query := range queries {
|
|
if len(query) > 0 {
|
|
query = unsafepattern.ReplaceAllString(query, ".")
|
|
patterns = append(patterns, regexp.MustCompile("(?i)"+query))
|
|
}
|
|
}
|
|
if len(patterns) == 0 {
|
|
return [][2]string{}, nil
|
|
}
|
|
tree, err := server.tree().GetRoot()
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
result := [][2]string{}
|
|
if err := tree.ForEach(func(id ID, leaf Leaf) error {
|
|
for _, pattern := range patterns {
|
|
if !pattern.MatchString(leaf.Content) && !pattern.MatchString(leaf.Meta.Title) {
|
|
return nil
|
|
}
|
|
}
|
|
title := leaf.Meta.Title
|
|
pid := id.Pop()
|
|
for pid != "" {
|
|
parent, err := server.tree().Get(pid)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
title = path.Join(parent.Meta.Title, title)
|
|
pid = pid.Pop()
|
|
}
|
|
result = append(result, [2]string{id.URLSafeString(), title})
|
|
return nil
|
|
}); err != nil {
|
|
return nil, fmt.Errorf("failed for each: %v", err)
|
|
}
|
|
return result, nil
|
|
}
|