From 055b10405ea02fb7adb3867141dc56464fda9a90 Mon Sep 17 00:00:00 2001
From: Luke Shumaker <lukeshu@lukeshu.com>
Date: Mon, 18 Dec 2017 22:23:11 -0500
Subject: use contexts for logging

---
 nslcd_systemd/nslcd_systemd.go | 44 +++++++++++++++++++++++++++++-------------
 1 file changed, 31 insertions(+), 13 deletions(-)

(limited to 'nslcd_systemd/nslcd_systemd.go')

diff --git a/nslcd_systemd/nslcd_systemd.go b/nslcd_systemd/nslcd_systemd.go
index b2f8e28..29d49d6 100644
--- a/nslcd_systemd/nslcd_systemd.go
+++ b/nslcd_systemd/nslcd_systemd.go
@@ -61,6 +61,15 @@ type Backend interface {
 	Close()
 }
 
+type contextKey struct {
+	name string
+}
+
+var (
+	// ConnectionIDKey is a context key.
+	ConnectionIDKey = &contextKey{"connection-id"}
+)
+
 func get_socket() (socket net.Listener, err error) {
 	fds := sd_daemon.ListenFds(true)
 	if fds == nil {
@@ -102,17 +111,20 @@ func handler(backend nslcd_server.Backend, limits nslcd_server.Limits, conn *net
 	ctx, cancel := context.WithCancel(ctx)
 	defer cancel()
 
+	// TODO: override nslcd_server.LoggerKey with a logger that includes ConnectionIDKey
+	log := nslcd_server.LoggerFromContext(ctx)
+
 	cred, err := getpeercred(conn)
 	if err != nil {
-		sd_daemon.Log.Debug("Connection from unknown client")
+		log.Debug("Connection from unknown client")
 	} else {
-		sd_daemon.Log.Debug(fmt.Sprintf("Connection from pid=%v uid=%v gid=%v",
+		log.Debug(fmt.Sprintf("Connection from pid=%v uid=%v gid=%v",
 			cred.Pid, cred.Uid, cred.Gid))
 		ctx = context.WithValue(ctx, nslcd_server.PeerCredKey, cred)
 	}
 	err = nslcd_server.HandleRequest(backend, limits, conn, ctx)
 	if err != nil {
-		sd_daemon.Log.Notice(fmt.Sprintf("Error while handling request: %v", err))
+		log.Notice(fmt.Sprintf("Error while handling request: %v", err))
 	}
 }
 
@@ -123,11 +135,13 @@ func Main(backend Backend, limits nslcd_server.Limits, ctx context.Context) uint
 	sigs := make(chan os.Signal)
 	signal.Notify(sigs, unix.SIGTERM, unix.SIGHUP)
 
-	disable_nss_module()
+	log := nslcd_server.LoggerFromContext(ctx)
+
+	disable_nss_module(log)
 
 	err = backend.Init()
 	if err != nil {
-		sd_daemon.Log.Err(fmt.Sprintf("Could not initialize backend: %v", err))
+		log.Err(fmt.Sprintf("Could not initialize backend: %v", err))
 		sd_daemon.Notification{State: "STOPPING=1"}.Send(false)
 		return sd_daemon.EXIT_FAILURE
 	}
@@ -138,7 +152,7 @@ func Main(backend Backend, limits nslcd_server.Limits, ctx context.Context) uint
 
 	socket, err := get_socket()
 	if err != nil {
-		sd_daemon.Log.Err(fmt.Sprintf("%v", err))
+		log.Err(fmt.Sprintf("%v", err))
 		sd_daemon.Notification{State: "STOPPING=1"}.Send(false)
 		return sd_daemon.EXIT_NOTRUNNING
 	}
@@ -153,6 +167,8 @@ func Main(backend Backend, limits nslcd_server.Limits, ctx context.Context) uint
 		defer sd_daemon.Recover()
 		defer wg.Done()
 
+		id := 0
+
 		var tempDelay time.Duration
 		last := false
 		for !last {
@@ -161,7 +177,7 @@ func Main(backend Backend, limits nslcd_server.Limits, ctx context.Context) uint
 				if ne, ok := err.(net.Error); ok && ne.Timeout() {
 					last = true
 				} else if ne, ok := err.(net.Error); ok && ne.Temporary() {
-					sd_daemon.Log.Notice(fmt.Sprintf("temporary error %v", err))
+					log.Notice(fmt.Sprintf("temporary error %v", err))
 					if tempDelay == 0 {
 						tempDelay = 5 * time.Millisecond
 					} else {
@@ -178,10 +194,12 @@ func Main(backend Backend, limits nslcd_server.Limits, ctx context.Context) uint
 			}
 			if conn != nil {
 				wg.Add(1)
+				id++
+				hctx := context.WithValue(ctx, ConnectionIDKey, id)
 				go func() {
 					defer sd_daemon.Recover()
 					defer wg.Done()
-					handler(backend, limits, conn.(*net.UnixConn), ctx)
+					handler(backend, limits, conn.(*net.UnixConn), hctx)
 				}()
 			}
 		}
@@ -194,23 +212,23 @@ func Main(backend Backend, limits nslcd_server.Limits, ctx context.Context) uint
 		case sig := <-sigs:
 			switch sig {
 			case unix.SIGTERM:
-				sd_daemon.Log.Notice("Received SIGTERM, shutting down")
+				log.Notice("Received SIGTERM, shutting down")
 				return sd_daemon.EXIT_SUCCESS
 			case unix.SIGHUP:
-				sd_daemon.Log.Notice("Received SIGHUP, reloading")
+				log.Notice("Received SIGHUP, reloading")
 				sd_daemon.Notification{State: "RELOADING=1"}.Send(false)
 				err := backend.Reload()
 				if err != nil {
-					sd_daemon.Log.Notice(fmt.Sprintf("Could not reload backend: %v", err))
+					log.Notice(fmt.Sprintf("Could not reload backend: %v", err))
 					return sd_daemon.EXIT_NOTRUNNING
 				}
 				sd_daemon.Notification{State: "READY=1"}.Send(false)
 			}
 		case <-ctx.Done():
-			sd_daemon.Log.Err(fmt.Sprintf("Context was canceled, shutting down: %v", ctx.Err()))
+			log.Err(fmt.Sprintf("Context was canceled, shutting down: %v", ctx.Err()))
 			return sd_daemon.EXIT_FAILURE
 		case err = <-socket_error:
-			sd_daemon.Log.Err(fmt.Sprintf("%v", err))
+			log.Err(fmt.Sprintf("%v", err))
 			return sd_daemon.EXIT_NETWORK
 		}
 	}
-- 
cgit v1.2.3