// Serve starts the devd server. The callback is called with the serving URL // just before service starts. func (dd *Devd) Serve(address string, port int, certFile string, logger termlog.TermLog, callback func(string)) error { templates, err := ricetemp.MakeTemplates(rice.MustFindBox("templates")) if err != nil { return fmt.Errorf("Error loading templates: %s", err) } mux, err := dd.Router(logger, templates) if err != nil { return err } var tlsConfig *tls.Config var tlsEnabled bool if certFile != "" { tlsConfig, err = getTLSConfig(certFile) if err != nil { return fmt.Errorf("Could not load certs: %s", err) } tlsEnabled = true } var hl net.Listener if port > 0 { hl, err = net.Listen("tcp", fmt.Sprintf("%v:%d", address, port)) } else { hl, err = pickPort(address, portLow, portHigh, tlsEnabled) } if err != nil { return err } if tlsConfig != nil { hl = tls.NewListener(hl, tlsConfig) } hl = slowdown.NewSlowListener(hl, dd.UpKbps*1024, dd.DownKbps*1024) url := formatURL(tlsEnabled, address, hl.Addr().(*net.TCPAddr).Port) logger.Say("Listening on %s (%s)", url, hl.Addr().String()) server := &http.Server{Addr: hl.Addr().String(), Handler: mux} callback(url) if dd.HasLivereload() { c := make(chan os.Signal, 1) signal.Notify(c, syscall.SIGHUP) go func() { for { <-c logger.Say("Received signal - reloading") dd.lrserver.Reload([]string{"*"}) } }() } err = server.Serve(hl) logger.Shout("Server stopped: %v", err) return nil }
func main() { httpIP := kingpin.Flag("address", "Address to listen on"). Short('A'). Default("127.0.0.1"). String() allInterfaces := kingpin.Flag("a", "Listen on all addresses"). Short('a'). Bool() certFile := kingpin.Flag("cert", "Certificate bundle file - enables TLS"). Short('c'). PlaceHolder("PATH"). Default(""). ExistingFile() throttleDownKbps := kingpin.Flag( "down", "Throttle downstream from the client to N kilobytes per second", ). PlaceHolder("N"). Short('d'). Default("0"). Int() logHeaders := kingpin.Flag("logheaders", "Log headers"). Short('H'). Default("false"). Bool() ignoreHeaders := kingpin.Flag( "ignore", "Disable logging matching requests. Regexes are matched over 'host/path'", ). Short('I'). PlaceHolder("REGEX"). Strings() livereloadRoutes := kingpin.Flag("livereload", "Enable livereload for static files"). Short('l'). Default("false"). Bool() latency := kingpin.Flag("latency", "Add N milliseconds of round-trip latency"). PlaceHolder("N"). Short('n'). Default("0"). Int() openBrowser := kingpin.Flag("open", "Open browser window on startup"). Short('o'). Default("false"). Bool() httpPort := kingpin.Flag( "port", "Port to listen on - if not specified, devd will auto-pick a sensible port", ). Short('p'). Int() enableTimer := kingpin.Flag("logtime", "Log timing"). Short('T'). Default("false"). Bool() throttleUpKbps := kingpin.Flag( "up", "Throttle upstream from the client to N kilobytes per second", ). PlaceHolder("N"). Short('u'). Default("0"). Int() watch := kingpin.Flag("watch", "Watch path to trigger livereload"). PlaceHolder("PATH"). Short('w'). Strings() debug := kingpin.Flag("debug", "Debugging for devd development"). Default("false"). Bool() excludes := kingpin.Flag("exclude", "Glob pattern for files to exclude from livereload."). PlaceHolder("PATTERN"). Short('x'). Strings() routes := kingpin.Arg( "route", `Routes have the following forms: [SUBDOMAIN]/<PATH>=<DIR> [SUBDOMAIN]/<PATH>=<URL> <DIR> <URL> `, ).Required().Strings() kingpin.Version(version) kingpin.Parse() logger := termlog.NewLog() if *debug { logger.Enable("debug") } if *enableTimer { logger.Enable("timer") } if *throttleDownKbps == 0 { *throttleDownKbps = slowdown.MaxRate } if *throttleUpKbps == 0 { *throttleUpKbps = slowdown.MaxRate } if *allInterfaces { *httpIP = "0.0.0.0" } tlsEnabled := false if *certFile != "" { tlsEnabled = true } var hl net.Listener var err error if *httpPort > 0 { hl, err = net.Listen("tcp", fmt.Sprintf("%v:%d", *httpIP, *httpPort)) } else { hl, err = pickPort(*httpIP, portLow, portHigh, tlsEnabled) } if err != nil { kingpin.Fatalf("Could not bind to port: %s", err) return } templates := ricetemp.MustMakeTemplates(rice.MustFindBox("templates")) if err != nil { kingpin.Fatalf("Error loading templates: %s", err) return } ignores := make([]*regexp.Regexp, 0, 0) for _, expr := range *ignoreHeaders { v, err := regexp.Compile(expr) if err != nil { kingpin.Fatalf("%s", err) } ignores = append(ignores, v) } routeColl := make(routeCollection) for _, s := range *routes { err := routeColl.Set(s) if err != nil { kingpin.FatalUsage("Invalid route specification: %s", err) } } mux := http.NewServeMux() var livereloadEnabled = false if *livereloadRoutes || len(*watch) > 0 { livereloadEnabled = true } for match, route := range routeColl { handler := devdHandler( logger, route, templates, *logHeaders, ignores, livereloadEnabled, *latency, ) mux.Handle(match, http.StripPrefix(route.Path, handler)) } lr := livereload.NewServer("livereload", logger) if livereloadEnabled { mux.Handle("/livereload", lr) mux.Handle("/livereload.js", http.HandlerFunc(lr.ServeScript)) } if *livereloadRoutes { err = WatchRoutes(routeColl, lr) if err != nil { kingpin.Fatalf("Could not watch routes for livereload: %s", err) } } if len(*watch) > 0 { err = WatchPaths(*watch, *excludes, lr, logger) if err != nil { kingpin.Fatalf("Could not watch path for livereload: %s", err) } } var tlsConfig *tls.Config if *certFile != "" { tlsConfig, err = getTLSConfig(*certFile) if err != nil { kingpin.Fatalf("Could not load certs: %s", err) return } hl = tls.NewListener(hl, tlsConfig) } hl = slowdown.NewSlowListener( hl, float64(*throttleUpKbps)*1024, float64(*throttleDownKbps)*1024, ) url := formatURL(tlsEnabled, *httpIP, hl.Addr().(*net.TCPAddr).Port) logger.Say("Listening on %s (%s)", url, hl.Addr().String()) if *openBrowser { go func() { webbrowser.Open(url) }() } server := &http.Server{ Addr: hl.Addr().String(), Handler: hostPortStrip(mux), } err = server.Serve(hl) logger.Shout("Server stopped: %v", err) }
// Serve starts the devd server func (dd *Devd) Serve(logger termlog.Logger) error { templates, err := ricetemp.MakeTemplates(rice.MustFindBox("templates")) if err != nil { return fmt.Errorf("Error loading templates: %s", err) } ignores := make([]*regexp.Regexp, 0, 0) for _, expr := range dd.IgnoreLogs { v, err := regexp.Compile(expr) if err != nil { return fmt.Errorf("%s", err) } ignores = append(ignores, v) } routeColl := make(RouteCollection) for _, s := range dd.Routes { err := routeColl.Set(s) if err != nil { return fmt.Errorf("Invalid route specification: %s", err) } } mux := http.NewServeMux() for match, route := range routeColl { handler := dd.RouteHandler(logger, route, templates, ignores) mux.Handle(match, http.StripPrefix(route.Path, handler)) } lr := livereload.NewServer("livereload", logger) if dd.LivereloadEnabled() { mux.Handle("/livereload", lr) mux.Handle("/livereload.js", http.HandlerFunc(lr.ServeScript)) } if dd.LivereloadRoutes { err = WatchRoutes(routeColl, lr, dd.Excludes, logger) if err != nil { return fmt.Errorf("Could not watch routes for livereload: %s", err) } } if len(dd.Watch) > 0 { err = WatchPaths(dd.Watch, dd.Excludes, lr, logger) if err != nil { return fmt.Errorf("Could not watch path for livereload: %s", err) } } var hl net.Listener tlsEnabled := false if dd.CertFile != "" { tlsEnabled = true } if dd.Port > 0 { hl, err = net.Listen("tcp", fmt.Sprintf("%v:%d", dd.Address, dd.Port)) } else { hl, err = pickPort(dd.Address, portLow, portHigh, tlsEnabled) } if err != nil { return fmt.Errorf("Could not bind to port: %s", err) } var tlsConfig *tls.Config if dd.CertFile != "" { tlsConfig, err = getTLSConfig(dd.CertFile) if err != nil { return fmt.Errorf("Could not load certs: %s", err) } hl = tls.NewListener(hl, tlsConfig) } hl = slowdown.NewSlowListener(hl, dd.UpKbps*1024, dd.DownKbps*1024) url := formatURL(tlsEnabled, dd.Address, hl.Addr().(*net.TCPAddr).Port) logger.Say("Listening on %s (%s)", url, hl.Addr().String()) if dd.OpenBrowser { go func() { webbrowser.Open(url) }() } server := &http.Server{ Addr: hl.Addr().String(), Handler: hostPortStrip(mux), } err = server.Serve(hl) logger.Shout("Server stopped: %v", err) return nil }