sum7
/
yaja
Archived
1
0
Fork 0
This repository has been archived on 2020-09-27. You can view files and clone it, but cannot push or open issues or pull requests.
yaja/daemon/server.go

205 lines
5.2 KiB
Go
Raw Normal View History

package daemon
2017-10-01 23:30:48 +02:00
import (
"crypto/tls"
2017-12-14 21:30:07 +01:00
"net/http"
2017-10-01 23:30:48 +02:00
"os"
"os/signal"
"syscall"
"time"
2017-10-01 23:30:48 +02:00
"golang.org/x/crypto/acme/autocert"
serverDaemon "dev.sum7.eu/genofire/yaja/daemon/server"
2018-02-07 15:34:18 +01:00
"dev.sum7.eu/genofire/yaja/database"
"dev.sum7.eu/genofire/yaja/server/extension"
2017-10-02 14:38:52 +02:00
2018-02-07 15:34:18 +01:00
"dev.sum7.eu/genofire/golang-lib/file"
"dev.sum7.eu/genofire/golang-lib/worker"
"dev.sum7.eu/genofire/yaja/server"
2017-10-01 23:30:48 +02:00
log "github.com/sirupsen/logrus"
"github.com/spf13/cobra"
)
var (
serverConfig = &serverDaemon.Config{}
2017-12-17 17:50:51 +01:00
db = &database.State{}
srv *server.Server
certs *tls.Config
extensionsClient extension.Extensions
extensionsServer extension.Extensions
)
// ServerCMD represents the serve command
var ServerCMD = &cobra.Command{
2017-12-14 21:30:07 +01:00
Use: "server",
Short: "runs xmpp server",
Example: "yaja daemon server -c /etc/yaja.conf",
2017-10-01 23:30:48 +02:00
Run: func(cmd *cobra.Command, args []string) {
2017-12-17 17:50:51 +01:00
if err := file.ReadTOML(configPath, serverConfig); err != nil {
2017-10-02 14:38:52 +02:00
log.Fatal("unable to load config file:", err)
}
log.SetLevel(serverConfig.Logging.Level)
2017-12-14 21:30:07 +01:00
if err := file.ReadJSON(serverConfig.StatePath, db); err != nil {
log.Warn("unable to load state file:", err)
}
statesaveWorker = worker.NewWorker(time.Minute, func() {
file.SaveJSON(serverConfig.StatePath, db)
log.Info("save state to:", serverConfig.StatePath)
})
m := autocert.Manager{
Cache: autocert.DirCache(serverConfig.TLSDir),
Prompt: autocert.AcceptTOS,
}
2017-12-14 21:30:07 +01:00
// https server to handle acme (by letsencrypt)
for _, addr := range serverConfig.Address.Webserver {
hs := &http.Server{
Addr: addr,
TLSConfig: &tls.Config{GetCertificate: m.GetCertificate},
}
go func(hs *http.Server, addr string) {
if err := hs.ListenAndServeTLS("", ""); err != http.ErrServerClosed {
log.Errorf("webserver with addr %s: %s", addr, err)
}
}(hs, addr)
2017-12-14 21:30:07 +01:00
}
srv = &server.Server{
2017-12-17 17:50:51 +01:00
TLSManager: &m,
Database: db,
ClientAddr: serverConfig.Address.Client,
ServerAddr: serverConfig.Address.Server,
LoggingClient: serverConfig.Logging.LevelClient,
LoggingServer: serverConfig.Logging.LevelServer,
RegisterEnable: serverConfig.Register.Enable,
RegisterDomains: serverConfig.Register.Domains,
2017-12-17 17:50:51 +01:00
ExtensionsServer: extensionsServer,
ExtensionsClient: extensionsClient,
}
go statesaveWorker.Start()
go srv.Start()
2017-10-02 14:38:52 +02:00
log.Infoln("yaja started ")
2017-10-01 23:30:48 +02:00
// Wait for INT/TERM
sigs := make(chan os.Signal, 1)
signal.Notify(sigs, syscall.SIGTERM, syscall.SIGHUP, syscall.SIGQUIT, syscall.SIGUSR1)
for sig := range sigs {
log.Infoln("received", sig)
switch sig {
case syscall.SIGTERM:
log.Panic("terminated")
os.Exit(0)
case syscall.SIGQUIT:
quit()
case syscall.SIGHUP:
quit()
case syscall.SIGUSR1:
reload()
}
}
2017-10-01 23:30:48 +02:00
},
}
func quit() {
srv.Close()
statesaveWorker.Close()
file.SaveJSON(serverConfig.StatePath, db)
}
func reload() {
log.Info("start reloading...")
var configNewData *serverDaemon.Config
2017-12-17 17:50:51 +01:00
if err := file.ReadTOML(configPath, configNewData); err != nil {
log.Warn("unable to load config file:", err)
return
}
log.SetLevel(configNewData.Logging.Level)
srv.LoggingClient = configNewData.Logging.LevelClient
2017-12-17 17:50:51 +01:00
srv.LoggingServer = configNewData.Logging.LevelServer
srv.RegisterEnable = configNewData.Register.Enable
srv.RegisterDomains = configNewData.Register.Domains
2017-12-14 21:30:07 +01:00
//TODO fetch changing address (to set restart)
if configNewData.StatePath != serverConfig.StatePath {
statesaveWorker.Close()
statesaveWorker := worker.NewWorker(time.Minute, func() {
2017-12-14 21:30:07 +01:00
file.SaveJSON(configNewData.StatePath, db)
log.Info("save state to:", configNewData.StatePath)
})
go statesaveWorker.Start()
}
restartServer := false
if configNewData.TLSDir != serverConfig.TLSDir {
m := autocert.Manager{
Cache: autocert.DirCache(serverConfig.TLSDir),
Prompt: autocert.AcceptTOS,
}
certs = &tls.Config{GetCertificate: m.GetCertificate}
restartServer = true
}
if restartServer {
newServer := &server.Server{
2017-12-17 17:50:51 +01:00
TLSConfig: certs,
Database: db,
ClientAddr: configNewData.Address.Client,
ServerAddr: configNewData.Address.Server,
LoggingClient: configNewData.Logging.LevelClient,
RegisterEnable: configNewData.Register.Enable,
RegisterDomains: configNewData.Register.Domains,
ExtensionsServer: extensionsServer,
ExtensionsClient: extensionsClient,
}
log.Warn("reloading need a restart:")
go newServer.Start()
//TODO should fetch new server error
srv.Close()
srv = newServer
}
serverConfig = configNewData
log.Info("reloaded")
}
2017-10-01 23:30:48 +02:00
func init() {
2018-02-10 13:34:42 +01:00
2017-12-17 17:50:51 +01:00
extensionsClient = append(extensionsClient,
&extension.Message{},
2017-12-17 15:39:36 +01:00
&extension.Presence{},
extension.IQExtensions{
2018-02-10 13:34:42 +01:00
//&extension.IQPrivateBookmark{},
//&extension.IQPrivateMetacontact{},
//&extension.IQPrivateRoster{},
2017-12-17 15:39:36 +01:00
&extension.IQPing{},
2018-02-10 13:34:42 +01:00
//&extension.IQLast{},
//&extension.IQDisco{Database: db},
//&extension.IQRoster{Database: db},
//&extension.IQExtensionDiscovery{GetSpaces: func() []string {
// return extensionsClient.Spaces()
//}},
})
2017-12-17 17:50:51 +01:00
extensionsServer = append(extensionsServer,
extension.IQExtensions{
&extension.IQPing{},
})
ServerCMD.Flags().StringVarP(&configPath, "config", "c", "yaja-server.conf", "Path to configuration file")
2017-12-16 23:20:46 +01:00
2017-10-01 23:30:48 +02:00
}