gowiki/pkg/cmd/cmd.go

// Copyright (C) 2018 Marius Schellenberger

package cmd

import (
	"encoding/json"
	"git.giftfish.de/ston1th/godrop/v2"
	"git.giftfish.de/ston1th/gowiki/pkg/core"
	"git.giftfish.de/ston1th/gowiki/pkg/db"
	"git.giftfish.de/ston1th/gowiki/pkg/log"
	"git.giftfish.de/ston1th/gowiki/pkg/server"
	"github.com/urfave/cli"
	stdlog "log"
	"net"
	"os"
	"os/signal"
	"syscall"
	"time"
)

const (
	defDataDir = "/var/lib/gowiki"
	defListen  = "127.0.0.1:8080"
	defLogFile = "gowiki.log"

	defRunUser  = "wiki"
	defRunGroup = "wiki"
)

var (
	conf     core.Config
	dumpFile string
	config   string
)

func initServer(conf core.Config) (err error) {
	if err = godrop.PledgePromises("stdio rpath wpath cpath inet fattr flock proc exec id unveil"); err != nil {
		return
	}
	dropCfg := godrop.Config{
		User:       conf.User,
		Group:      conf.Group,
		Foreground: conf.Foreground,
	}
	err = godrop.Drop(dropCfg, func() (net.Listener, error) {
		return net.Listen("tcp", conf.ListenAddr)
	})
	if err != nil {
		return
	}
	if err = os.Chdir(conf.DataDir); err != nil {
		return
	}

	if err = godrop.PledgePromises("stdio rpath wpath cpath inet fattr flock unveil"); err != nil {
		return
	}

	l, err := godrop.GetListener()
	if err != nil {
		return
	}

	log.InitLogger(conf.DataDir, conf.LogFile, conf.Debug)

	srv := server.NewHTTPServer(l, conf)
	err = srv.Start()
	if err != nil {
		return
	}
	log.Println("gowiki started")
	sigs := make(chan os.Signal)
	signal.Notify(sigs, syscall.SIGINT, syscall.SIGTERM)
	sig := <-sigs
	log.Println("signal: " + sig.String())
	go func() {
		time.Sleep(time.Second * 20)
		log.Fatal("stop timed out: killing")
	}()
	err = srv.Stop()
	if err != nil {
		log.Println(err)
	}
	log.Println("gowiki stopped")
	return
}

func loadConfig() error {
	if config == "" {
		return nil
	}
	file, err := os.Open(config)
	if err != nil {
		return err
	}
	err = json.NewDecoder(file).Decode(&conf)
	if err != nil {
		return err
	}
	return file.Close()
}

func Run(version string) {
	app := cli.NewApp()
	app.Name = "gowiki"
	app.Usage = "a simple wiki engine"
	app.Version = version
	app.Commands = []cli.Command{
		{
			Name:  "server",
			Usage: "start gowiki server",
			Flags: defaultFlags(serverFlags()),
			Action: func(c *cli.Context) error {
				if err := loadConfig(); err != nil {
					stdlog.Fatal("server: ", err)
				}
				conf.Version = app.Version
				if err := initServer(conf); err != nil {
					stdlog.Fatal("server: ", err)
				}
				return nil
			},
		},
		{
			Name:  "dump",
			Usage: "create a json dump of all articles in the data directory (gowiki needs to be stopped)",
			Flags: defaultFlags(dumpRestoreFlags()),
			Action: func(c *cli.Context) error {
				var (
					file = os.Stdout
					err  error
				)
				if err = loadConfig(); err != nil {
					stdlog.Fatal("dump: ", err)
				}
				if dumpFile != "-" {
					file, err = os.OpenFile(dumpFile, os.O_WRONLY|os.O_CREATE|os.O_TRUNC, 0640)
					if err != nil {
						stdlog.Fatal("dump: ", err)
					}
				}
				DB, err := db.New(conf.DataDir)
				if err != nil {
					stdlog.Fatal("dump: ", err)
				}
				if err = DB.Dump(file); err != nil {
					stdlog.Fatal("dump: ", err)
				}
				file.Close()
				err = DB.Close()
				if err != nil {
					stdlog.Fatal("dump: ", err)
				}
				return nil
			},
		},
		{
			Name:  "restore",
			Usage: "restore a json dump to the data directory (gowiki needs to be stopped)",
			Flags: defaultFlags(dumpRestoreFlags()),
			Action: func(c *cli.Context) error {
				var (
					file = os.Stdin
					err  error
				)
				if err = loadConfig(); err != nil {
					stdlog.Fatal("restore: ", err)
				}
				if dumpFile != "-" {
					file, err = os.Open(dumpFile)
					if err != nil {
						stdlog.Fatal("restore: ", err)
					}
				}
				DB, err := db.New(conf.DataDir)
				if err != nil {
					stdlog.Fatal("restore: ", err)
				}
				if err = DB.Restore(file); err != nil {
					stdlog.Fatal("restore: ", err)
				}
				file.Close()
				err = DB.Close()
				if err != nil {
					stdlog.Fatal("restore: ", err)
				}
				return nil
			},
		},
	}
	app.Run(os.Args)
}

func serverFlags() []cli.Flag {
	return []cli.Flag{
		cli.StringFlag{
			Name:        "user, u",
			Value:       defRunUser,
			Usage:       "drop privileges to user",
			Destination: &conf.User,
		},
		cli.StringFlag{
			Name:        "group, g",
			Value:       defRunGroup,
			Usage:       "drop privileges to group",
			Destination: &conf.Group,
		},
		cli.StringFlag{
			Name:        "listen, l",
			Value:       defListen,
			Usage:       "listening <address>:<port>",
			Destination: &conf.ListenAddr,
		},
		cli.StringFlag{
			Name:        "log",
			Value:       defLogFile,
			Usage:       "log file (use - for stdout, this only works in combination with -f)",
			Destination: &conf.LogFile,
		},
		cli.StringFlag{
			Name:        "secret",
			Usage:       "static hmac secret (at least 64 chars, used for JWT signing)",
			Destination: &conf.Secret,
		},
		cli.BoolFlag{
			Name:        "foreground, f",
			Usage:       "do not fork into the background",
			Destination: &conf.Foreground,
		},
		cli.BoolFlag{
			Name:        "secure, s",
			Usage:       "enable secure cookie",
			Destination: &conf.SecureCookie,
		},
		cli.BoolFlag{
			Name:        "debug",
			Usage:       "enable debugging",
			Destination: &conf.Debug,
		},
	}
}

func dumpRestoreFlags() []cli.Flag {
	return []cli.Flag{
		cli.StringFlag{
			Name:        "file, f",
			Value:       "-",
			Usage:       "file to read/write dump (default stdin/stdout)",
			Destination: &dumpFile,
		},
	}
}

func defaultFlags(f []cli.Flag) []cli.Flag {
	return append([]cli.Flag{
		cli.StringFlag{
			Name:        "config, c",
			Usage:       "config file",
			Destination: &config,
		},
		cli.StringFlag{
			Name:        "data, d",
			Value:       defDataDir,
			Usage:       "data directory",
			Destination: &conf.DataDir,
		},
	}, f...)
}