filebrowser/setup.go

242 lines
5.4 KiB
Go

package hugo
import (
"errors"
"fmt"
"io/ioutil"
"log"
"net/http"
"os"
"os/exec"
"path/filepath"
"reflect"
"strings"
"github.com/hacdias/caddy-filemanager"
"github.com/hacdias/caddy-filemanager/config"
"github.com/hacdias/caddy-filemanager/frontmatter"
"github.com/hacdias/caddy-hugo/utils/commands"
"github.com/mholt/caddy"
"github.com/mholt/caddy/caddyhttp/httpserver"
)
// AssetsURL is the base url for the assets
const (
AssetsURL = "/_hugointernal"
HugoNotFound = "It seems that you don't have 'hugo' on your PATH."
)
func init() {
caddy.RegisterPlugin("hugo", caddy.Plugin{
ServerType: "http",
Action: setup,
})
}
// Setup is the init function of Caddy plugins and it configures the whole
// middleware thing.
func setup(c *caddy.Controller) error {
cnf := httpserver.GetConfig(c)
conf, fm, err := parse(c, cnf.Root)
if err != nil {
return err
}
// Generates the Hugo website for the first time the plugin is activated.
go RunHugo(conf, true)
mid := func(next httpserver.Handler) httpserver.Handler {
fm.Next = next
return &Hugo{
Next: next,
Config: conf,
FileManager: fm,
}
}
cnf.AddMiddleware(mid)
return nil
}
// Config is a configuration for managing a particular hugo website.
type Config struct {
Public string // Public content path
Root string // Hugo files path
Hugo string // Hugo executable location
Styles string // Admin styles path
Args []string // Hugo arguments
BaseURL string // BaseURL of admin interface
WebDavURL string
BeforePublish config.CommandFunc
AfterPublish config.CommandFunc
}
// Parse parses the configuration set by the user so it can be
// used by the middleware
func parse(c *caddy.Controller, root string) (*Config, *filemanager.FileManager, error) {
var (
cfg *Config
fm *filemanager.FileManager
err error
tokens string
)
cfg = new(Config)
if cfg.Hugo, err = exec.LookPath("hugo"); err != nil {
fmt.Println(HugoNotFound)
return cfg, fm, errors.New(HugoNotFound)
}
for c.Next() {
cfg.Public = strings.Replace(root, "./", "", -1)
cfg.BaseURL = "/admin"
cfg.Root = "./"
cfg.BeforePublish = func(r *http.Request, c *config.Config, u *config.User) error { return nil }
cfg.AfterPublish = func(r *http.Request, c *config.Config, u *config.User) error { return nil }
args := c.RemainingArgs()
if len(args) >= 1 {
cfg.Root = args[0]
cfg.Root = strings.TrimSuffix(cfg.Root, "/")
cfg.Root += "/"
}
if len(args) >= 2 {
cfg.BaseURL = args[1]
cfg.BaseURL = strings.TrimPrefix(cfg.BaseURL, "/")
cfg.BaseURL = "/" + cfg.BaseURL
}
for c.NextBlock() {
switch c.Val() {
case "flag":
if !c.NextArg() {
return cfg, &filemanager.FileManager{}, c.ArgErr()
}
values := strings.Split(c.Val(), " ")
if len(values) == 0 {
return cfg, fm, errors.New("Not enough arguments for 'flag' option.")
}
value := "true"
if len(values) > 1 {
value = values[1]
}
cfg.Args = append(cfg.Args, "--"+values[0]+"="+value)
case "before_publish":
if cfg.BeforePublish, err = config.CommandRunner(c); err != nil {
return cfg, &filemanager.FileManager{}, err
}
case "after_publish":
if cfg.AfterPublish, err = config.CommandRunner(c); err != nil {
return cfg, &filemanager.FileManager{}, err
}
default:
line := "\n\t" + c.Val()
if c.NextArg() {
line += " " + c.Val()
}
tokens += line
}
}
}
tokens = "filemanager " + cfg.BaseURL + " {\n\tshow " + cfg.Root + tokens
tokens += "\n}"
fmConfig, err := config.Parse(caddy.NewTestController("http", tokens))
if err != nil {
return cfg, fm, err
}
fm = &filemanager.FileManager{Configs: fmConfig}
fm.Configs[0].HugoEnabled = true
format := getFrontMatter(cfg)
cfg.WebDavURL = fm.Configs[0].WebDavURL
for _, user := range fm.Configs[0].Users {
user.FrontMatter = format
}
if err != nil {
return cfg, fm, err
}
return cfg, fm, nil
}
func getFrontMatter(conf *Config) string {
format := "toml"
// Checks if there is an Hugo website in the path that is provided.
// If not, a new website will be created.
create := true
if _, err := os.Stat(conf.Root + "config.yaml"); err == nil {
format = "yaml"
create = false
}
if _, err := os.Stat(conf.Root + "config.json"); err == nil {
format = "json"
create = false
}
if _, err := os.Stat(conf.Root + "config.toml"); err == nil {
format = "toml"
create = false
}
if create {
err := commands.Run(conf.Hugo, []string{"new", "site", conf.Root, "--force"}, ".")
if err != nil {
log.Fatal(err)
}
}
// Get Default FrontMatter
bytes, err := ioutil.ReadFile(filepath.Clean(conf.Root + "/config." + format))
if err != nil {
log.Println(err)
fmt.Printf("Can't get the default frontmatter from the configuration. %s will be used.\n", format)
} else {
bytes = frontmatter.AppendRune(bytes, format)
f, err := frontmatter.Unmarshal(bytes)
if err != nil {
log.Println(err)
fmt.Printf("Can't get the default frontmatter from the configuration. %s will be used.\n", format)
} else {
kind := reflect.TypeOf(f)
if kind == reflect.TypeOf(map[interface{}]interface{}{}) {
if val, ok := f.(map[interface{}]interface{})["metaDataFormat"]; ok {
format = val.(string)
}
} else {
if val, ok := f.(map[string]interface{})["metaDataFormat"]; ok {
format = val.(string)
}
}
}
}
return format
}