コード例 #1
0
ファイル: route_test.go プロジェクト: npk/devd
func TestRouteHandler(t *testing.T) {
	var routeHandlerTests = []struct {
		spec string
	}{
		{"/one=two"},
	}
	for i, tt := range routeHandlerTests {
		r, err := newRoute(tt.spec)
		if err != nil {
			t.Errorf(
				"Test %d, unexpected error:\n%s\n",
				i,
				err,
			)
		}

		rb, err := rice.FindBox("templates")
		if err != nil {
			t.Error(err)
		}
		templates, err := ricetemp.MakeTemplates(rb)
		if err != nil {
			panic(err)
		}

		r.Endpoint.Handler(templates, inject.CopyInject{})
	}
}
コード例 #2
0
ファイル: server.go プロジェクト: chrissexton/devd
// 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
}
コード例 #3
0
ファイル: route_test.go プロジェクト: npk/devd
func TestForwardEndpoint(t *testing.T) {
	f, err := newForwardEndpoint("http://foo")
	if err != nil {
		t.Errorf("Unexpected error: %s", err)
	}
	rb, err := rice.FindBox("templates")
	if err != nil {
		t.Error(err)
	}
	templates, err := ricetemp.MakeTemplates(rb)
	if err != nil {
		panic(err)
	}

	f.Handler(templates, inject.CopyInject{})

	f, err = newForwardEndpoint("%")
	if err == nil {
		t.Errorf("Expected error, got %s", f)
	}
}
コード例 #4
0
ファイル: cli.go プロジェクト: supiyun/devd
// 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
}