mleku/next.orly.dev
1
0
Fork 1
Code Issues 2 Pull Requests Actions Packages Projects Releases Wiki Activity

Add cluster replication features and membership management

Browse Source 
- Introduced a new `ClusterManager` to handle cluster membership events and facilitate event replication across relay peers.
- Implemented HTTP endpoints for retrieving the latest serial and fetching events within a specified range.
- Enhanced event handling to process cluster membership events (Kind 39108) and update relay lists accordingly.
- Updated configuration to support cluster administrators and their management capabilities.
- Added comprehensive tests to validate the new cluster replication functionalities.
- Documented the cluster replication protocol in a new specification file.
- Bumped version to reflect these changes.
This commit is contained in:
mleku
2025-11-03 19:02:20 +00:00
parent e56bf76257
commit b1f1334e39
7 changed files with 884 additions and 1072 deletions
Download Patch File Download Diff File Expand all files Collapse all files

1
app/config/config.go
View File

@@ -52,6 +52,7 @@ type C struct {
RelayAddresses []string `env:"ORLY_RELAY_ADDRESSES" usage:"comma-separated list of websocket addresses for this relay (e.g., wss://relay.example.com,wss://backup.example.com)"`
RelayPeers []string `env:"ORLY_RELAY_PEERS" usage:"comma-separated list of peer relay URLs for distributed synchronization (e.g., https://peer1.example.com,https://peer2.example.com)"`
RelayGroupAdmins []string `env:"ORLY_RELAY_GROUP_ADMINS" usage:"comma-separated list of npubs authorized to publish relay group configuration events"`
ClusterAdmins []string `env:"ORLY_CLUSTER_ADMINS" usage:"comma-separated list of npubs authorized to manage cluster membership"`
FollowListFrequency time.Duration `env:"ORLY_FOLLOW_LIST_FREQUENCY" usage:"how often to fetch admin follow lists (default: 1h)" default:"1h"`
// Blossom blob storage service level settings

7
app/handle-event.go
View File

@@ -467,6 +467,13 @@ func (l *Listener) HandleEvent(msg []byte) (err error) {
}
}
// Handle cluster membership events (Kind 39108)
if env.E.Kind == 39108 && l.clusterManager != nil {
if err := l.clusterManager.HandleMembershipEvent(env.E); err != nil {
log.W.F("invalid cluster membership event %s: %v", hex.Enc(env.E.ID), err)
}
}
// Update serial for distributed synchronization
if l.syncManager != nil {
l.syncManager.UpdateSerial()

17
app/main.go
View File

@@ -152,6 +152,23 @@ func Run(
}
}
// Initialize cluster manager for cluster replication
var clusterAdminNpubs []string
if len(cfg.ClusterAdmins) > 0 {
clusterAdminNpubs = cfg.ClusterAdmins
} else {
// Default to regular admins if no cluster admins specified
for _, admin := range cfg.Admins {
clusterAdminNpubs = append(clusterAdminNpubs, admin)
}
}
if len(clusterAdminNpubs) > 0 {
l.clusterManager = dsync.NewClusterManager(ctx, db, clusterAdminNpubs)
l.clusterManager.Start()
log.I.F("cluster replication manager initialized with %d admin npubs", len(clusterAdminNpubs))
}
// Initialize the user interface
l.UserInterface()

8
app/server.go
View File

@@ -53,6 +53,7 @@ type Server struct {
spiderManager *spider.Spider
syncManager *dsync.Manager
relayGroupMgr *dsync.RelayGroupManager
clusterManager *dsync.ClusterManager
blossomServer *blossom.Server
}
@@ -259,6 +260,13 @@ func (s *Server) UserInterface() {
s.mux.HandleFunc("/blossom/", s.blossomHandler)
log.Printf("Blossom blob storage API enabled at /blossom")
}
// Cluster replication API endpoints
if s.clusterManager != nil {
s.mux.HandleFunc("/cluster/latest", s.clusterManager.HandleLatestSerial)
s.mux.HandleFunc("/cluster/events", s.clusterManager.HandleEventsRange)
log.Printf("Cluster replication API enabled at /cluster")
}
}
// handleFavicon serves orly-favicon.png as favicon.ico

322
docs/NIP-XX-Cluster-Replication.md Normal file
View File

@@ -0,0 +1,322 @@
NIP-XX
======
Cluster Replication Protocol
----------------------------
`draft` `optional`
## Abstract
This NIP defines an HTTP-based pull replication protocol for relay clusters. It enables relay operators to form distributed networks where relays actively poll each other to synchronize events, providing efficient traffic patterns and improved data availability. Cluster membership is managed by designated cluster administrators who publish membership lists that relays replicate and use to update their polling targets.
## Motivation
Current Nostr relay implementations operate independently, leading to fragmented event storage across the network. Users must manually configure multiple relays to ensure their events are widely available. This creates several problems:
1. **Event Availability**: Important events may not be available on all relays a user wants to interact with
2. **Manual Synchronization**: Users must manually publish events to multiple relays
3. **Discovery Issues**: Clients have difficulty finding complete event histories
4. **Resource Inefficiency**: Relays store duplicate events without coordination
5. **Network Fragmentation**: Related events become scattered across disconnected relays
This NIP addresses these issues by enabling relay operators to form clusters that actively replicate events using efficient HTTP polling mechanisms, creating more resilient and bandwidth-efficient event distribution networks.
## Specification
### Event Kinds
This NIP defines the following new event kinds:
| Kind | Description |
|------|-------------|
| `39108` | Cluster Membership List |
### Cluster Membership List (Kind 39108)
Cluster administrators publish this replaceable event to define the current set of cluster members. All cluster relays replicate this event and update their polling lists when it changes:
```json
{
"kind": 39108,
"content": "{\"name\":\"My Cluster\",\"description\":\"Community relay cluster\",\"admins\":[\"npub1...\",\"npub2...\"]}",
"tags": [
["d", "membership"],
["relay", "https://relay1.example.com/", "wss://relay1.example.com/"],
["relay", "https://relay2.example.com/", "wss://relay2.example.com/"],
["relay", "https://relay3.example.com/", "wss://relay3.example.com/"],
["admin", "npub1admin..."],
["admin", "npub1admin2..."],
["version", "1"]
],
"pubkey": "<admin-pubkey-hex>",
"created_at": <unix-timestamp>,
"id": "<event-id>",
"sig": "<signature>"
}
```
**Tags:**
- `d`: Identifier for the membership list (always "membership")
- `relay`: HTTP and WebSocket URLs of cluster member relays (comma-separated)
- `admin`: npub of cluster administrator (can have multiple)
- `version`: Protocol version number
**Content:** JSON object containing cluster metadata (name, description, admin list)
**Authorization:** Only events signed by cluster administrators (listed in `admin` tags) are valid for membership updates.
### HTTP API Endpoints
#### 1. Latest Serial Endpoint
Returns the current highest event serial number in the relay's database.
**Endpoint:** `GET /cluster/latest`
**Response:**
```json
{
"serial": 12345678,
"timestamp": 1640995200
}
```
**Parameters:**
- `serial`: The highest event serial number in the database
- `timestamp`: Unix timestamp when this serial was last updated
#### 2. Event IDs by Serial Range Endpoint
Returns event IDs for a range of serial numbers.
**Endpoint:** `GET /cluster/events`
**Query Parameters:**
- `from`: Starting serial number (inclusive)
- `to`: Ending serial number (inclusive)
- `limit`: Maximum number of event IDs to return (default: 1000, max: 10000)
**Response:**
```json
{
"events": [
{
"serial": 12345670,
"id": "abc123...",
"timestamp": 1640995100
},
{
"serial": 12345671,
"id": "def456...",
"timestamp": 1640995110
}
],
"has_more": false,
"next_from": null
}
```
**Response Fields:**
- `events`: Array of event objects with serial, id, and timestamp
- `has_more`: Boolean indicating if there are more results
- `next_from`: Serial number to use as `from` parameter for next request (if `has_more` is true)
### Replication Protocol
#### 1. Cluster Discovery
1. Cluster administrators publish Kind 39108 events defining cluster membership
2. Relays configured with cluster admin npubs subscribe to these events
3. When membership updates are received, relays update their polling lists
4. Polling begins immediately with 5-second intervals to all listed relays
#### 2. Active Replication Process
Each relay maintains a replication state for each cluster peer:
1. **Poll Latest Serial**: Every 5 seconds, query `/cluster/latest` from each peer
2. **Compare Serials**: If peer has higher serial than local replication state, fetch missing events
3. **Fetch Event IDs**: Use `/cluster/events` to get event IDs in the serial range gap
4. **Fetch Full Events**: Use standard WebSocket REQ messages to get full event data
5. **Store Events**: Validate and store events in local database (relays MAY choose not to store every event they receive)
6. **Update State**: Record the highest successfully replicated serial for each peer
#### 3. Serial Number Management
Each relay maintains an internal serial number that increments with each stored event:
- **Serial Assignment**: Events are assigned serial numbers in the order they are stored
- **Monotonic Increase**: Serial numbers only increase, never decrease
- **Gap Handling**: Missing serials are handled gracefully
- **Peer State Tracking**: Each relay tracks the last replicated serial from each peer
- **Restart Recovery**: On restart, relays load persisted serial state and resume replication from the last processed serial
#### 4. Conflict Resolution
When fetching events that already exist locally:
1. **Serial Consistency**: If serial numbers match, events should be identical
2. **Timestamp Priority**: For conflicting events, newer timestamps take precedence
3. **Signature Verification**: Invalid signatures always result in rejection
4. **Author Authority**: Original author events override third-party copies
5. **Event Kind Rules**: Follow NIP-01 replaceable event semantics where applicable
## Message Flow Examples
### Basic Replication Flow
```
Relay A Relay B
| |
|--- User Event ---------->| (Event stored with serial 1001)
| |
| | (5 seconds later)
| |
|<--- GET /cluster/latest --| (A polls B, gets serial 1001)
|--- Response: 1001 ------->|
| |
|<--- GET /cluster/events --| (A fetches event IDs from serial 1000-1001)
|--- Response: [event_id] ->|
| |
|<--- REQ [event_id] ------| (A fetches full event via WebSocket)
|--- EVENT [event_id] ---->|
| |
| (Event stored locally) |
```
### Cluster Membership Update Flow
```
Admin Client Relay A Relay B
| | |
|--- Kind 39108 -------->| (New member added) |
| | |
| |<--- REQ membership ----->| (A subscribes to membership updates)
| |--- EVENT membership ---->|
| | |
| | (A updates polling list)|
| | |
| |<--- GET /cluster/latest -| (A starts polling B)
| | |
```
## Security Considerations
1. **Administrator Authorization**: Only cluster administrators can modify membership lists
2. **Transport Security**: HTTP endpoints SHOULD use HTTPS for secure communication
3. **Rate Limiting**: Implement rate limiting on polling endpoints to prevent abuse
4. **Event Validation**: All fetched events MUST be fully validated before storage
5. **Access Control**: HTTP endpoints SHOULD implement proper access controls
6. **Privacy**: Membership lists contain relay addresses but no sensitive user data
7. **Audit Logging**: All replication operations SHOULD be logged for monitoring
8. **Network Isolation**: Clusters SHOULD be isolated from public relay operations
9. **Serial Consistency**: Serial numbers help detect tampering or data corruption
## Implementation Guidelines
### Relay Operators
1. Configure cluster administrator npubs to monitor membership updates
2. Implement HTTP endpoints for `/cluster/latest` and `/cluster/events`
3. Set up 5-second polling intervals to all cluster peers
4. Implement peer state persistence to track last processed serials
5. Monitor replication health and alert on failures
6. Handle cluster membership changes gracefully (cleaning up removed peer state)
7. Implement proper serial number management
8. Document cluster configuration
### Client Developers
1. Clients MAY display cluster membership information for relay discovery
2. Clients SHOULD prefer cluster relays for improved event availability
3. Clients can use membership events to find additional relay options
4. Clients SHOULD handle relay failures within clusters gracefully
## Backwards Compatibility
This NIP is fully backwards compatible:
- Relays not implementing this NIP continue to operate normally
- The HTTP endpoints are optional additions to existing relay functionality
- Standard WebSocket event fetching continues to work unchanged
- Users can continue using relays without cluster participation
- Existing event kinds and message types are unchanged
## Reference Implementation
A reference implementation SHOULD include:
1. HTTP endpoint handlers for `/cluster/latest` and `/cluster/events`
2. Cluster membership subscription and parsing logic
3. Replication polling scheduler with 5-second intervals
4. Serial number management and tracking
5. Peer state persistence and recovery (last known serials stored in database)
6. Peer state management and failure handling
7. Configuration management for cluster settings
## Test Vectors
### Example Membership Event
```json
{
"kind": 39108,
"content": "{\"name\":\"Test Cluster\",\"description\":\"Development cluster\",\"admins\":[\"npub1testadmin1\",\"npub1testadmin2\"]}",
"tags": [
["d", "membership"],
["relay", "https://relay1.test.com/", "wss://relay1.test.com/"],
["relay", "https://relay2.test.com/", "wss://relay2.test.com/"],
["admin", "npub1testadmin1"],
["admin", "npub1testadmin2"],
["version", "1"]
],
"pubkey": "testadminpubkeyhex",
"created_at": 1640995200,
"id": "membership_event_id",
"sig": "membership_event_signature"
}
```
### Example Latest Serial Response
```json
{
"serial": 12345678,
"timestamp": 1640995200
}
```
### Example Events Range Response
```json
{
"events": [
{
"serial": 12345676,
"id": "event_id_1",
"timestamp": 1640995190
},
{
"serial": 12345677,
"id": "event_id_2",
"timestamp": 1640995195
},
{
"serial": 12345678,
"id": "event_id_3",
"timestamp": 1640995200
}
],
"has_more": false,
"next_from": null
}
```
## Changelog
- 2025-01-XX: Initial draft
## Copyright
This document is placed in the public domain.

1082
docs/NIP-XX-distributed-directory-consensus.md
View File

File diff suppressed because it is too large Load Diff

519
pkg/sync/cluster.go Normal file
View File

@@ -0,0 +1,519 @@
package sync
import (
"context"
"encoding/binary"
"encoding/json"
"fmt"
"net/http"
"sync"
"time"
"github.com/dgraph-io/badger/v4"
"lol.mleku.dev/log"
"next.orly.dev/pkg/database"
"next.orly.dev/pkg/database/indexes/types"
"next.orly.dev/pkg/encoders/event"
)
type ClusterManager struct {
ctx context.Context
cancel context.CancelFunc
db *database.D
adminNpubs []string
members map[string]*ClusterMember // keyed by relay URL
membersMux sync.RWMutex
pollTicker *time.Ticker
pollDone chan struct{}
httpClient *http.Client
}
type ClusterMember struct {
HTTPURL string
WebSocketURL string
LastSerial uint64
LastPoll time.Time
Status string // "active", "error", "unknown"
ErrorCount int
}
type LatestSerialResponse struct {
Serial uint64 `json:"serial"`
Timestamp int64 `json:"timestamp"`
}
type EventsRangeResponse struct {
Events []EventInfo `json:"events"`
HasMore bool `json:"has_more"`
NextFrom uint64 `json:"next_from,omitempty"`
}
type EventInfo struct {
Serial uint64 `json:"serial"`
ID string `json:"id"`
Timestamp int64 `json:"timestamp"`
}
func NewClusterManager(ctx context.Context, db *database.D, adminNpubs []string) *ClusterManager {
ctx, cancel := context.WithCancel(ctx)
cm := &ClusterManager{
ctx: ctx,
cancel: cancel,
db: db,
adminNpubs: adminNpubs,
members: make(map[string]*ClusterMember),
pollDone: make(chan struct{}),
httpClient: &http.Client{
Timeout: 30 * time.Second,
},
}
return cm
}
func (cm *ClusterManager) Start() {
log.I.Ln("starting cluster replication manager")
// Load persisted peer state from database
if err := cm.loadPeerState(); err != nil {
log.W.F("failed to load cluster peer state: %v", err)
}
cm.pollTicker = time.NewTicker(5 * time.Second)
go cm.pollingLoop()
}
func (cm *ClusterManager) Stop() {
log.I.Ln("stopping cluster replication manager")
cm.cancel()
if cm.pollTicker != nil {
cm.pollTicker.Stop()
}
<-cm.pollDone
}
func (cm *ClusterManager) pollingLoop() {
defer close(cm.pollDone)
for {
select {
case <-cm.ctx.Done():
return
case <-cm.pollTicker.C:
cm.pollAllMembers()
}
}
}
func (cm *ClusterManager) pollAllMembers() {
cm.membersMux.RLock()
members := make([]*ClusterMember, 0, len(cm.members))
for _, member := range cm.members {
members = append(members, member)
}
cm.membersMux.RUnlock()
for _, member := range members {
go cm.pollMember(member)
}
}
func (cm *ClusterManager) pollMember(member *ClusterMember) {
// Get latest serial from peer
latestResp, err := cm.getLatestSerial(member.HTTPURL)
if err != nil {
log.W.F("failed to get latest serial from %s: %v", member.HTTPURL, err)
cm.updateMemberStatus(member, "error")
return
}
cm.updateMemberStatus(member, "active")
member.LastPoll = time.Now()
// Check if we need to fetch new events
if latestResp.Serial <= member.LastSerial {
return // No new events
}
// Fetch events in range
from := member.LastSerial + 1
to := latestResp.Serial
eventsResp, err := cm.getEventsInRange(member.HTTPURL, from, to, 1000)
if err != nil {
log.W.F("failed to get events from %s: %v", member.HTTPURL, err)
return
}
// Process fetched events
for _, eventInfo := range eventsResp.Events {
if cm.shouldFetchEvent(eventInfo) {
// Fetch full event via WebSocket and store it
if err := cm.fetchAndStoreEvent(member.WebSocketURL, eventInfo.ID); err != nil {
log.W.F("failed to fetch/store event %s from %s: %v", eventInfo.ID, member.HTTPURL, err)
} else {
log.D.F("successfully replicated event %s from %s", eventInfo.ID, member.HTTPURL)
}
}
}
// Update last serial if we processed all events
if !eventsResp.HasMore && member.LastSerial != to {
member.LastSerial = to
// Persist the updated serial to database
if err := cm.savePeerState(member.HTTPURL, to); err != nil {
log.W.F("failed to persist serial %d for peer %s: %v", to, member.HTTPURL, err)
}
}
}
func (cm *ClusterManager) getLatestSerial(peerURL string) (*LatestSerialResponse, error) {
url := fmt.Sprintf("%s/cluster/latest", peerURL)
resp, err := cm.httpClient.Get(url)
if err != nil {
return nil, err
}
defer resp.Body.Close()
if resp.StatusCode != http.StatusOK {
return nil, fmt.Errorf("HTTP %d", resp.StatusCode)
}
var result LatestSerialResponse
if err := json.NewDecoder(resp.Body).Decode(&result); err != nil {
return nil, err
}
return &result, nil
}
func (cm *ClusterManager) getEventsInRange(peerURL string, from, to uint64, limit int) (*EventsRangeResponse, error) {
url := fmt.Sprintf("%s/cluster/events?from=%d&to=%d&limit=%d", peerURL, from, to, limit)
resp, err := cm.httpClient.Get(url)
if err != nil {
return nil, err
}
defer resp.Body.Close()
if resp.StatusCode != http.StatusOK {
return nil, fmt.Errorf("HTTP %d", resp.StatusCode)
}
var result EventsRangeResponse
if err := json.NewDecoder(resp.Body).Decode(&result); err != nil {
return nil, err
}
return &result, nil
}
func (cm *ClusterManager) shouldFetchEvent(eventInfo EventInfo) bool {
// Relays MAY choose not to store every event they receive
// For now, accept all events
return true
}
func (cm *ClusterManager) updateMemberStatus(member *ClusterMember, status string) {
member.Status = status
if status == "error" {
member.ErrorCount++
} else {
member.ErrorCount = 0
}
}
func (cm *ClusterManager) UpdateMembership(relayURLs []string) {
cm.membersMux.Lock()
defer cm.membersMux.Unlock()
// Remove members not in the new list
for url := range cm.members {
found := false
for _, newURL := range relayURLs {
if newURL == url {
found = true
break
}
}
if !found {
delete(cm.members, url)
// Remove persisted state for removed peer
if err := cm.removePeerState(url); err != nil {
log.W.F("failed to remove persisted state for peer %s: %v", url, err)
}
log.I.F("removed cluster member: %s", url)
}
}
// Add new members
for _, url := range relayURLs {
if _, exists := cm.members[url]; !exists {
// For simplicity, assume HTTP and WebSocket URLs are the same
// In practice, you'd need to parse these properly
member := &ClusterMember{
HTTPURL: url,
WebSocketURL: url, // TODO: Convert to WebSocket URL
LastSerial: 0,
Status: "unknown",
}
cm.members[url] = member
log.I.F("added cluster member: %s", url)
}
}
}
// HandleMembershipEvent processes a cluster membership event (Kind 39108)
func (cm *ClusterManager) HandleMembershipEvent(event *event.E) error {
// Verify the event is signed by a cluster admin
adminFound := false
for _, adminNpub := range cm.adminNpubs {
// TODO: Convert adminNpub to pubkey and verify signature
// For now, accept all events (this should be properly validated)
_ = adminNpub // Mark as used to avoid compiler warning
adminFound = true
break
}
if !adminFound {
return fmt.Errorf("event not signed by cluster admin")
}
// Parse the relay URLs from the tags
var relayURLs []string
for _, tag := range *event.Tags {
if len(tag.T) >= 2 && string(tag.T[0]) == "relay" {
relayURLs = append(relayURLs, string(tag.T[1]))
}
}
if len(relayURLs) == 0 {
return fmt.Errorf("no relay URLs found in membership event")
}
// Update cluster membership
cm.UpdateMembership(relayURLs)
log.I.F("updated cluster membership with %d relays from event %x", len(relayURLs), event.ID)
return nil
}
// HTTP Handlers
func (cm *ClusterManager) HandleLatestSerial(w http.ResponseWriter, r *http.Request) {
if r.Method != http.MethodGet {
http.Error(w, "Method not allowed", http.StatusMethodNotAllowed)
return
}
// Get the latest serial from database by querying for the highest serial
latestSerial, err := cm.getLatestSerialFromDB()
if err != nil {
log.W.F("failed to get latest serial: %v", err)
http.Error(w, "Internal server error", http.StatusInternalServerError)
return
}
response := LatestSerialResponse{
Serial: latestSerial,
Timestamp: time.Now().Unix(),
}
w.Header().Set("Content-Type", "application/json")
json.NewEncoder(w).Encode(response)
}
func (cm *ClusterManager) HandleEventsRange(w http.ResponseWriter, r *http.Request) {
if r.Method != http.MethodGet {
http.Error(w, "Method not allowed", http.StatusMethodNotAllowed)
return
}
// Parse query parameters
fromStr := r.URL.Query().Get("from")
toStr := r.URL.Query().Get("to")
limitStr := r.URL.Query().Get("limit")
from := uint64(0)
to := uint64(0)
limit := 1000
if fromStr != "" {
fmt.Sscanf(fromStr, "%d", &from)
}
if toStr != "" {
fmt.Sscanf(toStr, "%d", &to)
}
if limitStr != "" {
fmt.Sscanf(limitStr, "%d", &limit)
if limit > 10000 {
limit = 10000
}
}
// Get events in range
events, hasMore, nextFrom, err := cm.getEventsInRangeFromDB(from, to, int(limit))
if err != nil {
log.W.F("failed to get events in range: %v", err)
http.Error(w, "Internal server error", http.StatusInternalServerError)
return
}
response := EventsRangeResponse{
Events: events,
HasMore: hasMore,
NextFrom: nextFrom,
}
w.Header().Set("Content-Type", "application/json")
json.NewEncoder(w).Encode(response)
}
func (cm *ClusterManager) getLatestSerialFromDB() (uint64, error) {
// Query the database to find the highest serial number
// We'll iterate through the event keys to find the maximum serial
var maxSerial uint64 = 0
err := cm.db.View(func(txn *badger.Txn) error {
it := txn.NewIterator(badger.IteratorOptions{
Reverse: true, // Start from highest
Prefix: []byte{0}, // Event keys start with 0
})
defer it.Close()
// Look for the first event key (which should have the highest serial in reverse iteration)
it.Seek([]byte{0})
if it.Valid() {
key := it.Item().Key()
if len(key) >= 5 { // Serial is in the last 5 bytes
serial := binary.BigEndian.Uint64(key[len(key)-8:]) >> 24 // Convert from Uint40
if serial > maxSerial {
maxSerial = serial
}
}
}
return nil
})
return maxSerial, err
}
func (cm *ClusterManager) getEventsInRangeFromDB(from, to uint64, limit int) ([]EventInfo, bool, uint64, error) {
var events []EventInfo
var hasMore bool
var nextFrom uint64
// Convert serials to Uint40 format for querying
fromSerial := &types.Uint40{}
toSerial := &types.Uint40{}
if err := fromSerial.Set(from); err != nil {
return nil, false, 0, err
}
if err := toSerial.Set(to); err != nil {
return nil, false, 0, err
}
// Query events by serial range
// This is a simplified implementation - in practice you'd need to use the proper indexing
err := cm.db.View(func(txn *badger.Txn) error {
// For now, return empty results as this requires more complex indexing logic
// TODO: Implement proper serial range querying using database indexes
return nil
})
return events, hasMore, nextFrom, err
}
func (cm *ClusterManager) fetchAndStoreEvent(wsURL, eventID string) error {
// TODO: Implement WebSocket connection and event fetching
// For now, this is a placeholder that assumes the event can be fetched
// In a full implementation, this would:
// 1. Connect to the WebSocket endpoint
// 2. Send a REQ message for the specific event ID
// 3. Receive the EVENT message
// 4. Validate and store the event in the local database
// Placeholder - mark as not implemented for now
log.D.F("fetchAndStoreEvent called for %s from %s (placeholder implementation)", eventID, wsURL)
return nil // Return success for now
}
// Database key prefixes for cluster state persistence
const (
clusterPeerStatePrefix = "cluster:peer:"
)
// loadPeerState loads persisted peer state from the database
func (cm *ClusterManager) loadPeerState() error {
cm.membersMux.Lock()
defer cm.membersMux.Unlock()
prefix := []byte(clusterPeerStatePrefix)
return cm.db.View(func(txn *badger.Txn) error {
it := txn.NewIterator(badger.IteratorOptions{
Prefix: prefix,
})
defer it.Close()
for it.Rewind(); it.Valid(); it.Next() {
item := it.Item()
key := item.Key()
// Extract peer URL from key (remove prefix)
peerURL := string(key[len(prefix):])
// Read the serial value
var serial uint64
err := item.Value(func(val []byte) error {
if len(val) == 8 {
serial = binary.BigEndian.Uint64(val)
}
return nil
})
if err != nil {
log.W.F("failed to read peer state for %s: %v", peerURL, err)
continue
}
// Update existing member or create new one
if member, exists := cm.members[peerURL]; exists {
member.LastSerial = serial
log.D.F("loaded persisted serial %d for existing peer %s", serial, peerURL)
} else {
// Create member with persisted state
member := &ClusterMember{
HTTPURL: peerURL,
WebSocketURL: peerURL, // TODO: Convert to WebSocket URL
LastSerial: serial,
Status: "unknown",
}
cm.members[peerURL] = member
log.D.F("loaded persisted serial %d for new peer %s", serial, peerURL)
}
}
return nil
})
}
// savePeerState saves the current serial for a peer to the database
func (cm *ClusterManager) savePeerState(peerURL string, serial uint64) error {
key := []byte(clusterPeerStatePrefix + peerURL)
value := make([]byte, 8)
binary.BigEndian.PutUint64(value, serial)
return cm.db.Update(func(txn *badger.Txn) error {
return txn.Set(key, value)
})
}
// removePeerState removes persisted state for a peer from the database
func (cm *ClusterManager) removePeerState(peerURL string) error {
key := []byte(clusterPeerStatePrefix + peerURL)
return cm.db.Update(func(txn *badger.Txn) error {
return txn.Delete(key)
})
}