Some playtime

Author: 0x19

client/client.go

@@ -2,9 +2,11 @@ package client
 
 import (
 	"context"
+	"encoding/binary"
 	"errors"
 	"fmt"
 	"sync"
+	"time"
 )
 
 // Client manages multiple transports and handlers using the config
@@ -76,3 +78,60 @@ func (c *Client) Close() error {
 	}
 	return nil
 }
+
+// SendAndReceiveMessage sends a message to another node and waits for a
+// response. This implementation handles large payloads with chunking and
+// provides proper response handling with timeouts.
+// Note: Currently this method only works with TCPTransport and will return
+// an error for other transport types.
+func (c *Client) SendAndReceiveMessage(name string, data []byte, timeout time.Duration) ([]byte, error) {
+	transport, err := c.GetTransport(name)
+	if err != nil {
+		return nil, err
+	}
+	
+	// Check if we're dealing with a TCPTransport which has advanced response handling
+	tcpTransport, ok := transport.(*TCPTransport)
+	if !ok {
+		return nil, fmt.Errorf("SendAndReceiveMessage is only supported for TCP transport, got %T", transport)
+	}
+	
+	// Get the response message type - use the success status
+	responseType := MessageType(1) // Using 1 as a default success value
+	
+	// Register a response channel before sending the message
+	responseCh := tcpTransport.RegisterResponseChannel(responseType)
+	
+	// Define the maximum size for non-chunked messages
+	const maxChunkSize = 1024 * 1024 // 1MB
+	
+	// For large payloads, use chunking protocol to ensure reliable transmission
+	encodedMsg := data
+	if len(data) > maxChunkSize {
+		// Prepare the chunked message with a 4-byte length prefix
+		// The server expects: [total_size(4 bytes)][payload...]
+		lengthPrefix := make([]byte, 4)
+		binary.LittleEndian.PutUint32(lengthPrefix, uint32(len(data)))
+		
+		// Prepend the length prefix to the message
+		chunkedMsg := append(lengthPrefix, data...)
+		
+		// Replace the original message with the chunked version
+		encodedMsg = chunkedMsg
+	}
+	
+	// Send the message
+	if err := tcpTransport.Send(encodedMsg); err != nil {
+		// Make sure to unregister the response channel on error
+		tcpTransport.UnregisterResponseChannel(responseType)
+		return nil, fmt.Errorf("failed to send message: %w", err)
+	}
+	
+	// Wait for the response with the provided timeout
+	response, err := tcpTransport.WaitForResponseWithTimeout(responseCh, timeout)
+	if err != nil {
+		return nil, fmt.Errorf("error waiting for response: %w", err)
+	}
+	
+	return response, nil
+}

demos/simple/README.md

@@ -0,0 +1,37 @@
+# FDB Simple Demo
+
+This directory contains a simple demonstration project for the FDB (Fantastic Distributed Backend) system. This demo is designed to showcase the core functionality and performance characteristics of FDB in a straightforward, easy-to-understand manner.
+
+## Purpose
+
+The simple demo focuses on:
+
+1. Basic node setup and communication
+2. Topology metrics and visualization
+3. Small to moderate data transfer demonstrations
+4. Easy-to-run configuration for quick demonstrations
+
+## Components
+
+This demo will include:
+
+- Simple node configuration files
+- Scripts to start/stop a demo cluster
+- Sample data generators for testing
+- Basic visualization of topology metrics
+- Instructions for running various test scenarios
+
+## Usage
+
+Detailed usage instructions will be provided as the demo is developed. The goal is to make this demo runnable with minimal setup to showcase FDB's capabilities.
+
+## Planned Features
+
+- Single-command setup and teardown
+- Progressive load testing from small to large data volumes
+- Integration with Prometheus/Grafana for metrics visualization
+- Example outputs and expected results
+
+---
+
+*This demo is part of the FDB demos suite which showcases different aspects and capabilities of the FDB distributed system.*