2024-08-19 06:26:44 +02:00
|
|
|
// Copyright 2024, Command Line Inc.
|
|
|
|
// SPDX-License-Identifier: Apache-2.0
|
|
|
|
|
|
|
|
package conncontroller
|
|
|
|
|
|
|
|
import (
|
|
|
|
"context"
|
2024-08-24 03:12:40 +02:00
|
|
|
"errors"
|
2024-08-19 06:26:44 +02:00
|
|
|
"fmt"
|
|
|
|
"io"
|
2024-08-24 03:12:40 +02:00
|
|
|
"io/fs"
|
2024-08-19 06:26:44 +02:00
|
|
|
"log"
|
|
|
|
"net"
|
2024-08-24 03:12:40 +02:00
|
|
|
"os"
|
|
|
|
"path/filepath"
|
2024-08-19 06:26:44 +02:00
|
|
|
"strings"
|
|
|
|
"sync"
|
2024-08-24 03:12:40 +02:00
|
|
|
"sync/atomic"
|
|
|
|
"time"
|
2024-08-19 06:26:44 +02:00
|
|
|
|
2024-08-24 03:12:40 +02:00
|
|
|
"github.com/kevinburke/ssh_config"
|
2024-09-02 21:34:49 +02:00
|
|
|
"github.com/skeema/knownhosts"
|
2024-09-05 23:25:45 +02:00
|
|
|
"github.com/wavetermdev/waveterm/pkg/remote"
|
|
|
|
"github.com/wavetermdev/waveterm/pkg/userinput"
|
|
|
|
"github.com/wavetermdev/waveterm/pkg/util/shellutil"
|
|
|
|
"github.com/wavetermdev/waveterm/pkg/util/utilfn"
|
|
|
|
"github.com/wavetermdev/waveterm/pkg/wavebase"
|
|
|
|
"github.com/wavetermdev/waveterm/pkg/wps"
|
|
|
|
"github.com/wavetermdev/waveterm/pkg/wshrpc"
|
|
|
|
"github.com/wavetermdev/waveterm/pkg/wshutil"
|
2024-08-19 06:26:44 +02:00
|
|
|
"golang.org/x/crypto/ssh"
|
|
|
|
)
|
|
|
|
|
2024-08-24 03:12:40 +02:00
|
|
|
const (
|
|
|
|
Status_Init = "init"
|
|
|
|
Status_Connecting = "connecting"
|
|
|
|
Status_Connected = "connected"
|
|
|
|
Status_Disconnected = "disconnected"
|
|
|
|
Status_Error = "error"
|
|
|
|
)
|
|
|
|
|
2024-09-05 09:21:08 +02:00
|
|
|
const DefaultConnectionTimeout = 60 * time.Second
|
|
|
|
|
2024-08-19 06:26:44 +02:00
|
|
|
var globalLock = &sync.Mutex{}
|
|
|
|
var clientControllerMap = make(map[remote.SSHOpts]*SSHConn)
|
2024-09-06 08:09:30 +02:00
|
|
|
var activeConnCounter = &atomic.Int32{}
|
2024-08-19 06:26:44 +02:00
|
|
|
|
|
|
|
type SSHConn struct {
|
|
|
|
Lock *sync.Mutex
|
2024-08-24 03:12:40 +02:00
|
|
|
Status string
|
2024-08-19 06:26:44 +02:00
|
|
|
Opts *remote.SSHOpts
|
|
|
|
Client *ssh.Client
|
|
|
|
SockName string
|
|
|
|
DomainSockListener net.Listener
|
|
|
|
ConnController *ssh.Session
|
2024-08-24 03:12:40 +02:00
|
|
|
Error string
|
|
|
|
HasWaiter *atomic.Bool
|
2024-09-04 07:15:02 +02:00
|
|
|
LastConnectTime int64
|
2024-09-06 08:09:30 +02:00
|
|
|
ActiveConnNum int
|
2024-08-24 03:12:40 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
func GetAllConnStatus() []wshrpc.ConnStatus {
|
|
|
|
globalLock.Lock()
|
|
|
|
defer globalLock.Unlock()
|
|
|
|
|
|
|
|
var connStatuses []wshrpc.ConnStatus
|
|
|
|
for _, conn := range clientControllerMap {
|
|
|
|
connStatuses = append(connStatuses, conn.DeriveConnStatus())
|
|
|
|
}
|
|
|
|
return connStatuses
|
|
|
|
}
|
|
|
|
|
|
|
|
func (conn *SSHConn) DeriveConnStatus() wshrpc.ConnStatus {
|
|
|
|
conn.Lock.Lock()
|
|
|
|
defer conn.Lock.Unlock()
|
|
|
|
return wshrpc.ConnStatus{
|
2024-09-06 08:09:30 +02:00
|
|
|
Status: conn.Status,
|
|
|
|
Connected: conn.Status == Status_Connected,
|
|
|
|
Connection: conn.Opts.String(),
|
|
|
|
HasConnected: (conn.LastConnectTime > 0),
|
|
|
|
ActiveConnNum: conn.ActiveConnNum,
|
|
|
|
Error: conn.Error,
|
2024-08-24 03:12:40 +02:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
func (conn *SSHConn) FireConnChangeEvent() {
|
|
|
|
status := conn.DeriveConnStatus()
|
2024-09-12 03:03:55 +02:00
|
|
|
event := wps.WaveEvent{
|
|
|
|
Event: wps.Event_ConnChange,
|
2024-08-24 03:12:40 +02:00
|
|
|
Scopes: []string{
|
|
|
|
fmt.Sprintf("connection:%s", conn.GetName()),
|
|
|
|
},
|
|
|
|
Data: status,
|
|
|
|
}
|
2024-09-02 21:34:49 +02:00
|
|
|
log.Printf("sending event: %+#v", event)
|
2024-08-24 03:12:40 +02:00
|
|
|
wps.Broker.Publish(event)
|
2024-08-19 06:26:44 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
func (conn *SSHConn) Close() error {
|
2024-08-24 03:12:40 +02:00
|
|
|
defer conn.FireConnChangeEvent()
|
|
|
|
conn.WithLock(func() {
|
|
|
|
if conn.Status == Status_Connected || conn.Status == Status_Connecting {
|
|
|
|
// if status is init, disconnected, or error don't change it
|
|
|
|
conn.Status = Status_Disconnected
|
|
|
|
}
|
|
|
|
conn.close_nolock()
|
|
|
|
})
|
|
|
|
// we must wait for the waiter to complete
|
|
|
|
startTime := time.Now()
|
|
|
|
for conn.HasWaiter.Load() {
|
|
|
|
time.Sleep(10 * time.Millisecond)
|
|
|
|
if time.Since(startTime) > 2*time.Second {
|
|
|
|
return fmt.Errorf("timeout waiting for waiter to complete")
|
|
|
|
}
|
|
|
|
}
|
|
|
|
return nil
|
|
|
|
}
|
|
|
|
|
|
|
|
func (conn *SSHConn) close_nolock() {
|
|
|
|
// does not set status (that should happen at another level)
|
2024-08-19 06:26:44 +02:00
|
|
|
if conn.DomainSockListener != nil {
|
|
|
|
conn.DomainSockListener.Close()
|
|
|
|
conn.DomainSockListener = nil
|
|
|
|
}
|
|
|
|
if conn.ConnController != nil {
|
|
|
|
conn.ConnController.Close()
|
|
|
|
conn.ConnController = nil
|
|
|
|
}
|
2024-08-24 03:12:40 +02:00
|
|
|
if conn.Client != nil {
|
|
|
|
conn.Client.Close()
|
|
|
|
conn.Client = nil
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
func (conn *SSHConn) GetDomainSocketName() string {
|
|
|
|
conn.Lock.Lock()
|
|
|
|
defer conn.Lock.Unlock()
|
|
|
|
return conn.SockName
|
|
|
|
}
|
|
|
|
|
|
|
|
func (conn *SSHConn) GetStatus() string {
|
|
|
|
conn.Lock.Lock()
|
|
|
|
defer conn.Lock.Unlock()
|
|
|
|
return conn.Status
|
|
|
|
}
|
|
|
|
|
|
|
|
func (conn *SSHConn) GetName() string {
|
|
|
|
// no lock required because opts is immutable
|
|
|
|
return conn.Opts.String()
|
2024-08-19 06:26:44 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
func (conn *SSHConn) OpenDomainSocketListener() error {
|
2024-08-24 03:12:40 +02:00
|
|
|
var allowed bool
|
|
|
|
conn.WithLock(func() {
|
|
|
|
if conn.Status != Status_Connecting {
|
|
|
|
allowed = false
|
|
|
|
} else {
|
|
|
|
allowed = true
|
|
|
|
}
|
|
|
|
})
|
|
|
|
if !allowed {
|
|
|
|
return fmt.Errorf("cannot open domain socket for %q when status is %q", conn.GetName(), conn.GetStatus())
|
2024-08-19 06:26:44 +02:00
|
|
|
}
|
2024-08-24 03:12:40 +02:00
|
|
|
client := conn.GetClient()
|
2024-08-19 06:26:44 +02:00
|
|
|
randStr, err := utilfn.RandomHexString(16) // 64-bits of randomness
|
|
|
|
if err != nil {
|
|
|
|
return fmt.Errorf("error generating random string: %w", err)
|
|
|
|
}
|
|
|
|
sockName := fmt.Sprintf("/tmp/waveterm-%s.sock", randStr)
|
2024-09-05 09:21:08 +02:00
|
|
|
log.Printf("remote domain socket %s %q\n", conn.GetName(), conn.GetDomainSocketName())
|
2024-08-24 03:12:40 +02:00
|
|
|
listener, err := client.ListenUnix(sockName)
|
2024-08-19 06:26:44 +02:00
|
|
|
if err != nil {
|
|
|
|
return fmt.Errorf("unable to request connection domain socket: %v", err)
|
|
|
|
}
|
2024-08-24 03:12:40 +02:00
|
|
|
conn.WithLock(func() {
|
|
|
|
conn.SockName = sockName
|
|
|
|
conn.DomainSockListener = listener
|
|
|
|
})
|
2024-08-19 06:26:44 +02:00
|
|
|
go func() {
|
2024-08-24 03:12:40 +02:00
|
|
|
defer conn.WithLock(func() {
|
2024-08-19 06:26:44 +02:00
|
|
|
conn.DomainSockListener = nil
|
2024-08-24 03:12:40 +02:00
|
|
|
conn.SockName = ""
|
|
|
|
})
|
2024-08-19 06:26:44 +02:00
|
|
|
wshutil.RunWshRpcOverListener(listener)
|
|
|
|
}()
|
|
|
|
return nil
|
|
|
|
}
|
|
|
|
|
|
|
|
func (conn *SSHConn) StartConnServer() error {
|
2024-08-24 03:12:40 +02:00
|
|
|
var allowed bool
|
|
|
|
conn.WithLock(func() {
|
|
|
|
if conn.Status != Status_Connecting {
|
|
|
|
allowed = false
|
|
|
|
} else {
|
|
|
|
allowed = true
|
|
|
|
}
|
|
|
|
})
|
|
|
|
if !allowed {
|
|
|
|
return fmt.Errorf("cannot start conn server for %q when status is %q", conn.GetName(), conn.GetStatus())
|
2024-08-19 06:26:44 +02:00
|
|
|
}
|
2024-08-24 03:12:40 +02:00
|
|
|
client := conn.GetClient()
|
|
|
|
wshPath := remote.GetWshPath(client)
|
2024-08-19 06:26:44 +02:00
|
|
|
rpcCtx := wshrpc.RpcContext{
|
2024-08-20 23:56:48 +02:00
|
|
|
ClientType: wshrpc.ClientType_ConnServer,
|
2024-08-24 03:12:40 +02:00
|
|
|
Conn: conn.GetName(),
|
2024-08-19 06:26:44 +02:00
|
|
|
}
|
2024-08-24 03:12:40 +02:00
|
|
|
sockName := conn.GetDomainSocketName()
|
|
|
|
jwtToken, err := wshutil.MakeClientJWTToken(rpcCtx, sockName)
|
2024-08-19 06:26:44 +02:00
|
|
|
if err != nil {
|
|
|
|
return fmt.Errorf("unable to create jwt token for conn controller: %w", err)
|
|
|
|
}
|
2024-08-24 03:12:40 +02:00
|
|
|
sshSession, err := client.NewSession()
|
2024-08-19 06:26:44 +02:00
|
|
|
if err != nil {
|
|
|
|
return fmt.Errorf("unable to create ssh session for conn controller: %w", err)
|
|
|
|
}
|
|
|
|
pipeRead, pipeWrite := io.Pipe()
|
|
|
|
sshSession.Stdout = pipeWrite
|
|
|
|
sshSession.Stderr = pipeWrite
|
2024-09-04 11:13:00 +02:00
|
|
|
shellPath, err := remote.DetectShell(client)
|
|
|
|
if err != nil {
|
|
|
|
return err
|
|
|
|
}
|
|
|
|
var cmdStr string
|
|
|
|
if remote.IsPowershell(shellPath) {
|
|
|
|
cmdStr = fmt.Sprintf("$env:%s=\"%s\"; %s connserver", wshutil.WaveJwtTokenVarName, jwtToken, wshPath)
|
|
|
|
} else {
|
|
|
|
cmdStr = fmt.Sprintf("%s=\"%s\" %s connserver", wshutil.WaveJwtTokenVarName, jwtToken, wshPath)
|
|
|
|
}
|
2024-08-19 06:26:44 +02:00
|
|
|
log.Printf("starting conn controller: %s\n", cmdStr)
|
|
|
|
err = sshSession.Start(cmdStr)
|
|
|
|
if err != nil {
|
|
|
|
return fmt.Errorf("unable to start conn controller: %w", err)
|
|
|
|
}
|
2024-08-24 03:12:40 +02:00
|
|
|
conn.WithLock(func() {
|
|
|
|
conn.ConnController = sshSession
|
|
|
|
})
|
2024-08-19 06:26:44 +02:00
|
|
|
// service the I/O
|
|
|
|
go func() {
|
|
|
|
// wait for termination, clear the controller
|
2024-08-24 03:12:40 +02:00
|
|
|
defer conn.WithLock(func() {
|
|
|
|
conn.ConnController = nil
|
|
|
|
})
|
2024-08-19 06:26:44 +02:00
|
|
|
waitErr := sshSession.Wait()
|
2024-08-24 03:12:40 +02:00
|
|
|
log.Printf("conn controller (%q) terminated: %v", conn.GetName(), waitErr)
|
2024-08-19 06:26:44 +02:00
|
|
|
}()
|
|
|
|
go func() {
|
|
|
|
readErr := wshutil.StreamToLines(pipeRead, func(line []byte) {
|
|
|
|
lineStr := string(line)
|
|
|
|
if !strings.HasSuffix(lineStr, "\n") {
|
|
|
|
lineStr += "\n"
|
|
|
|
}
|
2024-08-24 03:12:40 +02:00
|
|
|
log.Printf("[conncontroller:%s:output] %s", conn.GetName(), lineStr)
|
2024-08-19 06:26:44 +02:00
|
|
|
})
|
|
|
|
if readErr != nil && readErr != io.EOF {
|
2024-08-24 03:12:40 +02:00
|
|
|
log.Printf("[conncontroller:%s] error reading output: %v\n", conn.GetName(), readErr)
|
2024-08-19 06:26:44 +02:00
|
|
|
}
|
|
|
|
}()
|
2024-09-05 09:21:08 +02:00
|
|
|
regCtx, cancelFn := context.WithTimeout(context.Background(), 5*time.Second)
|
|
|
|
defer cancelFn()
|
|
|
|
err = wshutil.DefaultRouter.WaitForRegister(regCtx, wshutil.MakeConnectionRouteId(rpcCtx.Conn))
|
|
|
|
if err != nil {
|
|
|
|
return fmt.Errorf("timeout waiting for connserver to register")
|
|
|
|
}
|
|
|
|
time.Sleep(300 * time.Millisecond) // TODO remove this sleep (but we need to wait until connserver is "ready")
|
2024-08-19 06:26:44 +02:00
|
|
|
return nil
|
|
|
|
}
|
|
|
|
|
2024-09-04 07:15:02 +02:00
|
|
|
type WshInstallOpts struct {
|
|
|
|
Force bool
|
|
|
|
NoUserPrompt bool
|
|
|
|
}
|
|
|
|
|
|
|
|
func (conn *SSHConn) CheckAndInstallWsh(ctx context.Context, clientDisplayName string, opts *WshInstallOpts) error {
|
|
|
|
if opts == nil {
|
|
|
|
opts = &WshInstallOpts{}
|
|
|
|
}
|
2024-08-24 03:12:40 +02:00
|
|
|
client := conn.GetClient()
|
|
|
|
if client == nil {
|
|
|
|
return fmt.Errorf("client is nil")
|
|
|
|
}
|
2024-08-19 06:26:44 +02:00
|
|
|
// check that correct wsh extensions are installed
|
|
|
|
expectedVersion := fmt.Sprintf("wsh v%s", wavebase.WaveVersion)
|
|
|
|
clientVersion, err := remote.GetWshVersion(client)
|
2024-09-04 07:15:02 +02:00
|
|
|
if err == nil && clientVersion == expectedVersion && !opts.Force {
|
2024-08-19 06:26:44 +02:00
|
|
|
return nil
|
|
|
|
}
|
|
|
|
var queryText string
|
|
|
|
var title string
|
2024-09-04 07:15:02 +02:00
|
|
|
if opts.Force {
|
|
|
|
queryText = fmt.Sprintf("ReInstalling Wave Shell Extensions (%s) on `%s`\n", wavebase.WaveVersion, clientDisplayName)
|
|
|
|
title = "Install Wave Shell Extensions"
|
|
|
|
} else if err != nil {
|
2024-09-02 21:34:49 +02:00
|
|
|
queryText = fmt.Sprintf("Wave requires Wave Shell Extensions to be \n"+
|
|
|
|
"installed on `%s` \n"+
|
|
|
|
"to ensure a seamless experience. \n\n"+
|
|
|
|
"Would you like to install them?", clientDisplayName)
|
|
|
|
title = "Install Wave Shell Extensions"
|
2024-08-19 06:26:44 +02:00
|
|
|
} else {
|
2024-09-02 21:34:49 +02:00
|
|
|
queryText = fmt.Sprintf("Wave requires the Wave Shell Extensions \n"+
|
|
|
|
"installed on `%s` \n"+
|
|
|
|
"to be updated from %s to %s. \n\n"+
|
|
|
|
"Would you like to update?", clientDisplayName, clientVersion, expectedVersion)
|
|
|
|
title = "Update Wave Shell Extensions"
|
2024-08-19 06:26:44 +02:00
|
|
|
}
|
2024-09-04 07:15:02 +02:00
|
|
|
if !opts.NoUserPrompt {
|
|
|
|
request := &userinput.UserInputRequest{
|
|
|
|
ResponseType: "confirm",
|
|
|
|
QueryText: queryText,
|
|
|
|
Title: title,
|
|
|
|
Markdown: true,
|
|
|
|
CheckBoxMsg: "Don't show me this again",
|
|
|
|
}
|
|
|
|
response, err := userinput.GetUserInput(ctx, request)
|
|
|
|
if err != nil || !response.Confirm {
|
|
|
|
return err
|
|
|
|
}
|
2024-08-19 06:26:44 +02:00
|
|
|
}
|
2024-09-02 21:34:49 +02:00
|
|
|
log.Printf("attempting to install wsh to `%s`", clientDisplayName)
|
2024-08-19 06:26:44 +02:00
|
|
|
clientOs, err := remote.GetClientOs(client)
|
|
|
|
if err != nil {
|
|
|
|
return err
|
|
|
|
}
|
|
|
|
clientArch, err := remote.GetClientArch(client)
|
|
|
|
if err != nil {
|
|
|
|
return err
|
|
|
|
}
|
|
|
|
// attempt to install extension
|
|
|
|
wshLocalPath := shellutil.GetWshBinaryPath(wavebase.WaveVersion, clientOs, clientArch)
|
|
|
|
err = remote.CpHostToRemote(client, wshLocalPath, "~/.waveterm/bin/wsh")
|
|
|
|
if err != nil {
|
|
|
|
return err
|
|
|
|
}
|
2024-08-24 03:12:40 +02:00
|
|
|
log.Printf("successfully installed wsh on %s\n", conn.GetName())
|
2024-08-19 06:26:44 +02:00
|
|
|
return nil
|
|
|
|
}
|
|
|
|
|
2024-08-24 03:12:40 +02:00
|
|
|
func (conn *SSHConn) GetClient() *ssh.Client {
|
|
|
|
conn.Lock.Lock()
|
|
|
|
defer conn.Lock.Unlock()
|
|
|
|
return conn.Client
|
|
|
|
}
|
2024-08-19 06:26:44 +02:00
|
|
|
|
2024-08-24 03:12:40 +02:00
|
|
|
func (conn *SSHConn) Reconnect(ctx context.Context) error {
|
|
|
|
err := conn.Close()
|
|
|
|
if err != nil {
|
|
|
|
return err
|
2024-08-19 06:26:44 +02:00
|
|
|
}
|
2024-08-24 03:12:40 +02:00
|
|
|
return conn.Connect(ctx)
|
|
|
|
}
|
2024-08-19 06:26:44 +02:00
|
|
|
|
2024-09-04 08:04:19 +02:00
|
|
|
func (conn *SSHConn) WaitForConnect(ctx context.Context) error {
|
|
|
|
for {
|
|
|
|
status := conn.DeriveConnStatus()
|
|
|
|
if status.Status == Status_Connected {
|
|
|
|
return nil
|
|
|
|
}
|
|
|
|
if status.Status == Status_Connecting {
|
|
|
|
select {
|
|
|
|
case <-ctx.Done():
|
|
|
|
return fmt.Errorf("context timeout")
|
|
|
|
case <-time.After(100 * time.Millisecond):
|
|
|
|
continue
|
|
|
|
}
|
|
|
|
}
|
|
|
|
if status.Status == Status_Init || status.Status == Status_Disconnected {
|
|
|
|
return fmt.Errorf("disconnected")
|
|
|
|
}
|
|
|
|
if status.Status == Status_Error {
|
|
|
|
return fmt.Errorf("error: %v", status.Error)
|
|
|
|
}
|
|
|
|
return fmt.Errorf("unknown status: %q", status.Status)
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2024-08-24 03:12:40 +02:00
|
|
|
// does not return an error since that error is stored inside of SSHConn
|
|
|
|
func (conn *SSHConn) Connect(ctx context.Context) error {
|
|
|
|
var connectAllowed bool
|
|
|
|
conn.WithLock(func() {
|
|
|
|
if conn.Status == Status_Connecting || conn.Status == Status_Connected {
|
|
|
|
connectAllowed = false
|
|
|
|
} else {
|
|
|
|
conn.Status = Status_Connecting
|
|
|
|
conn.Error = ""
|
|
|
|
connectAllowed = true
|
|
|
|
}
|
|
|
|
})
|
2024-09-05 09:21:08 +02:00
|
|
|
log.Printf("Connect %s\n", conn.GetName())
|
2024-08-24 03:12:40 +02:00
|
|
|
if !connectAllowed {
|
|
|
|
return fmt.Errorf("cannot connect to %q when status is %q", conn.GetName(), conn.GetStatus())
|
|
|
|
}
|
|
|
|
conn.FireConnChangeEvent()
|
|
|
|
err := conn.connectInternal(ctx)
|
|
|
|
conn.WithLock(func() {
|
|
|
|
if err != nil {
|
|
|
|
conn.Status = Status_Error
|
|
|
|
conn.Error = err.Error()
|
|
|
|
conn.close_nolock()
|
|
|
|
} else {
|
|
|
|
conn.Status = Status_Connected
|
2024-09-04 07:15:02 +02:00
|
|
|
conn.LastConnectTime = time.Now().UnixMilli()
|
2024-09-06 08:09:30 +02:00
|
|
|
if conn.ActiveConnNum == 0 {
|
|
|
|
conn.ActiveConnNum = int(activeConnCounter.Add(1))
|
|
|
|
}
|
2024-08-24 03:12:40 +02:00
|
|
|
}
|
|
|
|
})
|
|
|
|
conn.FireConnChangeEvent()
|
|
|
|
return err
|
|
|
|
}
|
|
|
|
|
|
|
|
func (conn *SSHConn) WithLock(fn func()) {
|
|
|
|
conn.Lock.Lock()
|
|
|
|
defer conn.Lock.Unlock()
|
|
|
|
fn()
|
|
|
|
}
|
|
|
|
|
|
|
|
func (conn *SSHConn) connectInternal(ctx context.Context) error {
|
|
|
|
client, err := remote.ConnectToClient(ctx, conn.Opts) //todo specify or remove opts
|
2024-08-19 06:26:44 +02:00
|
|
|
if err != nil {
|
2024-09-30 21:32:22 +02:00
|
|
|
log.Printf("error: failed to connect to client %s: %v\n", conn.GetName(), err)
|
2024-08-24 03:12:40 +02:00
|
|
|
return err
|
2024-08-19 06:26:44 +02:00
|
|
|
}
|
2024-09-02 21:34:49 +02:00
|
|
|
fmtAddr := knownhosts.Normalize(fmt.Sprintf("%s@%s", client.User(), client.RemoteAddr().String()))
|
|
|
|
clientDisplayName := fmt.Sprintf("%s (%s)", conn.GetName(), fmtAddr)
|
2024-08-24 03:12:40 +02:00
|
|
|
conn.WithLock(func() {
|
|
|
|
conn.Client = client
|
|
|
|
})
|
2024-08-19 06:26:44 +02:00
|
|
|
err = conn.OpenDomainSocketListener()
|
|
|
|
if err != nil {
|
2024-09-30 21:32:22 +02:00
|
|
|
log.Printf("error: unable to open domain socket listener for %s: %v\n", conn.GetName(), err)
|
2024-08-24 03:12:40 +02:00
|
|
|
return err
|
2024-08-19 06:26:44 +02:00
|
|
|
}
|
2024-09-04 07:15:02 +02:00
|
|
|
installErr := conn.CheckAndInstallWsh(ctx, clientDisplayName, nil)
|
2024-08-19 06:26:44 +02:00
|
|
|
if installErr != nil {
|
2024-09-30 21:32:22 +02:00
|
|
|
log.Printf("error: unable to install wsh shell extensions for %s: %v\n", conn.GetName(), err)
|
2024-08-24 03:12:40 +02:00
|
|
|
return fmt.Errorf("conncontroller %s wsh install error: %v", conn.GetName(), installErr)
|
2024-08-19 06:26:44 +02:00
|
|
|
}
|
|
|
|
csErr := conn.StartConnServer()
|
|
|
|
if csErr != nil {
|
2024-09-30 21:32:22 +02:00
|
|
|
log.Printf("error: unable to start conn server for %s: %v\n", conn.GetName(), csErr)
|
2024-08-24 03:12:40 +02:00
|
|
|
return fmt.Errorf("conncontroller %s start wsh connserver error: %v", conn.GetName(), csErr)
|
2024-08-19 06:26:44 +02:00
|
|
|
}
|
2024-08-24 03:12:40 +02:00
|
|
|
conn.HasWaiter.Store(true)
|
|
|
|
go conn.waitForDisconnect()
|
|
|
|
return nil
|
|
|
|
}
|
2024-08-19 06:26:44 +02:00
|
|
|
|
2024-08-24 03:12:40 +02:00
|
|
|
func (conn *SSHConn) waitForDisconnect() {
|
|
|
|
defer conn.FireConnChangeEvent()
|
|
|
|
defer conn.HasWaiter.Store(false)
|
|
|
|
client := conn.GetClient()
|
|
|
|
if client == nil {
|
|
|
|
return
|
|
|
|
}
|
|
|
|
err := client.Wait()
|
|
|
|
conn.WithLock(func() {
|
2024-09-04 07:15:02 +02:00
|
|
|
// disconnects happen for a variety of reasons (like network, etc. and are typically transient)
|
|
|
|
// so we just set the status to "disconnected" here (not error)
|
|
|
|
// don't overwrite any existing error (or error status)
|
|
|
|
if err != nil && conn.Error == "" {
|
|
|
|
conn.Error = err.Error()
|
|
|
|
}
|
|
|
|
if conn.Status != Status_Error {
|
2024-08-24 03:12:40 +02:00
|
|
|
conn.Status = Status_Disconnected
|
|
|
|
}
|
|
|
|
conn.close_nolock()
|
|
|
|
})
|
2024-08-19 06:26:44 +02:00
|
|
|
}
|
|
|
|
|
2024-08-24 03:12:40 +02:00
|
|
|
func getConnInternal(opts *remote.SSHOpts) *SSHConn {
|
2024-08-19 06:26:44 +02:00
|
|
|
globalLock.Lock()
|
|
|
|
defer globalLock.Unlock()
|
2024-08-24 03:12:40 +02:00
|
|
|
rtn := clientControllerMap[*opts]
|
|
|
|
if rtn == nil {
|
|
|
|
rtn = &SSHConn{Lock: &sync.Mutex{}, Status: Status_Init, Opts: opts, HasWaiter: &atomic.Bool{}}
|
|
|
|
clientControllerMap[*opts] = rtn
|
|
|
|
}
|
|
|
|
return rtn
|
|
|
|
}
|
|
|
|
|
|
|
|
func GetConn(ctx context.Context, opts *remote.SSHOpts, shouldConnect bool) *SSHConn {
|
|
|
|
conn := getConnInternal(opts)
|
|
|
|
if conn.Client == nil && shouldConnect {
|
|
|
|
conn.Connect(ctx)
|
|
|
|
}
|
|
|
|
return conn
|
|
|
|
}
|
|
|
|
|
2024-09-02 21:34:49 +02:00
|
|
|
// Convenience function for ensuring a connection is established
|
2024-09-05 09:21:08 +02:00
|
|
|
func EnsureConnection(ctx context.Context, connName string) error {
|
|
|
|
if connName == "" {
|
2024-09-02 21:34:49 +02:00
|
|
|
return nil
|
|
|
|
}
|
2024-09-05 09:21:08 +02:00
|
|
|
connOpts, err := remote.ParseOpts(connName)
|
2024-09-02 21:34:49 +02:00
|
|
|
if err != nil {
|
2024-09-05 09:21:08 +02:00
|
|
|
return fmt.Errorf("error parsing connection name: %w", err)
|
2024-09-02 21:34:49 +02:00
|
|
|
}
|
2024-09-05 09:21:08 +02:00
|
|
|
conn := GetConn(ctx, connOpts, false)
|
|
|
|
if conn == nil {
|
|
|
|
return fmt.Errorf("connection not found: %s", connName)
|
|
|
|
}
|
|
|
|
connStatus := conn.DeriveConnStatus()
|
|
|
|
switch connStatus.Status {
|
|
|
|
case Status_Connected:
|
|
|
|
return nil
|
|
|
|
case Status_Connecting:
|
|
|
|
return conn.WaitForConnect(ctx)
|
|
|
|
case Status_Init, Status_Disconnected:
|
|
|
|
return conn.Connect(ctx)
|
|
|
|
case Status_Error:
|
|
|
|
return fmt.Errorf("connection error: %s", connStatus.Error)
|
|
|
|
default:
|
|
|
|
return fmt.Errorf("unknown connection status %q", connStatus.Status)
|
2024-09-02 21:34:49 +02:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2024-08-24 03:12:40 +02:00
|
|
|
func DisconnectClient(opts *remote.SSHOpts) error {
|
|
|
|
conn := getConnInternal(opts)
|
|
|
|
if conn == nil {
|
|
|
|
return fmt.Errorf("client %q not found", opts.String())
|
|
|
|
}
|
|
|
|
err := conn.Close()
|
|
|
|
return err
|
|
|
|
}
|
|
|
|
|
|
|
|
func resolveSshConfigPatterns(configFiles []string) ([]string, error) {
|
|
|
|
// using two separate containers to track order and have O(1) lookups
|
|
|
|
// since go does not have an ordered map primitive
|
|
|
|
var discoveredPatterns []string
|
|
|
|
alreadyUsed := make(map[string]bool)
|
|
|
|
alreadyUsed[""] = true // this excludes the empty string from potential alias
|
|
|
|
var openedFiles []fs.File
|
|
|
|
|
|
|
|
defer func() {
|
|
|
|
for _, openedFile := range openedFiles {
|
|
|
|
openedFile.Close()
|
|
|
|
}
|
|
|
|
}()
|
|
|
|
|
|
|
|
var errs []error
|
|
|
|
for _, configFile := range configFiles {
|
|
|
|
fd, openErr := os.Open(configFile)
|
|
|
|
openedFiles = append(openedFiles, fd)
|
|
|
|
if fd == nil {
|
|
|
|
errs = append(errs, openErr)
|
|
|
|
continue
|
|
|
|
}
|
2024-08-19 06:26:44 +02:00
|
|
|
|
2024-08-24 03:12:40 +02:00
|
|
|
cfg, _ := ssh_config.Decode(fd)
|
|
|
|
for _, host := range cfg.Hosts {
|
|
|
|
// for each host, find the first good alias
|
|
|
|
for _, hostPattern := range host.Patterns {
|
|
|
|
hostPatternStr := hostPattern.String()
|
2024-09-06 02:02:44 +02:00
|
|
|
normalized := remote.NormalizeConfigPattern(hostPatternStr)
|
|
|
|
if (!strings.Contains(hostPatternStr, "*") && !strings.Contains(hostPatternStr, "?") && !strings.Contains(hostPatternStr, "!")) || alreadyUsed[normalized] {
|
|
|
|
discoveredPatterns = append(discoveredPatterns, normalized)
|
|
|
|
alreadyUsed[normalized] = true
|
2024-08-24 03:12:40 +02:00
|
|
|
break
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
2024-08-19 06:26:44 +02:00
|
|
|
}
|
2024-08-24 03:12:40 +02:00
|
|
|
if len(errs) == len(configFiles) {
|
2024-09-06 02:02:44 +02:00
|
|
|
errs = append([]error{fmt.Errorf("no ssh config files could be opened: ")}, errs...)
|
2024-08-24 03:12:40 +02:00
|
|
|
return nil, errors.Join(errs...)
|
|
|
|
}
|
|
|
|
if len(discoveredPatterns) == 0 {
|
|
|
|
return nil, fmt.Errorf("no compatible hostnames found in ssh config files")
|
|
|
|
}
|
|
|
|
|
|
|
|
return discoveredPatterns, nil
|
|
|
|
}
|
|
|
|
|
2024-09-06 02:02:44 +02:00
|
|
|
func GetConnectionsList() ([]string, error) {
|
|
|
|
existing := GetAllConnStatus()
|
|
|
|
var currentlyRunning []string
|
|
|
|
var hasConnected []string
|
|
|
|
|
|
|
|
// populate all lists
|
|
|
|
for _, stat := range existing {
|
|
|
|
if stat.Connected {
|
|
|
|
currentlyRunning = append(currentlyRunning, stat.Connection)
|
|
|
|
}
|
|
|
|
|
|
|
|
if stat.HasConnected {
|
|
|
|
hasConnected = append(hasConnected, stat.Connection)
|
|
|
|
}
|
|
|
|
}
|
|
|
|
fromConfig, err := GetConnectionsFromConfig()
|
|
|
|
if err != nil {
|
|
|
|
return nil, err
|
|
|
|
}
|
|
|
|
|
|
|
|
// sort into one final list and remove duplicates
|
|
|
|
alreadyUsed := make(map[string]struct{})
|
|
|
|
var connList []string
|
|
|
|
|
|
|
|
for _, subList := range [][]string{currentlyRunning, hasConnected, fromConfig} {
|
|
|
|
for _, pattern := range subList {
|
|
|
|
if _, used := alreadyUsed[pattern]; !used {
|
|
|
|
connList = append(connList, pattern)
|
|
|
|
alreadyUsed[pattern] = struct{}{}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
return connList, nil
|
|
|
|
}
|
|
|
|
|
2024-08-24 03:12:40 +02:00
|
|
|
func GetConnectionsFromConfig() ([]string, error) {
|
|
|
|
home := wavebase.GetHomeDir()
|
|
|
|
localConfig := filepath.Join(home, ".ssh", "config")
|
|
|
|
systemConfig := filepath.Join("/etc", "ssh", "config")
|
|
|
|
sshConfigFiles := []string{localConfig, systemConfig}
|
|
|
|
ssh_config.ReloadConfigs()
|
|
|
|
|
|
|
|
return resolveSshConfigPatterns(sshConfigFiles)
|
2024-08-19 06:26:44 +02:00
|
|
|
}
|