package transport import ( "bytes" "context" "crypto/hmac" "crypto/sha256" "encoding/hex" "encoding/json" "fmt" "io" "log" "net/http" "strings" "sync" "time" "synapse/pkg/types" ) // ============================================================================= // HTTP Transport // ============================================================================= // HTTPTransport implements HTTP-based transport for Synapse messages type HTTPTransport struct { mu sync.RWMutex // Configuration baseURL string timeout time.Duration maxRetries int retryDelay time.Duration // HTTP Client client *http.Client // Security authSecret string // Callbacks callbackEndpoint string callbackHandler MessageCallbackHandler } // HTTPTransportConfig holds HTTP transport configuration type HTTPTransportConfig struct { BaseURL string Timeout time.Duration MaxRetries int RetryDelay time.Duration AuthSecret string } // DefaultHTTPTransportConfig returns default HTTP transport configuration func DefaultHTTPTransportConfig() *HTTPTransportConfig { return &HTTPTransportConfig{ Timeout: 30 * time.Second, MaxRetries: 5, RetryDelay: 2 * time.Second, } } // NewHTTPTransport creates a new HTTP transport func NewHTTPTransport(config *HTTPTransportConfig) *HTTPTransport { if config == nil { config = DefaultHTTPTransportConfig() } t := &HTTPTransport{ baseURL: config.BaseURL, timeout: config.Timeout, maxRetries: config.MaxRetries, retryDelay: config.RetryDelay, authSecret: config.AuthSecret, client: &http.Client{ Timeout: config.Timeout, }, } return t } // SetCallbackHandler sets the handler for incoming callbacks func (t *HTTPTransport) SetCallbackHandler(handler MessageCallbackHandler) { t.callbackHandler = handler } // SetCallbackEndpoint sets the endpoint for receiving callbacks func (t *HTTPTransport) SetCallbackEndpoint(endpoint string) { t.callbackEndpoint = endpoint } // ============================================================================= // Message Sending // ============================================================================= // Send sends a message via HTTP POST func (t *HTTPTransport) Send(ctx context.Context, endpoint string, msg *types.UnifiedSynapseMessage) error { if endpoint == "" { return fmt.Errorf("endpoint is required") } // Add signature if secret is configured if t.authSecret != "" { t.signMessage(msg) } // Marshal message body, err := json.Marshal(msg) if err != nil { return fmt.Errorf("failed to marshal message: %w", err) } // Create request req, err := http.NewRequestWithContext(ctx, "POST", endpoint, bytes.NewReader(body)) if err != nil { return fmt.Errorf("failed to create request: %w", err) } // Set headers req.Header.Set("Content-Type", "application/json") req.Header.Set("X-Synapse-Version", "1.0.0") req.Header.Set("X-Synapse-Agent", msg.Sender.AgentID) req.Header.Set("X-Synapse-System", msg.Sender.SystemID) if msg.Signature != "" { req.Header.Set("X-Synapse-Signature", msg.Signature) } // Send with retries var lastErr error for i := 0; i < t.maxRetries; i++ { if i > 0 { delay := t.retryDelay * time.Duration(1<= 200 && resp.StatusCode < 300 { log.Printf("[Transport] Message sent successfully: %s to %s", msg.ID, endpoint) return nil } lastErr = fmt.Errorf("HTTP %d: %s", resp.StatusCode, string(respBody)) log.Printf("[Transport] Request failed: %v", lastErr) } return fmt.Errorf("failed to send message after %d retries: %w", t.maxRetries, lastErr) } // SendWithCallback sends a message and waits for callback response func (t *HTTPTransport) SendWithCallback( ctx context.Context, endpoint string, msg *types.UnifiedSynapseMessage, timeout time.Duration, ) (*types.UnifiedSynapseMessage, error) { // Create channel for response respChan := make(chan *types.UnifiedSynapseMessage, 1) errChan := make(chan error, 1) // Register callback handler for this message correlationID := msg.CorrelationID if correlationID == "" { correlationID = msg.ID } // Start timeout goroutine go func() { select { case <-ctx.Done(): errChan <- ctx.Err() case <-time.After(timeout): errChan <- fmt.Errorf("timeout waiting for response") } }() // Send message if err := t.Send(ctx, endpoint, msg); err != nil { return nil, err } // Wait for response select { case resp := <-respChan: return resp, nil case err := <-errChan: return nil, err } } // ============================================================================= // Message Reception // ============================================================================= // MessageCallbackHandler is the interface for handling incoming messages type MessageCallbackHandler interface { HandleMessage(msg *types.UnifiedSynapseMessage) error } // HandleCallback handles an incoming callback message (HTTP POST) func (t *HTTPTransport) HandleCallback(w http.ResponseWriter, r *http.Request) { if r.Method != "POST" { http.Error(w, "method not allowed", http.StatusMethodNotAllowed) return } // Read body body, err := io.ReadAll(r.Body) if err != nil { http.Error(w, "failed to read body", http.StatusBadRequest) return } r.Body.Close() // Parse message var msg types.UnifiedSynapseMessage if err := json.Unmarshal(body, &msg); err != nil { http.Error(w, "invalid JSON", http.StatusBadRequest) return } // Verify signature if configured if t.authSecret != "" && msg.Signature != "" { if !t.verifySignature(body, msg.Signature) { http.Error(w, "invalid signature", http.StatusUnauthorized) return } } // Handle message if t.callbackHandler != nil { if err := t.callbackHandler.HandleMessage(&msg); err != nil { log.Printf("[Transport] Failed to handle message: %v", err) http.Error(w, "internal error", http.StatusInternalServerError) return } } // Send success response w.Header().Set("Content-Type", "application/json") w.WriteHeader(http.StatusOK) json.NewEncoder(w).Encode(map[string]interface{}{ "success": true, "message": "received", }) } // ============================================================================= // HTTP Server // ============================================================================= // Server is an HTTP server for Synapse transport type Server struct { transport *HTTPTransport mux *http.ServeMux server *http.Server } // NewServer creates a new HTTP server for Synapse transport func NewServer(addr string, transport *HTTPTransport) *Server { mux := http.NewServeMux() server := &Server{ transport: transport, mux: mux, server: &http.Server{ Addr: addr, Handler: mux, }, } // Register callback endpoint mux.HandleFunc("/synapse/callback", transport.HandleCallback) mux.HandleFunc("/synapse/health", func(w http.ResponseWriter, r *http.Request) { w.WriteHeader(http.StatusOK) w.Write([]byte(`{"status":"ok"}`)) }) return server } // Start starts the HTTP server func (s *Server) Start() error { log.Printf("[Transport] Starting HTTP server on %s", s.server.Addr) return s.server.ListenAndServe() } // Stop stops the HTTP server func (s *Server) Stop(ctx context.Context) error { return s.server.Shutdown(ctx) } // ============================================================================= // Security // ============================================================================= func (t *HTTPTransport) signMessage(msg *types.UnifiedSynapseMessage) { // Create canonical body (message without signature) msgCopy := *msg msgCopy.Signature = "" body, _ := json.Marshal(msgCopy) // Compute HMAC-SHA256 h := hmac.New(sha256.New, []byte(t.authSecret)) h.Write(body) signature := hex.EncodeToString(h.Sum(nil)) msg.Signature = signature } func (t *HTTPTransport) verifySignature(body []byte, signature string) bool { h := hmac.New(sha256.New, []byte(t.authSecret)) h.Write(body) expected := hex.EncodeToString(h.Sum(nil)) return hmac.Equal([]byte(strings.ToLower(signature)), []byte(strings.ToLower(expected))) } // ============================================================================= // Callback Sender (implements p2p.CallbackSender) // ============================================================================= // HTTPCallbackSender implements p2p.CallbackSender using HTTP transport type HTTPCallbackSender struct { transport *HTTPTransport } // NewHTTPCallbackSender creates a new HTTP callback sender func NewHTTPCallbackSender(t *HTTPTransport) *HTTPCallbackSender { return &HTTPCallbackSender{transport: t} } // SendCallback sends a callback message func (s *HTTPCallbackSender) SendCallback(ctx context.Context, endpoint string, msg *types.UnifiedSynapseMessage) error { if endpoint == "" && msg.Receiver != nil { endpoint = msg.Receiver.Endpoint } return s.transport.Send(ctx, endpoint, msg) } // ============================================================================= // WebSocket Transport (for future extension) // ============================================================================= // WebSocketConfig holds WebSocket transport configuration type WebSocketConfig struct { URL string Timeout time.Duration } // WebSocketTransport implements WebSocket-based transport type WebSocketTransport struct { mu sync.RWMutex config *WebSocketConfig handler MessageCallbackHandler } // NewWebSocketTransport creates a new WebSocket transport func NewWebSocketTransport(config *WebSocketConfig) *WebSocketTransport { return &WebSocketTransport{ config: config, } } // SetMessageHandler sets the message handler func (t *WebSocketTransport) SetMessageHandler(handler MessageCallbackHandler) { t.handler = handler } // Connect establishes a WebSocket connection func (t *WebSocketTransport) Connect(ctx context.Context) error { // Placeholder for WebSocket implementation // In a real implementation, this would use gorilla/websocket log.Printf("[Transport] WebSocket connect to %s (placeholder)", t.config.URL) return nil } // Send sends a message via WebSocket func (t *WebSocketTransport) Send(ctx context.Context, msg *types.UnifiedSynapseMessage) error { // Placeholder for WebSocket send implementation log.Printf("[Transport] WebSocket send (placeholder): %s", msg.ID) return nil } // ============================================================================= // Message Utilities // ============================================================================= // CreateSuccessResponse creates a success response func CreateSuccessResponse(msgID string) map[string]interface{} { return map[string]interface{}{ "success": true, "message": "received", "id": msgID, } } // CreateErrorResponse creates an error response func CreateErrorResponse(code int, message string) map[string]interface{} { return map[string]interface{}{ "success": false, "error": map[string]interface{}{ "code": code, "message": message, }, } }