405 lines
10 KiB
Go
405 lines
10 KiB
Go
package mesh
|
|
|
|
import (
|
|
"bytes"
|
|
"context"
|
|
"encoding/json"
|
|
"fmt"
|
|
"net/http"
|
|
"net/url"
|
|
"strings"
|
|
"sync"
|
|
"time"
|
|
|
|
"github.com/example/remote-access-platform/agents/rap-node-agent/internal/fabricproto"
|
|
"github.com/gorilla/websocket"
|
|
)
|
|
|
|
type Client struct {
|
|
BaseURL string
|
|
HTTPClient *http.Client
|
|
}
|
|
|
|
type FabricSessionDialOptions struct {
|
|
Token string
|
|
Header http.Header
|
|
Dialer *websocket.Dialer
|
|
Timeout time.Duration
|
|
MaxPayload int
|
|
}
|
|
|
|
type FabricSessionClient struct {
|
|
conn *websocket.Conn
|
|
timeout time.Duration
|
|
maxPayload int
|
|
readMu sync.Mutex
|
|
writeMu sync.Mutex
|
|
}
|
|
|
|
type FabricSessionPumpOptions struct {
|
|
OutboundBuffer int
|
|
InboundBuffer int
|
|
ErrorBuffer int
|
|
}
|
|
|
|
type FabricSessionPump struct {
|
|
session *FabricSessionClient
|
|
outbound chan fabricproto.Frame
|
|
inbound chan fabricproto.Frame
|
|
errors chan error
|
|
done chan struct{}
|
|
cancel context.CancelFunc
|
|
closeMu sync.Once
|
|
}
|
|
|
|
func NewClient(baseURL string) Client {
|
|
return Client{
|
|
BaseURL: baseURL,
|
|
HTTPClient: &http.Client{
|
|
Timeout: 5 * time.Second,
|
|
},
|
|
}
|
|
}
|
|
|
|
func (c Client) SendHealth(ctx context.Context, message HealthMessage) (HealthAck, error) {
|
|
payload, err := json.Marshal(message)
|
|
if err != nil {
|
|
return HealthAck{}, err
|
|
}
|
|
req, err := http.NewRequestWithContext(ctx, http.MethodPost, c.BaseURL+"/mesh/v1/health", bytes.NewReader(payload))
|
|
if err != nil {
|
|
return HealthAck{}, err
|
|
}
|
|
req.Header.Set("Content-Type", "application/json")
|
|
httpClient := c.HTTPClient
|
|
if httpClient == nil {
|
|
httpClient = http.DefaultClient
|
|
}
|
|
resp, err := httpClient.Do(req)
|
|
if err != nil {
|
|
return HealthAck{}, err
|
|
}
|
|
defer resp.Body.Close()
|
|
if resp.StatusCode < 200 || resp.StatusCode >= 300 {
|
|
return HealthAck{}, fmt.Errorf("mesh health rejected with status %d", resp.StatusCode)
|
|
}
|
|
var ack HealthAck
|
|
if err := json.NewDecoder(resp.Body).Decode(&ack); err != nil {
|
|
return HealthAck{}, err
|
|
}
|
|
return ack, nil
|
|
}
|
|
|
|
func (c Client) SendSynthetic(ctx context.Context, envelope SyntheticEnvelope) (SyntheticEnvelope, error) {
|
|
payload, err := json.Marshal(envelope)
|
|
if err != nil {
|
|
return SyntheticEnvelope{}, err
|
|
}
|
|
req, err := http.NewRequestWithContext(ctx, http.MethodPost, c.BaseURL+"/mesh/v1/synthetic/probe", bytes.NewReader(payload))
|
|
if err != nil {
|
|
return SyntheticEnvelope{}, err
|
|
}
|
|
req.Header.Set("Content-Type", "application/json")
|
|
httpClient := c.HTTPClient
|
|
if httpClient == nil {
|
|
httpClient = http.DefaultClient
|
|
}
|
|
resp, err := httpClient.Do(req)
|
|
if err != nil {
|
|
return SyntheticEnvelope{}, err
|
|
}
|
|
defer resp.Body.Close()
|
|
if resp.StatusCode < 200 || resp.StatusCode >= 300 {
|
|
return SyntheticEnvelope{}, fmt.Errorf("mesh synthetic probe rejected with status %d", resp.StatusCode)
|
|
}
|
|
var ack SyntheticEnvelope
|
|
if err := json.NewDecoder(resp.Body).Decode(&ack); err != nil {
|
|
return SyntheticEnvelope{}, err
|
|
}
|
|
return ack, nil
|
|
}
|
|
|
|
func (c Client) SendProduction(ctx context.Context, envelope ProductionEnvelope) (ProductionForwardResult, error) {
|
|
payload, err := json.Marshal(envelope)
|
|
if err != nil {
|
|
return ProductionForwardResult{}, err
|
|
}
|
|
req, err := http.NewRequestWithContext(ctx, http.MethodPost, c.BaseURL+"/mesh/v1/forward", bytes.NewReader(payload))
|
|
if err != nil {
|
|
return ProductionForwardResult{}, err
|
|
}
|
|
req.Header.Set("Content-Type", "application/json")
|
|
httpClient := c.HTTPClient
|
|
if httpClient == nil {
|
|
httpClient = http.DefaultClient
|
|
}
|
|
resp, err := httpClient.Do(req)
|
|
if err != nil {
|
|
return ProductionForwardResult{}, err
|
|
}
|
|
defer resp.Body.Close()
|
|
if resp.StatusCode < 200 || resp.StatusCode >= 300 {
|
|
return ProductionForwardResult{}, fmt.Errorf("mesh production forward rejected with status %d", resp.StatusCode)
|
|
}
|
|
var result ProductionForwardResult
|
|
if err := json.NewDecoder(resp.Body).Decode(&result); err != nil {
|
|
return ProductionForwardResult{}, err
|
|
}
|
|
return result, nil
|
|
}
|
|
|
|
func (c Client) DialFabricSession(ctx context.Context, opts FabricSessionDialOptions) (*websocket.Conn, *http.Response, error) {
|
|
target, err := c.fabricSessionWebSocketURL()
|
|
if err != nil {
|
|
return nil, nil, err
|
|
}
|
|
header := cloneHeader(opts.Header)
|
|
if strings.TrimSpace(opts.Token) != "" {
|
|
header.Set("X-RAP-Fabric-Session-Token", strings.TrimSpace(opts.Token))
|
|
}
|
|
dialer := opts.Dialer
|
|
if dialer == nil {
|
|
base := *websocket.DefaultDialer
|
|
if opts.Timeout > 0 {
|
|
base.HandshakeTimeout = opts.Timeout
|
|
}
|
|
dialer = &base
|
|
}
|
|
return dialer.DialContext(ctx, target, header)
|
|
}
|
|
|
|
func (c Client) OpenFabricSession(ctx context.Context, opts FabricSessionDialOptions) (*FabricSessionClient, *http.Response, error) {
|
|
conn, resp, err := c.DialFabricSession(ctx, opts)
|
|
if err != nil {
|
|
if resp != nil {
|
|
return nil, resp, fmt.Errorf("fabric session websocket rejected with status %d: %w", resp.StatusCode, err)
|
|
}
|
|
return nil, resp, err
|
|
}
|
|
maxPayload := opts.MaxPayload
|
|
if maxPayload <= 0 {
|
|
maxPayload = fabricproto.DefaultMaxPayload
|
|
}
|
|
return &FabricSessionClient{
|
|
conn: conn,
|
|
timeout: opts.Timeout,
|
|
maxPayload: maxPayload,
|
|
}, resp, nil
|
|
}
|
|
|
|
func (c Client) SendFabricSessionFrame(ctx context.Context, opts FabricSessionDialOptions, frame fabricproto.Frame) (fabricproto.Frame, error) {
|
|
session, _, err := c.OpenFabricSession(ctx, opts)
|
|
if err != nil {
|
|
return fabricproto.Frame{}, err
|
|
}
|
|
defer session.Close()
|
|
return session.RoundTrip(ctx, frame)
|
|
}
|
|
|
|
func (c *FabricSessionClient) Close() error {
|
|
if c == nil || c.conn == nil {
|
|
return nil
|
|
}
|
|
return c.conn.Close()
|
|
}
|
|
|
|
func (c *FabricSessionClient) WriteFrame(ctx context.Context, frame fabricproto.Frame) error {
|
|
if c == nil || c.conn == nil {
|
|
return fmt.Errorf("fabric session client is closed")
|
|
}
|
|
payload, err := fabricproto.MarshalFrame(frame)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
c.writeMu.Lock()
|
|
defer c.writeMu.Unlock()
|
|
c.applyWriteDeadline(ctx)
|
|
return c.conn.WriteMessage(websocket.BinaryMessage, payload)
|
|
}
|
|
|
|
func (c *FabricSessionClient) ReadFrame(ctx context.Context) (fabricproto.Frame, error) {
|
|
if c == nil || c.conn == nil {
|
|
return fabricproto.Frame{}, fmt.Errorf("fabric session client is closed")
|
|
}
|
|
c.readMu.Lock()
|
|
defer c.readMu.Unlock()
|
|
c.applyReadDeadline(ctx)
|
|
messageType, responsePayload, err := c.conn.ReadMessage()
|
|
if err != nil {
|
|
return fabricproto.Frame{}, err
|
|
}
|
|
if messageType != websocket.BinaryMessage {
|
|
return fabricproto.Frame{}, fmt.Errorf("fabric session websocket returned non-binary message type %d", messageType)
|
|
}
|
|
return fabricproto.UnmarshalFrame(responsePayload, c.maxPayload)
|
|
}
|
|
|
|
func (c *FabricSessionClient) RoundTrip(ctx context.Context, frame fabricproto.Frame) (fabricproto.Frame, error) {
|
|
if err := c.WriteFrame(ctx, frame); err != nil {
|
|
return fabricproto.Frame{}, err
|
|
}
|
|
return c.ReadFrame(ctx)
|
|
}
|
|
|
|
func (c *FabricSessionClient) StartPump(ctx context.Context, opts FabricSessionPumpOptions) *FabricSessionPump {
|
|
if opts.OutboundBuffer <= 0 {
|
|
opts.OutboundBuffer = 64
|
|
}
|
|
if opts.InboundBuffer <= 0 {
|
|
opts.InboundBuffer = 64
|
|
}
|
|
if opts.ErrorBuffer <= 0 {
|
|
opts.ErrorBuffer = 8
|
|
}
|
|
pumpCtx, cancel := context.WithCancel(ctx)
|
|
pump := &FabricSessionPump{
|
|
session: c,
|
|
outbound: make(chan fabricproto.Frame, opts.OutboundBuffer),
|
|
inbound: make(chan fabricproto.Frame, opts.InboundBuffer),
|
|
errors: make(chan error, opts.ErrorBuffer),
|
|
done: make(chan struct{}),
|
|
cancel: cancel,
|
|
}
|
|
go pump.writeLoop(pumpCtx)
|
|
go pump.readLoop(pumpCtx)
|
|
return pump
|
|
}
|
|
|
|
func (p *FabricSessionPump) Send(ctx context.Context, frame fabricproto.Frame) error {
|
|
if p == nil {
|
|
return fmt.Errorf("fabric session pump is nil")
|
|
}
|
|
select {
|
|
case <-ctx.Done():
|
|
return ctx.Err()
|
|
case <-p.done:
|
|
return fmt.Errorf("fabric session pump is closed")
|
|
case p.outbound <- frame:
|
|
return nil
|
|
}
|
|
}
|
|
|
|
func (p *FabricSessionPump) Frames() <-chan fabricproto.Frame {
|
|
if p == nil {
|
|
return nil
|
|
}
|
|
return p.inbound
|
|
}
|
|
|
|
func (p *FabricSessionPump) Errors() <-chan error {
|
|
if p == nil {
|
|
return nil
|
|
}
|
|
return p.errors
|
|
}
|
|
|
|
func (p *FabricSessionPump) Close() error {
|
|
if p == nil {
|
|
return nil
|
|
}
|
|
var err error
|
|
p.closeMu.Do(func() {
|
|
close(p.done)
|
|
p.cancel()
|
|
err = p.session.Close()
|
|
})
|
|
return err
|
|
}
|
|
|
|
func (p *FabricSessionPump) writeLoop(ctx context.Context) {
|
|
defer p.Close()
|
|
for {
|
|
select {
|
|
case <-ctx.Done():
|
|
p.reportError(ctx.Err())
|
|
return
|
|
case <-p.done:
|
|
return
|
|
case frame := <-p.outbound:
|
|
if err := p.session.WriteFrame(ctx, frame); err != nil {
|
|
p.reportError(err)
|
|
return
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
func (p *FabricSessionPump) readLoop(ctx context.Context) {
|
|
defer p.Close()
|
|
for {
|
|
frame, err := p.session.ReadFrame(ctx)
|
|
if err != nil {
|
|
p.reportError(err)
|
|
return
|
|
}
|
|
select {
|
|
case <-ctx.Done():
|
|
p.reportError(ctx.Err())
|
|
return
|
|
case <-p.done:
|
|
return
|
|
case p.inbound <- frame:
|
|
}
|
|
}
|
|
}
|
|
|
|
func (p *FabricSessionPump) reportError(err error) {
|
|
if err == nil {
|
|
return
|
|
}
|
|
select {
|
|
case p.errors <- err:
|
|
default:
|
|
}
|
|
}
|
|
|
|
func (c *FabricSessionClient) applyReadDeadline(ctx context.Context) {
|
|
if deadline, ok := ctx.Deadline(); ok {
|
|
_ = c.conn.SetReadDeadline(deadline)
|
|
} else if c.timeout > 0 {
|
|
_ = c.conn.SetReadDeadline(time.Now().Add(c.timeout))
|
|
}
|
|
}
|
|
|
|
func (c *FabricSessionClient) applyWriteDeadline(ctx context.Context) {
|
|
if deadline, ok := ctx.Deadline(); ok {
|
|
_ = c.conn.SetWriteDeadline(deadline)
|
|
} else if c.timeout > 0 {
|
|
_ = c.conn.SetWriteDeadline(time.Now().Add(c.timeout))
|
|
}
|
|
}
|
|
|
|
func (c Client) fabricSessionWebSocketURL() (string, error) {
|
|
base := strings.TrimSpace(c.BaseURL)
|
|
if base == "" {
|
|
return "", fmt.Errorf("mesh base url is required")
|
|
}
|
|
parsed, err := url.Parse(base)
|
|
if err != nil {
|
|
return "", err
|
|
}
|
|
switch parsed.Scheme {
|
|
case "http":
|
|
parsed.Scheme = "ws"
|
|
case "https":
|
|
parsed.Scheme = "wss"
|
|
case "ws", "wss":
|
|
default:
|
|
return "", fmt.Errorf("unsupported mesh base url scheme %q", parsed.Scheme)
|
|
}
|
|
parsed.Path = strings.TrimRight(parsed.Path, "/") + "/mesh/v1/fabric/session/ws"
|
|
parsed.RawQuery = ""
|
|
parsed.Fragment = ""
|
|
return parsed.String(), nil
|
|
}
|
|
|
|
func cloneHeader(header http.Header) http.Header {
|
|
out := http.Header{}
|
|
for key, values := range header {
|
|
for _, value := range values {
|
|
out.Add(key, value)
|
|
}
|
|
}
|
|
return out
|
|
}
|