opensource/coder
3
0
Fork 0
mirror of https://github.com/coder/coder.git synced 2026-09-24 15:04:27 +08:00
Code Issues Packages Projects Releases Wiki Activity

feat: add coder connect exists hidden subcommand (#17418)

Browse Source 
Adds a new hidden subcommand `coder connect exists <hostname>` that checks if the name exists via Coder Connect. This will be used in SSH config to match only if Coder Connect is unavailable for the hostname in question, so that the SSH client will directly dial the workspace over an existing Coder Connect tunnel.

Also refactors the way we inject a test DNS resolver into the lookup functions so that we can test from outside the `workspacesdk` package.
This commit is contained in:
Spike Curtis
2025-04-17 11:23:24 +04:00
committed by GitHub
parent 6f5da1e2ee
commit 3b54254177
8 changed files with 242 additions and 98 deletions
Download Patch File Download Diff File Expand all files Collapse all files
codersdk/workspacesdk/workspacesdk.go
+30 -9
View File
@@ -20,11 +20,12 @@ import (
"cdr.dev/slog"
"github.com/coder/quartz"
"github.com/coder/websocket"
"github.com/coder/coder/v2/codersdk"
"github.com/coder/coder/v2/tailnet"
"github.com/coder/coder/v2/tailnet/proto"
"github.com/coder/quartz"
"github.com/coder/websocket"
)
var ErrSkipClose = xerrors.New("skip tailnet close")
@@ -128,19 +129,16 @@ func init() {
}
}
type resolver interface {
type Resolver interface {
LookupIP(ctx context.Context, network, host string) ([]net.IP, error)
}
type Client struct {
client *codersdk.Client
// overridden in tests
resolver resolver
}
func New(c *codersdk.Client) *Client {
return &Client{client: c, resolver: net.DefaultResolver}
return &Client{client: c}
}
// AgentConnectionInfo returns required information for establishing
@@ -392,6 +390,12 @@ func (c *Client) AgentReconnectingPTY(ctx context.Context, opts WorkspaceAgentRe
return websocket.NetConn(context.Background(), conn, websocket.MessageBinary), nil
}
func WithTestOnlyCoderContextResolver(ctx context.Context, r Resolver) context.Context {
return context.WithValue(ctx, dnsResolverContextKey{}, r)
}
type dnsResolverContextKey struct{}
type CoderConnectQueryOptions struct {
HostnameSuffix string
}
@@ -409,15 +413,32 @@ func (c *Client) IsCoderConnectRunning(ctx context.Context, o CoderConnectQueryO
suffix = info.HostnameSuffix
}
domainName := fmt.Sprintf(tailnet.IsCoderConnectEnabledFmtString, suffix)
return ExistsViaCoderConnect(ctx, domainName)
}
func testOrDefaultResolver(ctx context.Context) Resolver {
// check the context for a non-default resolver. This is only used in testing.
resolver, ok := ctx.Value(dnsResolverContextKey{}).(Resolver)
if !ok || resolver == nil {
resolver = net.DefaultResolver
}
return resolver
}
// ExistsViaCoderConnect checks if the given hostname exists via Coder Connect. This doesn't guarantee the
// workspace is actually reachable, if, for example, its agent is unhealthy, but rather that Coder Connect knows about
// the workspace and advertises the hostname via DNS.
func ExistsViaCoderConnect(ctx context.Context, hostname string) (bool, error) {
resolver := testOrDefaultResolver(ctx)
var dnsError *net.DNSError
ips, err := c.resolver.LookupIP(ctx, "ip6", domainName)
ips, err := resolver.LookupIP(ctx, "ip6", hostname)
if xerrors.As(err, &dnsError) {
if dnsError.IsNotFound {
return false, nil
}
}
if err != nil {
return false, xerrors.Errorf("lookup DNS %s: %w", domainName, err)
return false, xerrors.Errorf("lookup DNS %s: %w", hostname, err)
}
// The returned IP addresses are probably from the Coder Connect DNS server, but there are sometimes weird captive
codersdk/workspacesdk/workspacesdk_internal_test.go
-86
View File
@@ -1,86 +0,0 @@
package workspacesdk
import (
"context"
"fmt"
"net"
"net/http"
"net/http/httptest"
"net/url"
"testing"
"github.com/stretchr/testify/assert"
"github.com/stretchr/testify/require"
"golang.org/x/xerrors"
"github.com/coder/coder/v2/coderd/httpapi"
"github.com/coder/coder/v2/codersdk"
"github.com/coder/coder/v2/testutil"
"tailscale.com/net/tsaddr"
"github.com/coder/coder/v2/tailnet"
)
func TestClient_IsCoderConnectRunning(t *testing.T) {
t.Parallel()
ctx := testutil.Context(t, testutil.WaitShort)
srv := httptest.NewServer(http.HandlerFunc(func(rw http.ResponseWriter, r *http.Request) {
assert.Equal(t, "/api/v2/workspaceagents/connection", r.URL.Path)
httpapi.Write(ctx, rw, http.StatusOK, AgentConnectionInfo{
HostnameSuffix: "test",
})
}))
defer srv.Close()
apiURL, err := url.Parse(srv.URL)
require.NoError(t, err)
sdkClient := codersdk.New(apiURL)
client := New(sdkClient)
// Right name, right IP
expectedName := fmt.Sprintf(tailnet.IsCoderConnectEnabledFmtString, "test")
client.resolver = &fakeResolver{t: t, hostMap: map[string][]net.IP{
expectedName: {net.ParseIP(tsaddr.CoderServiceIPv6().String())},
}}
result, err := client.IsCoderConnectRunning(ctx, CoderConnectQueryOptions{})
require.NoError(t, err)
require.True(t, result)
// Wrong name
result, err = client.IsCoderConnectRunning(ctx, CoderConnectQueryOptions{HostnameSuffix: "coder"})
require.NoError(t, err)
require.False(t, result)
// Not found
client.resolver = &fakeResolver{t: t, err: &net.DNSError{IsNotFound: true}}
result, err = client.IsCoderConnectRunning(ctx, CoderConnectQueryOptions{})
require.NoError(t, err)
require.False(t, result)
// Some other error
client.resolver = &fakeResolver{t: t, err: xerrors.New("a bad thing happened")}
_, err = client.IsCoderConnectRunning(ctx, CoderConnectQueryOptions{})
require.Error(t, err)
// Right name, wrong IP
client.resolver = &fakeResolver{t: t, hostMap: map[string][]net.IP{
expectedName: {net.ParseIP("2001::34")},
}}
result, err = client.IsCoderConnectRunning(ctx, CoderConnectQueryOptions{})
require.NoError(t, err)
require.False(t, result)
}
type fakeResolver struct {
t testing.TB
hostMap map[string][]net.IP
err error
}
func (f *fakeResolver) LookupIP(_ context.Context, network, host string) ([]net.IP, error) {
assert.Equal(f.t, "ip6", network)
return f.hostMap[host], f.err
}
codersdk/workspacesdk/workspacesdk_test.go
+74
View File
@@ -1,12 +1,18 @@
package workspacesdk_test
import (
"context"
"fmt"
"net"
"net/http"
"net/http/httptest"
"net/url"
"testing"
"github.com/stretchr/testify/assert"
"github.com/stretchr/testify/require"
"golang.org/x/xerrors"
"tailscale.com/net/tsaddr"
"tailscale.com/tailcfg"
"github.com/coder/websocket"
@@ -15,6 +21,7 @@ import (
"github.com/coder/coder/v2/codersdk"
"github.com/coder/coder/v2/codersdk/agentsdk"
"github.com/coder/coder/v2/codersdk/workspacesdk"
"github.com/coder/coder/v2/tailnet"
"github.com/coder/coder/v2/testutil"
)
@@ -72,3 +79,70 @@ func TestWorkspaceDialerFailure(t *testing.T) {
// Then: an error indicating a database issue is returned, to conditionalize the behavior of the caller.
require.ErrorIs(t, err, codersdk.ErrDatabaseNotReachable)
}
func TestClient_IsCoderConnectRunning(t *testing.T) {
t.Parallel()
ctx := testutil.Context(t, testutil.WaitShort)
srv := httptest.NewServer(http.HandlerFunc(func(rw http.ResponseWriter, r *http.Request) {
assert.Equal(t, "/api/v2/workspaceagents/connection", r.URL.Path)
httpapi.Write(ctx, rw, http.StatusOK, workspacesdk.AgentConnectionInfo{
HostnameSuffix: "test",
})
}))
defer srv.Close()
apiURL, err := url.Parse(srv.URL)
require.NoError(t, err)
sdkClient := codersdk.New(apiURL)
client := workspacesdk.New(sdkClient)
// Right name, right IP
expectedName := fmt.Sprintf(tailnet.IsCoderConnectEnabledFmtString, "test")
ctxResolveExpected := workspacesdk.WithTestOnlyCoderContextResolver(ctx,
&fakeResolver{t: t, hostMap: map[string][]net.IP{
expectedName: {net.ParseIP(tsaddr.CoderServiceIPv6().String())},
}})
result, err := client.IsCoderConnectRunning(ctxResolveExpected, workspacesdk.CoderConnectQueryOptions{})
require.NoError(t, err)
require.True(t, result)
// Wrong name
result, err = client.IsCoderConnectRunning(ctxResolveExpected, workspacesdk.CoderConnectQueryOptions{HostnameSuffix: "coder"})
require.NoError(t, err)
require.False(t, result)
// Not found
ctxResolveNotFound := workspacesdk.WithTestOnlyCoderContextResolver(ctx,
&fakeResolver{t: t, err: &net.DNSError{IsNotFound: true}})
result, err = client.IsCoderConnectRunning(ctxResolveNotFound, workspacesdk.CoderConnectQueryOptions{})
require.NoError(t, err)
require.False(t, result)
// Some other error
ctxResolverErr := workspacesdk.WithTestOnlyCoderContextResolver(ctx,
&fakeResolver{t: t, err: xerrors.New("a bad thing happened")})
_, err = client.IsCoderConnectRunning(ctxResolverErr, workspacesdk.CoderConnectQueryOptions{})
require.Error(t, err)
// Right name, wrong IP
ctxResolverWrongIP := workspacesdk.WithTestOnlyCoderContextResolver(ctx,
&fakeResolver{t: t, hostMap: map[string][]net.IP{
expectedName: {net.ParseIP("2001::34")},
}})
result, err = client.IsCoderConnectRunning(ctxResolverWrongIP, workspacesdk.CoderConnectQueryOptions{})
require.NoError(t, err)
require.False(t, result)
}
type fakeResolver struct {
t testing.TB
hostMap map[string][]net.IP
err error
}
func (f *fakeResolver) LookupIP(_ context.Context, network, host string) ([]net.IP, error) {
assert.Equal(f.t, "ip6", network)
return f.hostMap[host], f.err
}