func StartAdmin(globals *config.Globals) {
debug := logging.DebugLevel() > 0
InitSessionStore(globals.Config)
appRouter.HandleFunc("/", SecurityContextHandler(mainPageHandler, globals, ""))
appRouter.HandleFunc("/login", ContextHandler(loginPageHandler, globals)).Name("auth-login")
appRouter.HandleFunc("/logout", logoffHandler)
appRouter.HandleFunc("/chpass", SecurityContextHandler(chpassPageHandler, globals, ""))
appRouter.HandleFunc("/logs", SecurityContextHandler(logsPageHandler, globals, "ADMIN"))
InitUsersHandlers(globals, appRouter.PathPrefix("/users"))
InitEndpointsHandlers(globals, appRouter.PathPrefix("/endpoints"))
InitCertsHandlers(globals, appRouter.PathPrefix("/certs"))
InitStatsHandlers(globals, appRouter.PathPrefix("/stats"))
InitSettingsHandlers(globals, appRouter.PathPrefix("/settings"))
http.Handle("/static/", http.StripPrefix("/static",
FileServer(http.Dir(globals.Config.AdminPanel.StaticDir), debug)))
http.Handle("/favicon.ico", FileServer(http.Dir(globals.Config.AdminPanel.StaticDir), debug))
http.Handle("/", globals.StatsAdmin.Handler(common.LogHandler(CsrfHandler(SessionHandler(appRouter)), "admin:", "module", "admin")))
if globals.Config.AdminPanel.HTTPSAddress != "" {
log.Info("admin.StartAdmin Listen HTTPS ", "port", globals.Config.AdminPanel.HTTPSAddress)
go func() {
if err := http.ListenAndServeTLS(globals.Config.AdminPanel.HTTPSAddress,
globals.Config.AdminPanel.SslCert, globals.Config.AdminPanel.SslKey, nil); err != nil {
log.Error("admin.StartAdmin Error listening https, ", "err", err)
}
}()
}
if globals.Config.AdminPanel.HTTPAddress != "" {
log.Info("admin.StartAdmin Listen", "port", globals.Config.AdminPanel.HTTPAddress)
go func() {
if err := http.ListenAndServe(globals.Config.AdminPanel.HTTPAddress, nil); err != nil {
log.Error("admin.StartAdmin Error listening http, ", "err", err)
}
}()
}
}
func StartEndpoint(name string, globals *config.Globals) (errstr []string) {
log.Info("server.StartEndpoint starting ", "endpoint", name)
mu.Lock()
defer mu.Unlock()
var st *state
var ok bool
if st, ok = states[name]; ok && st != nil {
if st.running || st.runningSSL {
log.Warn("server.StartEndpoint already started ", "enpoint", name)
return []string{"already running"}
}
}
if st == nil {
st = &state{
serverClose: make(chan bool),
serverSSLClose: make(chan bool),
}
states[name] = st
}
servStat.Set(name, varState("stopped"))
servStat.Set(name+"|ssl", varState("stopped"))
conf := globals.GetEndpoint(name)
if conf == nil {
return []string{"invalid endpoint"}
}
uri, err := url.Parse(conf.Destination)
if err != nil {
return []string{"invalid url"}
}
var handler http.Handler
handler = httputil.NewSingleHostReverseProxy(uri)
handler = authenticationMW(handler, name, globals)
handler = counterMw(handler, name)
handler = common.LogHandler(handler, "server:", "endpoint", name, "module", "server")
handler = globals.StatsServer.Handler(handler)
if conf.HTTPAddress != "" {
log.Info("server.StartEndpoint starting http", "endpoint", name)
s := &http.Server{
Addr: conf.HTTPAddress,
Handler: handler,
ReadTimeout: 10 * time.Second,
WriteTimeout: 10 * time.Second,
}
ls, e := net.Listen("tcp", conf.HTTPAddress)
if e != nil {
log.Error("server.StartEndpoint starting http listen error ", "endpoint", name, "err", e)
errstr = append(errstr, "starting http error "+e.Error())
errors.Set(name, varState(e.Error()))
} else {
go func() {
st.running = true
go s.Serve(ls)
servStat.Set(name, varState("running"))
errors.Set(name, varState(""))
select {
case <-st.serverClose:
log.Info("server.StartEndpoint stop http ", "endpoint", name)
ls.Close()
st.running = false
servStat.Set(name, varState("stopped"))
return
}
}()
}
}
if conf.HTTPSAddress != "" {
log.Info("server.StartEndpoint starting https ", "endpoint", name)
s := &http.Server{
Addr: conf.HTTPSAddress,
Handler: handler,
ReadTimeout: 10 * time.Second,
WriteTimeout: 10 * time.Second,
}
config := &tls.Config{}
if config.NextProtos == nil {
config.NextProtos = []string{"http/1.1"}
}
var err error
config.Certificates = make([]tls.Certificate, 1)
config.Certificates[0], err = tls.LoadX509KeyPair(conf.SslCert, conf.SslKey)
if err != nil {
log.Error("server.StartEndpoint starting https cert error", "err", err, "endpoint", name)
errstr = append(errstr, "starting https - cert error "+err.Error())
errors.Set(name+"|ssl", varState(err.Error()))
} else {
ln, err := net.Listen("tcp", conf.HTTPSAddress)
if err != nil {
log.Error("server.StartEndpoint starting https listen error ", "err", err, "endpoint", name)
errstr = append(errstr, "starting https error "+err.Error())
errors.Set(name+"|ssl", varState(err.Error()))
} else {
tlsListener := tls.NewListener(ln, config)
go func() {
st.runningSSL = true
go s.Serve(tlsListener)
servStat.Set(name+"|ssl", varState("running"))
errors.Set(name+"|ssl", varState(""))
select {
case <-st.serverSSLClose:
log.Info("server.StartEndpoint stop https", "endpoint", name)
ln.Close()
st.runningSSL = false
servStat.Set(name, varState("stopped"))
return
}
}()
}
}
}
return
}