Channel close bugfix

channel/channel.go

@@ -161,9 +161,23 @@ func (c *Channel) Open() error {
 
 // Close signals to stop the channel read loop and closes the underlying Transport object.
 func (c *Channel) Close() error {
-	c.done <- true
-
-	return c.t.Close(false)
+	ch := make(chan struct{})
+
+	go func() {
+		c.done <- true
+
+		ch <- struct{}{}
+	}()
+
+	select {
+	case <-ch:
+		return c.t.Close(false)
+	case <-time.After(2 * (c.ReadDelay * c.ReadDelay)): // nolint: gomnd
+		// channel is stuck in a blocking read, force close transport to finish closing connection,
+		// so give it 2*(c.ReadDelay squared) to "nicely" exit -- with defaults this ends up being
+		// 50ms.
+		return c.t.Close(true)
+	}
 }
 
 type result struct {

examples/generic_driver/custom_logging/README.md

@@ -0,0 +1,7 @@
+Custom Logging
+===============
+
+If you want to use a custom logging setup with one or more outputs you can create a `logging.
+Instance` and pass it to the driver via the `WithLogger` option. The logging instance can accept 
+as many "loggers" as you want to give it -- these "loggers" can be any function that accepts a 
+variadic of interface. Check out the example to see this in action.

examples/generic_driver/custom_logging/main.go

@@ -0,0 +1,66 @@
+package main
+
+import (
+	"fmt"
+	"log"
+
+	"github.com/scrapli/scrapligo/logging"
+
+	"github.com/scrapli/scrapligo/driver/generic"
+	"github.com/scrapli/scrapligo/driver/options"
+)
+
+func myLoggerFunc(x ...interface{}) {
+	// not sure why you would want to do this, but this is just an example logger function you
+	// could use :)
+	if len(x) > 0 {
+		// pro tip... its almost certainly going to be a string, but this is just to show how
+		// you can add logger functions so who cares!
+		fmt.Printf("got a log item of type %T\n", x[0])
+	}
+}
+
+func main() {
+	li, err := logging.NewInstance(
+		logging.WithLevel(logging.Debug),
+		logging.WithLogger(log.Print),
+		logging.WithLogger(myLoggerFunc),
+	)
+	if err != nil {
+		fmt.Printf("failed to logging instance; error: %+v\n", err)
+
+		return
+	}
+
+	d, err := generic.NewDriver(
+		"sandbox-iosxe-latest-1.cisco.com",
+		options.WithAuthNoStrictKey(),
+		options.WithAuthUsername("developer"),
+		options.WithAuthPassword("C1sco12345"),
+		// the options.WithLogger applies the logging instance created above to our driver
+		options.WithLogger(li),
+	)
+	if err != nil {
+		fmt.Printf("failed to create driver; error: %+v\n", err)
+
+		return
+	}
+
+	err = d.Open()
+	if err != nil {
+		fmt.Printf("failed to open driver; error: %+v\n", err)
+
+		return
+	}
+
+	defer d.Close()
+
+	r, err := d.SendCommand("show version | i Version")
+	if err != nil {
+		fmt.Printf("failed to run command; error: %+v\n", err)
+
+		return
+	}
+
+	fmt.Printf("got some output: %s\n\n\n", r.Result)
+}

logging/logging.go

@@ -2,6 +2,7 @@ package logging
 
 import (
 	"fmt"
+	"sync"
 
 	"github.com/scrapli/scrapligo/util"
 )
@@ -42,9 +43,21 @@ type Instance struct {
 
 // Emit "emits" a logging message m to all the loggers in the Instance.
 func (i *Instance) Emit(m interface{}) {
+	wg := sync.WaitGroup{}
+
 	for _, f := range i.Loggers {
-		f(m)
+		wg.Add(1)
+
+		lf := f
+
+		go func() {
+			lf(m)
+
+			wg.Done()
+		}()
 	}
+
+	wg.Wait()
 }
 
 func (i *Instance) shouldLog(l string) bool {