0
0
package sshserver
import (
"cmp"
"context"
"crypto/tls"
"errors"
"fmt"
"log/slog"
"net"
"net/http"
"strings"
"sync"
"time"
"github.com/bluesky-social/indigo/atproto/identity"
commonv1 "github.com/johnandersen777/socialweb-computer-kcp/api/common/v1alpha1"
"github.com/johnandersen777/socialweb-computer-kcp/api/v1alpha1"
"github.com/johnandersen777/socialweb-computer-kcp/internal/bus"
"github.com/johnandersen777/socialweb-computer-kcp/internal/component"
sshcontract "github.com/johnandersen777/socialweb-computer-kcp/internal/contract/ssh"
"github.com/johnandersen777/socialweb-computer-kcp/internal/kit/httpjson"
"github.com/johnandersen777/socialweb-computer-kcp/internal/kit/kcp"
opsreadsvc "github.com/johnandersen777/socialweb-computer-kcp/internal/services/opsread"
"github.com/johnandersen777/socialweb-computer-kcp/internal/ssh/gateway"
"github.com/johnandersen777/socialweb-computer-kcp/internal/ssh/ownersession"
"github.com/johnandersen777/socialweb-computer-kcp/internal/sshtransport"
)
type Service struct {
spec v1alpha1.SshServerSpec
deps Deps
cfg gateway.Config
log *slog.Logger
ownerSessions map[string]ownersession.Session
tls *tls.Config
trust *component.Trust
directory identity.Directory
mu sync.Mutex
started bool
ready bool
readiness component.ReadySignal
stopped bool
ctx context.Context
cancel context.CancelFunc
done chan struct{}
key component.Key
httpURL string
sshURL string
publicURL string
public net.Listener
webURL string
webServer *http.Server
web *webSignIn
perUser bool
gateway *gateway.Gateway
}
var (
_ component.Service = (*Service)(nil)
_ sshcontract.Runner = requester{}
)
type requester struct {
service *Service
ref commonv1.ObjectRef
}
func (r requester) RunCommand(ctx context.Context, account sshcontract.Account, command string, env map[string]string, io sshcontract.CommandIO) error {
s := r.service
if !s.perUser {
runner, err := s.resolveRequester(ctx, r.ref)
if err != nil {
return err
}
return runner.RunCommand(ctx, account, command, env, io)
}
asked := time.Now()
runner, err := s.resolveRequester(ctx, s.accountRequesterRef(account.DID))
waited := time.Since(asked).Milliseconds()
switch {
case errors.Is(err, bus.ErrLinkDenied):
s.log.Info("sshserver_account_not_signed_in", "did", account.DID)
_ = io.WriteErr([]byte("sign in at " + s.publicOrigin() + " first: this ssh gateway rents VMs as you, with your own atproto session, and has none for " + account.DID + " yet\n"))
io.Exit(1)
return nil
case err != nil:
s.log.Warn("sshserver_account_requester_unavailable", "did", account.DID, "waitedMs", waited, "err", err.Error())
_ = io.WriteErr([]byte("ssh gateway error: your requester is not available: " + err.Error() + "\n"))
io.Exit(1)
return nil
}
s.log.Info("sshserver_account_requester_ready", "did", account.DID, "waitedMs", waited)
return runner.RunCommand(ctx, account, command, env, io)
}
func (s *Service) resolveRequester(ctx context.Context, ref commonv1.ObjectRef) (sshcontract.Runner, error) {
runner, err := bus.Resolve[sshcontract.Runner](s.deps.Caller(ctx), s.deps.Bus, s.deps.Self, ref, runCapability())
if err != nil {
return nil, fmt.Errorf("sshserver: the Requester %s/%s: %w", ref.Workspace, ref.Name, err)
}
return runner, nil
}
func runCapability() bus.Capability {
return bus.Capability{Name: sshcontract.CapabilityRun, Scope: []string{sshcontract.ScopeRun}}
}
func (s *Service) Start(ctx context.Context) error {
s.mu.Lock()
if s.started {
s.mu.Unlock()
return errors.New("sshserver: the service is already started")
}
s.started = true
s.ready = false
s.done = make(chan struct{})
runCtx, cancel := context.WithCancel(ctx)
s.ctx = runCtx
s.cancel = cancel
s.mu.Unlock()
fail := func(err error) error {
cancel()
s.shutdown(ctx)
s.mu.Lock()
s.started = false
s.mu.Unlock()
close(s.done)
return err
}
stopTrust, err := s.trust.Follow(runCtx, s.deps.Instance)
if err != nil {
return fail(err)
}
defer stopTrust()
if err := s.setup(runCtx); err != nil {
return fail(err)
}
defer s.followVault(runCtx)()
key := s.deps.Key()
key.Kind = cmp.Or(key.Kind, Kind)
key.Name = cmp.Or(key.Name, "default")
key.Workspace = s.workspace()
handlers := s.deps.Bus
if handlers == nil {
return fail(errors.New("sshserver: no handler registry is available"))
}
host := kcp.KindServiceHost(key.Kind, key.Workspace)
httpURL := "http://" + host
sshURL := "ssh://" + host
if err := handlers.RegisterHTTP(key, s.handler()); err != nil {
return fail(fmt.Errorf("sshserver: registering the handler: %w", err))
}
stream := func(streamCtx context.Context, conn net.Conn) error {
return s.gateway.ServeConn(streamCtx, conn)
}
if err := handlers.RegisterStream(key, stream, "ssh"); err != nil {
handlers.Remove(key)
return fail(fmt.Errorf("sshserver: registering the stream: %w", err))
}
publicURL := ""
if addr := strings.TrimSpace(s.spec.PublicListen); addr != "" {
ln, err := net.Listen("tcp", addr)
if err != nil {
handlers.Remove(key)
return fail(fmt.Errorf("sshserver: the public ssh listener %s: %w", addr, err))
}
publicURL = "ssh://" + ln.Addr().String()
s.mu.Lock()
s.public = ln
s.mu.Unlock()
go s.servePublic(runCtx, ln)
}
webURL := ""
if addr := strings.TrimSpace(s.spec.WebListen); addr != "" {
ln, err := net.Listen("tcp", addr)
if err != nil {
handlers.Remove(key)
return fail(fmt.Errorf("sshserver: the web listener %s: %w", addr, err))
}
webURL = "http://" + ln.Addr().String()
srv := &http.Server{Handler: s.handler(), ReadHeaderTimeout: webReadHeaderTimeout}
s.mu.Lock()
s.webServer = srv
s.mu.Unlock()
go func() {
if err := srv.Serve(ln); err != nil && !errors.Is(err, http.ErrServerClosed) {
s.log.Warn("sshserver_web_serve_failed", "err", err)
}
}()
}
s.mu.Lock()
s.key = key
s.httpURL = httpURL
s.sshURL = sshURL
s.publicURL = publicURL
s.webURL = webURL
s.ready = true
s.mu.Unlock()
s.log.Info("sshserver_registered", "http", host, "ssh", host, "public", publicURL, "web", webURL)
s.readiness.Signal()
<-runCtx.Done()
s.shutdown(ctx)
close(s.done)
return nil
}
func (s *Service) servePublic(ctx context.Context, ln net.Listener) {
for {
conn, err := ln.Accept()
if err != nil {
if ctx.Err() != nil || errors.Is(err, net.ErrClosed) {
return
}
s.log.Warn("sshserver_public_accept_failed", "err", err)
select {
case <-ctx.Done():
return
case <-time.After(publicAcceptBackoff):
}
continue
}
go func() {
defer conn.Close()
if err := s.gateway.ServeConn(ctx, conn); err != nil && ctx.Err() == nil {
s.log.Info("sshserver_public_conn_closed", "err", err)
}
}()
}
}
func (s *Service) setup(ctx context.Context) error {
var ref commonv1.ObjectRef
if !s.perUser {
var err error
if ref, err = s.requesterRef(); err != nil {
return err
}
}
if err := s.awaitVault(ctx); err != nil {
return err
}
web, err := s.openSignIn(ctx)
if err != nil {
return err
}
if !s.perUser {
if _, err := s.resolveRequester(ctx, ref); err != nil {
return err
}
}
owners := ownersession.New(ownersession.Config{Sessions: s.ownerSessions}, ownersession.Deps{Open: s.openOwner})
var auth sshtransport.Authenticator = owners
var agents sshtransport.AgentProvider = owners
if web != nil {
auth, agents = liveAuth{s}, liveAgents{s}
}
g, err := gateway.New(s.cfg, gateway.Deps{
Runner: requester{service: s, ref: ref},
Directory: s.directory,
Trust: s.inProcess,
Client: s.httpClient(requestTimeout),
Auth: auth,
Agents: agents,
Log: s.log,
})
if err != nil {
web.close()
return err
}
s.mu.Lock()
s.gateway = g
s.web = web
s.mu.Unlock()
return nil
}
func (s *Service) handler() http.Handler {
mux := http.NewServeMux()
mux.HandleFunc("GET /healthz", s.health)
mux.HandleFunc("GET /connect.json", s.connect)
opsreadsvc.RegisterGateway(mux, s.deps.OpsSecret, s.deps.OpsHost, s.log)
mux.HandleFunc("GET /.well-known/cocore-app.json", s.cocoreApp)
if s.currentWeb() != nil {
for _, route := range oauthRoutes {
mux.HandleFunc(route, s.oauthRoute)
}
mux.HandleFunc("GET /{$}", s.page)
}
s.gateway.Register(mux)
return mux
}
func (s *Service) health(w http.ResponseWriter, r *http.Request) {
s.mu.Lock()
ready := s.ready
s.mu.Unlock()
if !ready {
httpjson.Write(w, http.StatusServiceUnavailable, map[string]any{"ok": false})
return
}
httpjson.Write(w, http.StatusOK, map[string]any{"ok": true})
}
func (s *Service) connect(w http.ResponseWriter, r *http.Request) {
httpjson.Write(w, http.StatusOK, map[string]any{"sshHost": s.cfg.Hostname})
}
func (s *Service) cocoreApp(w http.ResponseWriter, r *http.Request) {
if s.cfg.DID == "" {
httpjson.Write(w, http.StatusNotFound, map[string]any{"error": "NotFound"})
return
}
httpjson.Write(w, http.StatusOK, map[string]any{"did": s.cfg.DID})
}
func (s *Service) Ready() component.Readiness {
return &s.readiness
}
func (s *Service) Endpoints() []component.Endpoint {
s.mu.Lock()
defer s.mu.Unlock()
if s.httpURL == "" || s.sshURL == "" {
return nil
}
out := []component.Endpoint{
{Name: "http", Protocol: component.ProtocolHTTP, URL: s.httpURL},
{Name: "ssh", Protocol: component.ProtocolSSH, URL: s.sshURL},
}
if s.publicURL != "" {
out = append(out, component.Endpoint{Name: PublicEndpoint, Protocol: component.ProtocolSSH, URL: s.publicURL})
}
if s.webURL != "" {
out = append(out, component.Endpoint{Name: WebEndpoint, Protocol: component.ProtocolHTTP, URL: s.webURL})
}
return out
}
func (s *Service) Stop(ctx context.Context) error {
s.mu.Lock()
cancel := s.cancel
done := s.done
s.mu.Unlock()
if cancel == nil {
return nil
}
cancel()
if done == nil {
return nil
}
select {
case <-done:
return nil
case <-ctx.Done():
return ctx.Err()
}
}
func (s *Service) shutdown(ctx context.Context) {
s.mu.Lock()
if s.stopped {
s.mu.Unlock()
return
}
s.stopped = true
g := s.gateway
public := s.public
s.public = nil
web := s.web
s.web = nil
webServer := s.webServer
s.webServer = nil
s.mu.Unlock()
defer web.close()
if webServer != nil {
_ = webServer.Close()
}
if public != nil {
_ = public.Close()
}
stopCtx, cancel := context.WithTimeout(context.WithoutCancel(ctx), DefaultShutdownTimeout)
defer cancel()
if g != nil {
if err := g.Shutdown(stopCtx); err != nil {
s.log.Warn("sshserver_shutdown_failed", "err", err)
}
}
s.log.Info("sshserver_stopped")
s.mu.Lock()
s.started = false
s.ready = false
s.publicURL = ""
s.webURL = ""
s.mu.Unlock()
}