gitdeploy/main.go

132 lines
2.6 KiB
Go
Raw Normal View History

package main
import (
"compress/flate"
"flag"
"fmt"
"net/http"
"os"
"git.ryanburnette.com/ryanburnette/git-deploy/assets"
"github.com/go-chi/chi"
"github.com/go-chi/chi/middleware"
)
var (
name = "gitdeploy"
version = "0.0.0"
date = "0001-01-01T00:00:00Z"
commit = "0000000"
)
func usage() {
ver()
fmt.Println("")
fmt.Println("Use 'help <command>'")
fmt.Println(" help")
fmt.Println(" init")
fmt.Println(" run")
}
func ver() {
fmt.Printf("%s v%s %s (%s)\n", name, version, commit[:7], date)
}
type runOptions struct {
listen string
trustProxy bool
compress bool
static string
}
var runFlags *flag.FlagSet
var runOpts runOptions
var initFlags *flag.FlagSet
func init() {
runOpts = runOptions{}
runFlags = flag.NewFlagSet("run", flag.ExitOnError)
runFlags.StringVar(&runOpts.listen, "listen", ":3000", "the address and port on which to listen")
runFlags.BoolVar(&runOpts.trustProxy, "trust-proxy", false, "trust X-Forwarded-For header")
runFlags.BoolVar(&runOpts.compress, "compress", true, "enable compression for text,html,js,css,etc")
runFlags.StringVar(&runOpts.static, "serve-path", "", "path to serve, falls back to built-in web app")
}
func main() {
args := os.Args[:]
if 1 == len(args) {
// "run" should be the default
args = append(args, "run")
}
if "help" == args[1] {
// top-level help
if 2 == len(args) {
usage()
os.Exit(0)
return
}
// move help to subcommand argument
self := args[0]
args = append([]string{self}, args[2:]...)
args = append(args, "--help")
}
switch args[1] {
case "version":
ver()
os.Exit(0)
return
case "init":
initFlags.Parse(args[2:])
case "run":
runFlags.Parse(args[2:])
serve()
default:
usage()
os.Exit(1)
return
}
}
func serve() {
r := chi.NewRouter()
// A good base middleware stack
if runOpts.trustProxy {
r.Use(middleware.RealIP)
}
if runOpts.compress {
r.Use(middleware.Compress(flate.DefaultCompression))
}
r.Use(middleware.Logger)
r.Use(middleware.Recoverer)
pub := http.FileServer(assets.Assets)
var dev http.Handler
var devFS http.FileSystem
if len(runOpts.static) > 0 {
devFS = http.Dir(runOpts.static)
dev = http.FileServer(devFS)
r.Get("/*", func(w http.ResponseWriter, r *http.Request) {
if _, err := devFS.Open(r.URL.Path); nil != err {
pub.ServeHTTP(w, r)
return
}
dev.ServeHTTP(w, r)
})
} else {
r.Get("/*", func(w http.ResponseWriter, r *http.Request) {
pub.ServeHTTP(w, r)
})
}
fmt.Println("Listening for http on", runOpts.listen)
if err := http.ListenAndServe(runOpts.listen, r); nil != err {
fmt.Fprintf(os.Stderr, "%s", err)
os.Exit(1)
return
}
}