tt daemon: logger support

Author: AnaNek

cli/cmd/daemon.go

@@ -108,7 +108,9 @@ func internalDaemonStartModule(cmdCtx *cmdcontext.CmdCtx, args []string) error {
 		return err
 	}
 
-	running.FillDaemonCtx(cliOpts, cmdCtx)
+	if err = running.FillDaemonCtx(cliOpts, cmdCtx); err != nil {
+		log.Fatalf(err.Error())
+	}
 
 	if err := daemon.RunHTTPServerOnBackground(cmdCtx); err != nil {
 		log.Fatalf(err.Error())
@@ -124,9 +126,9 @@ func internalDaemonStopModule(cmdCtx *cmdcontext.CmdCtx, args []string) error {
 		return err
 	}
 
-	running.FillDaemonCtx(cliOpts, cmdCtx)
-
-	daemon.StopHTTPServer(cmdCtx)
+	if err = running.FillDaemonCtx(cliOpts, cmdCtx); err != nil {
+		log.Fatalf(err.Error())
+	}
 
 	if err := running.Stop(cmdCtx, cmdCtx.Daemon.PIDFile, cmdCtx.Daemon.ConsoleSocket); err != nil {
 		return err
@@ -142,7 +144,9 @@ func internalDaemonStatusModule(cmdCtx *cmdcontext.CmdCtx, args []string) error
 		return err
 	}
 
-	running.FillDaemonCtx(cliOpts, cmdCtx)
+	if err = running.FillDaemonCtx(cliOpts, cmdCtx); err != nil {
+		log.Fatalf(err.Error())
+	}
 
 	log.Info(running.Status(cmdCtx, cmdCtx.Daemon.PIDFile))
 

cli/cmdcontext/cmdcontext.go

@@ -89,5 +89,20 @@ type ConnectCtx struct {
 type DaemonCtx struct {
 	Port int
 	PIDFile string
+	LogPath string
+	// LogMaxSize is the maximum size in megabytes of the log file
+	// before it gets rotated. It defaults to 100 megabytes.
+	LogMaxSize int
+	// LogMaxBackups is the maximum number of old log files to retain.
+	// The default is to retain all old log files (though LogMaxAge may
+	// still cause them to get deleted).
+	LogMaxBackups int
+	// LogMaxAge is the maximum number of days to retain old log files
+	// based on the timestamp encoded in their filename. Note that a
+	// day is defined as 24 hours and may not exactly correspond to
+	// calendar days due to daylight savings, leap seconds, etc. The
+	// default is not to remove old log files based on age.
+	LogMaxAge int
 	ConsoleSocket string
+	ListenInterface string
 }

cli/config/config.go

@@ -64,6 +64,20 @@ type AppOpts struct {
 type DaemonOpts struct {
 	PIDFile string `mapstructure:"pid"`
 	Port int `mapstructure:"port"`
+	LogDir string `mapstructure:"log_dir"`
+	LogFile string `mapstructure:"log_file"`
+	LogMaxSize int `mapstructure:"log_maxsize"`
+	// LogMaxAge is the maximum number of days to retain old log files
+	// based on the timestamp encoded in their filename. Note that a
+	// day is defined as 24 hours and may not exactly correspond to
+	// calendar days due to daylight savings, leap seconds, etc. The
+	// default is not to remove old log files based on age.
+	LogMaxAge int `mapstructure:"log_maxage"`
+	// LogMaxBackups is the maximum number of old log files to retain.
+	// The default is to retain all old log files (though LogMaxAge may
+	// still cause them to get deleted).
+	LogMaxBackups int `mapstructure:"log_maxbackups"`
+	ListenInterface string `mapstructure:"listen_interface"`
 }
 
 // CliOpts is used to store modules and app options.

cli/configure/configure.go

@@ -22,6 +22,12 @@ const (
 	cliExecutableName = "tt"
 )
 
+const (
+	defaultDaemonPort = 1024
+	defaultDaemonPidFile = "tt_daemon.pid"
+	defaultDaemonLogFile= "tt_daemon.log"
+)
+
 var (
 	// Path to default tarantool.yaml configuration file.
 	// Defined at build time, see magefile.
@@ -43,7 +49,18 @@ func getDefaultCliOpts() *config.CliOpts {
 		Restartable:        false,
 		DataDir:            "data",
 	}
-	return &config.CliOpts{Modules: &modules, App: &app}
+	daemon := config.DaemonOpts{
+		Port:            defaultDaemonPort,
+		PIDFile:         defaultDaemonPidFile,
+		LogDir:          "log",
+		LogFile:         defaultDaemonLogFile,
+		LogMaxSize:      0,
+		LogMaxAge:       0,
+		LogMaxBackups:   0,
+		ListenInterface: "",
+	}
+
+	return &config.CliOpts{Modules: &modules, App: &app, Daemon: &daemon}
 }
 
 // GetCliOpts returns Tarantool CLI options from the config file

cli/daemon/daemon.go

@@ -1,91 +1,23 @@
 package daemon
 
 import (
-	"fmt"
-	"net"
-	"os"
-	"strconv"
-	"syscall"
-
 	"github.com/tarantool/tt/cli/cmdcontext"
-	"github.com/tarantool/tt/cli/running"
+	"github.com/tarantool/tt/cli/ttlog"
 )
 
-func externalIP() (string, error) {
-	ifaces, err := net.Interfaces()
-	if err != nil {
-		return "", err
-	}
-
-	for _, iface := range ifaces {
-		if iface.Flags & net.FlagUp == 0 {
-			continue // interface down
-		}
-		if iface.Flags & net.FlagLoopback != 0 {
-			continue // loopback interface
-		}
-
-		addrs, err := iface.Addrs()
-		if err != nil {
-			return "", err
-		}
-
-		for _, addr := range addrs {
-			var ip net.IP
-			switch v := addr.(type) {
-			case *net.IPNet:
-				ip = v.IP
-			case *net.IPAddr:
-				ip = v.IP
-			}
-
-			if ip == nil || ip.IsLoopback() {
-				continue
-			}
-
-			ip = ip.To4()
-			if ip == nil {
-				continue // not an ipv4 address
-			}
-
-			return ip.String(), nil
-		}
-	}
-
-	return "", fmt.Errorf("external IP is not available")
-}
-
 func RunHTTPServerOnBackground(cmdCtx *cmdcontext.CmdCtx) error {
-	ip, err := externalIP()
-	if err != nil {
-		return err
+	logOpts := ttlog.LoggerOpts{
+		Filename: cmdCtx.Daemon.LogPath,
+		MaxSize: cmdCtx.Daemon.LogMaxSize,
+		MaxBackups: cmdCtx.Daemon.LogMaxBackups,
+		MaxAge: cmdCtx.Daemon.LogMaxAge,
 	}
 
-	httpServerAddr := ip + ":" + strconv.Itoa(cmdCtx.Daemon.Port)
-	proc := NewProcess(NewHTTPServer(httpServerAddr), cmdCtx.Daemon.PIDFile)
+	proc := NewProcess(NewHTTPServer(cmdCtx.Daemon.ListenInterface, cmdCtx.Daemon.Port),
+		cmdCtx.Daemon.PIDFile, logOpts)
 
 	if err := proc.Start(); err != nil {
 		return err
 	}
 	return nil
 }
-
-func SendSignalToDaemon(pidFile string, sig os.Signal) error {
-	pid, err := running.GetPIDFromFile(pidFile)
-	if err != nil {
-		return err
-	}
-
-	process, err := os.FindProcess(pid)
-	if err != nil {
-		return err
-	}
-
-	err = process.Signal(sig)
-	return err
-}
-
-func StopHTTPServer(cmdCtx *cmdcontext.CmdCtx) error {
-	err := SendSignalToDaemon(cmdCtx.Daemon.PIDFile, syscall.SIGUSR1)
-	return err
-}

cli/daemon/httpserver.go

@@ -2,27 +2,78 @@ package daemon
 
 import (
 	"context"
-	"log"
+	"fmt"
+	"net"
 	"net/http"
+	"strconv"
 	"time"
 
 	"github.com/tarantool/tt/cli/daemon/api"
+	"github.com/tarantool/tt/cli/ttlog"
 )
 
 const (
 	defaultStopTimeout = 100 * time.Millisecond
 )
 
 type HTTPServer struct {
-	srv    *http.Server
-	timeout time.Duration
+	listenIface string
+	port        int
+	srv         *http.Server
+	timeout     time.Duration
+	logger      *ttlog.Logger
 }
 
-func NewHTTPServer(httpServerAddr string) *HTTPServer {
+func (httpServer *HTTPServer) externalIP() (string, error) {
+	if httpServer.listenIface == "" {
+		return net.IPv4zero.String(), nil
+	}
+
+	iface, err := net.InterfaceByName(httpServer.listenIface)
+	if err != nil {
+		return "", err
+	}
+
+	if iface.Flags & net.FlagUp == 0 {
+		return "", fmt.Errorf("Interface down")
+	}
+	if iface.Flags & net.FlagLoopback != 0 {
+		return "", fmt.Errorf("Loopback interface")
+	}
+
+	addrs, err := iface.Addrs()
+	if err != nil {
+		return "", err
+	}
+
+	for _, addr := range addrs {
+		var ip net.IP
+		switch v := addr.(type) {
+		case *net.IPNet:
+			ip = v.IP
+		case *net.IPAddr:
+			ip = v.IP
+		}
+
+		if ip == nil || ip.IsLoopback() {
+			continue
+		}
+
+		ip = ip.To4()
+		if ip == nil {
+			continue // not an ipv4 address
+		}
+
+		return ip.String(), nil
+	}
+
+	return "", fmt.Errorf("external IP is not available")
+}
+
+func NewHTTPServer(listenInterface string, port int) *HTTPServer {
 	return &HTTPServer{
-		srv: &http.Server{
-			Addr: httpServerAddr,
-		},
+		listenIface: listenInterface,
+		port: port,
 		timeout: defaultStopTimeout,
 	}
 }
@@ -32,23 +83,46 @@ func (httpServer *HTTPServer) Timeout(timeout time.Duration) *HTTPServer {
 	return httpServer
 }
 
+func (httpServer *HTTPServer) SetLogger(logger *ttlog.Logger) {
+	httpServer.logger = logger
+}
+
 func (httpServer *HTTPServer) Start(ttPath string) {
+	ip, err := httpServer.externalIP()
+	if err != nil {
+		httpServer.logger.Fatalf("Can't get IP")
+	}
+
+	httpServerAddr := ip + ":" + strconv.Itoa(httpServer.port)
+	httpServer.srv = &http.Server{
+		Addr: httpServerAddr,
+	}
+
 	// Prepare HTTP server.
 	daemonHandler := api.NewDaemonHandler(ttPath)
 	http.Handle("/tarantool", daemonHandler)
 
 	// Start HTTP server.
-	if err := httpServer.srv.ListenAndServe(); err != http.ErrServerClosed {
-		log.Fatalf("Can't start HTTP server")
+	socket, err := net.Listen("tcp4", httpServer.srv.Addr)
+	if err != nil {
+		httpServer.logger.Fatal(err)
+	}
+
+	if err := httpServer.srv.Serve(socket); err != http.ErrServerClosed {
+		httpServer.logger.Fatalf("Can't start HTTP server")
 	}
 }
 
 func (httpServer *HTTPServer) Stop() error {
 	var err error
 
+	if httpServer.srv == nil {
+		return fmt.Errorf("Server is not started")
+	}
+
 	ctx, cancel := context.WithTimeout(context.Background(), httpServer.timeout)
 	if err = httpServer.srv.Shutdown(ctx); err != nil {
-		log.Printf(`HTTP server shutdown error: "%v"`, err)
+		httpServer.logger.Printf(`HTTP server shutdown error: "%v"`, err)
 	}
 	cancel()