132 lines
2.6 KiB
Go
132 lines
2.6 KiB
Go
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
|
|
}
|
|
}
|