add keepalive for ssh

dialer/sshd/dialer.go

@@ -2,7 +2,6 @@ package sshd
 
 import (
 	"context"
-	"errors"
 	"net"
 	"sync"
 	"time"
@@ -19,7 +18,7 @@ func init() {
 }
 
 type sshdDialer struct {
-	sessions     map[string]*sshSession
+	sessions     map[string]*ssh_util.Session
 	sessionMutex sync.Mutex
 	md           metadata
 	options      dialer.Options
@@ -32,7 +31,7 @@ func NewDialer(opts ...dialer.Option) dialer.Dialer {
 	}
 
 	return &sshdDialer{
-		sessions: make(map[string]*sshSession),
+		sessions: make(map[string]*ssh_util.Session),
 		options:  options,
 	}
 }
@@ -70,68 +69,31 @@ func (d *sshdDialer) Dial(ctx context.Context, addr string, opts ...dialer.DialO
 			return
 		}
 
-		session = &sshSession{
-			addr: addr,
-			conn: conn,
+		if d.md.handshakeTimeout > 0 {
+			conn.SetDeadline(time.Now().Add(d.md.handshakeTimeout))
+			defer conn.SetDeadline(time.Time{})
 		}
+
+		session, err = d.initSession(ctx, addr, conn)
+		if err != nil {
+			conn.Close()
+			return nil, err
+		}
+		if d.md.keepalive {
+			go session.Keepalive(d.md.keepaliveInterval, d.md.keepaliveTimeout, d.md.keepaliveRetries)
+		}
+		go session.Wait()
+		go session.WaitClose()
+
 		d.sessions[addr] = session
 	}
 
-	return session.conn, err
+	return ssh_util.NewClientConn(session), nil
 }
 
-// Handshake implements dialer.Handshaker
-func (d *sshdDialer) Handshake(ctx context.Context, conn net.Conn, options ...dialer.HandshakeOption) (net.Conn, error) {
-	opts := &dialer.HandshakeOptions{}
-	for _, option := range options {
-		option(opts)
-	}
-
-	d.sessionMutex.Lock()
-	defer d.sessionMutex.Unlock()
-
-	if d.md.handshakeTimeout > 0 {
-		conn.SetDeadline(time.Now().Add(d.md.handshakeTimeout))
-		defer conn.SetDeadline(time.Time{})
-	}
-
-	log := d.options.Logger
-
-	session, ok := d.sessions[opts.Addr]
-	if session != nil && session.conn != conn {
-		err := errors.New("ssh: unrecognized connection")
-		log.Error(err)
-		conn.Close()
-		delete(d.sessions, opts.Addr)
-		return nil, err
-	}
-
-	if !ok || session.client == nil {
-		s, err := d.initSession(ctx, opts.Addr, conn)
-		if err != nil {
-			log.Error(err)
-			conn.Close()
-			delete(d.sessions, opts.Addr)
-			return nil, err
-		}
-		session = s
-		go func() {
-			s.wait()
-			log.Debug("session closed")
-		}()
-		d.sessions[opts.Addr] = session
-	}
-	if session.IsClosed() {
-		delete(d.sessions, opts.Addr)
-		return nil, ssh_util.ErrSessionDead
-	}
-
-	return ssh_util.NewClientConn(session.conn, session.client), nil
-}
-
-func (d *sshdDialer) initSession(ctx context.Context, addr string, conn net.Conn) (*sshSession, error) {
+func (d *sshdDialer) initSession(ctx context.Context, addr string, conn net.Conn) (*ssh_util.Session, error) {
 	config := ssh.ClientConfig{
-		// Timeout:         timeout,
+		Timeout:         d.md.handshakeTimeout,
 		HostKeyCallback: ssh.InsecureIgnoreHostKey(),
 	}
 	if d.options.Auth != nil {
@@ -151,10 +113,5 @@ func (d *sshdDialer) initSession(ctx context.Context, addr string, conn net.Conn
 		return nil, err
 	}
 
-	return &sshSession{
-		conn:   conn,
-		client: ssh.NewClient(sshConn, chans, reqs),
-		closed: make(chan struct{}),
-		dead:   make(chan struct{}),
-	}, nil
+	return ssh_util.NewSession(conn, ssh.NewClient(sshConn, chans, reqs), d.options.Logger), nil
 }