0
0
package loopback
import (
"cmp"
"context"
"errors"
"fmt"
"io"
"net"
"net/http"
"strings"
"sync"
"time"
"github.com/johnandersen777/socialweb-computer-kcp/internal/contract/component"
"github.com/johnandersen777/socialweb-computer-kcp/internal/contract/ingress"
)
const DefaultHost = "127.0.0.1"
type Config struct {
Host string
Protocol string
}
type Bridge struct {
cfg Config
target ingress.Target
listener net.Listener
server *http.Server
ctx context.Context
cancel context.CancelFunc
done chan struct{}
closeOnce sync.Once
conns sync.WaitGroup
}
func Start(ctx context.Context, cfg Config, target ingress.Target) (*Bridge, error) {
if target == nil {
return nil, errors.New("loopback: the target is not configured")
}
host := strings.TrimSpace(cfg.Host)
host = cmp.Or(host, DefaultHost)
listener, err := net.Listen("tcp", net.JoinHostPort(host, "0"))
if err != nil {
return nil, fmt.Errorf("loopback: listening on %s: %w", host, err)
}
ctx, cancel := context.WithCancel(ctx)
bridge := &Bridge{cfg: cfg, target: target, listener: listener, ctx: ctx, cancel: cancel, done: make(chan struct{})}
switch strings.ToLower(strings.TrimSpace(cfg.Protocol)) {
case component.ProtocolHTTP, component.ProtocolWS:
bridge.server = &http.Server{Handler: target, ReadHeaderTimeout: 10 * time.Second}
go func() {
defer close(bridge.done)
_ = bridge.server.Serve(listener)
}()
case component.ProtocolTCP, component.ProtocolSSH:
go bridge.serveStreams()
default:
cancel()
_ = listener.Close()
return nil, fmt.Errorf("loopback: unknown protocol %q", cfg.Protocol)
}
return bridge, nil
}
func (b *Bridge) Address() string {
return b.listener.Addr().String()
}
func (b *Bridge) serveStreams() {
defer close(b.done)
for {
conn, err := b.listener.Accept()
if err != nil {
return
}
b.conns.Go(func() { b.bridge(conn) })
}
}
func (b *Bridge) bridge(conn net.Conn) {
defer conn.Close()
stop := context.AfterFunc(b.ctx, func() { _ = conn.Close() })
defer stop()
stream, err := b.target.DialStream(b.ctx)
if err != nil {
return
}
defer stream.Close()
done := make(chan struct{}, 2)
go func() {
_, _ = io.Copy(stream, conn)
done <- struct{}{}
}()
go func() {
_, _ = io.Copy(conn, stream)
done <- struct{}{}
}()
<-done
_ = conn.Close()
_ = stream.Close()
<-done
}
func (b *Bridge) Close() error {
b.closeOnce.Do(func() {
b.cancel()
if b.server != nil {
_ = b.server.Close()
return
}
_ = b.listener.Close()
})
<-b.done
b.conns.Wait()
return nil
}