Complete BZZZ functionality port to CHORUS
🎭 CHORUS now contains full BZZZ functionality adapted for containers Core systems ported: - P2P networking (libp2p with DHT and PubSub) - Task coordination (COOEE protocol) - HMMM collaborative reasoning - SHHH encryption and security - SLURP admin election system - UCXL content addressing - UCXI server integration - Hypercore logging system - Health monitoring and graceful shutdown - License validation with KACHING Container adaptations: - Environment variable configuration (no YAML files) - Container-optimized logging to stdout/stderr - Auto-generated agent IDs for container deployments - Docker-first architecture All proven BZZZ P2P protocols, AI integration, and collaboration features are now available in containerized form. Next: Build and test container deployment. 🤖 Generated with [Claude Code](https://claude.ai/code) Co-Authored-By: Claude <noreply@anthropic.com>
This commit is contained in:
anthonyrawlins
1005
pkg/election/election.go
Normal file
1005
pkg/election/election.go
Normal file
File diff suppressed because it is too large
Load Diff
452
pkg/election/election_test.go
Normal file
452
pkg/election/election_test.go
Normal file
@@ -0,0 +1,452 @@
|
||||
package election
|
||||
|
||||
import (
|
||||
"context"
|
||||
"testing"
|
||||
"time"
|
||||
|
||||
"chorus.services/bzzz/pkg/config"
|
||||
)
|
||||
|
||||
func TestElectionManager_NewElectionManager(t *testing.T) {
|
||||
cfg := &config.Config{
|
||||
Agent: config.AgentConfig{
|
||||
ID: "test-node",
|
||||
},
|
||||
}
|
||||
|
||||
em := NewElectionManager(cfg)
|
||||
if em == nil {
|
||||
t.Fatal("Expected NewElectionManager to return non-nil manager")
|
||||
}
|
||||
|
||||
if em.nodeID != "test-node" {
|
||||
t.Errorf("Expected nodeID to be 'test-node', got %s", em.nodeID)
|
||||
}
|
||||
|
||||
if em.state != StateIdle {
|
||||
t.Errorf("Expected initial state to be StateIdle, got %v", em.state)
|
||||
}
|
||||
}
|
||||
|
||||
func TestElectionManager_StartElection(t *testing.T) {
|
||||
cfg := &config.Config{
|
||||
Agent: config.AgentConfig{
|
||||
ID: "test-node",
|
||||
},
|
||||
}
|
||||
|
||||
em := NewElectionManager(cfg)
|
||||
|
||||
// Start election
|
||||
err := em.StartElection()
|
||||
if err != nil {
|
||||
t.Fatalf("Failed to start election: %v", err)
|
||||
}
|
||||
|
||||
// Verify state changed
|
||||
if em.state != StateCandidate {
|
||||
t.Errorf("Expected state to be StateCandidate after starting election, got %v", em.state)
|
||||
}
|
||||
|
||||
// Verify we added ourselves as a candidate
|
||||
em.mu.RLock()
|
||||
candidate, exists := em.candidates[em.nodeID]
|
||||
em.mu.RUnlock()
|
||||
|
||||
if !exists {
|
||||
t.Error("Expected to find ourselves as a candidate after starting election")
|
||||
}
|
||||
|
||||
if candidate.NodeID != em.nodeID {
|
||||
t.Errorf("Expected candidate NodeID to be %s, got %s", em.nodeID, candidate.NodeID)
|
||||
}
|
||||
}
|
||||
|
||||
func TestElectionManager_Vote(t *testing.T) {
|
||||
cfg := &config.Config{
|
||||
Agent: config.AgentConfig{
|
||||
ID: "test-node",
|
||||
},
|
||||
}
|
||||
|
||||
em := NewElectionManager(cfg)
|
||||
|
||||
// Add a candidate first
|
||||
candidate := &AdminCandidate{
|
||||
NodeID: "candidate-1",
|
||||
Term: 1,
|
||||
Score: 0.8,
|
||||
Capabilities: []string{"admin"},
|
||||
LastSeen: time.Now(),
|
||||
}
|
||||
|
||||
em.mu.Lock()
|
||||
em.candidates["candidate-1"] = candidate
|
||||
em.mu.Unlock()
|
||||
|
||||
// Vote for the candidate
|
||||
err := em.Vote("candidate-1")
|
||||
if err != nil {
|
||||
t.Fatalf("Failed to vote: %v", err)
|
||||
}
|
||||
|
||||
// Verify vote was recorded
|
||||
em.mu.RLock()
|
||||
vote, exists := em.votes[em.nodeID]
|
||||
em.mu.RUnlock()
|
||||
|
||||
if !exists {
|
||||
t.Error("Expected to find our vote after voting")
|
||||
}
|
||||
|
||||
if vote != "candidate-1" {
|
||||
t.Errorf("Expected vote to be for 'candidate-1', got %s", vote)
|
||||
}
|
||||
}
|
||||
|
||||
func TestElectionManager_VoteInvalidCandidate(t *testing.T) {
|
||||
cfg := &config.Config{
|
||||
Agent: config.AgentConfig{
|
||||
ID: "test-node",
|
||||
},
|
||||
}
|
||||
|
||||
em := NewElectionManager(cfg)
|
||||
|
||||
// Try to vote for non-existent candidate
|
||||
err := em.Vote("non-existent")
|
||||
if err == nil {
|
||||
t.Error("Expected error when voting for non-existent candidate")
|
||||
}
|
||||
}
|
||||
|
||||
func TestElectionManager_AddCandidate(t *testing.T) {
|
||||
cfg := &config.Config{
|
||||
Agent: config.AgentConfig{
|
||||
ID: "test-node",
|
||||
},
|
||||
}
|
||||
|
||||
em := NewElectionManager(cfg)
|
||||
|
||||
candidate := &AdminCandidate{
|
||||
NodeID: "new-candidate",
|
||||
Term: 1,
|
||||
Score: 0.7,
|
||||
Capabilities: []string{"admin", "leader"},
|
||||
LastSeen: time.Now(),
|
||||
}
|
||||
|
||||
err := em.AddCandidate(candidate)
|
||||
if err != nil {
|
||||
t.Fatalf("Failed to add candidate: %v", err)
|
||||
}
|
||||
|
||||
// Verify candidate was added
|
||||
em.mu.RLock()
|
||||
stored, exists := em.candidates["new-candidate"]
|
||||
em.mu.RUnlock()
|
||||
|
||||
if !exists {
|
||||
t.Error("Expected to find added candidate")
|
||||
}
|
||||
|
||||
if stored.NodeID != "new-candidate" {
|
||||
t.Errorf("Expected stored candidate NodeID to be 'new-candidate', got %s", stored.NodeID)
|
||||
}
|
||||
|
||||
if stored.Score != 0.7 {
|
||||
t.Errorf("Expected stored candidate score to be 0.7, got %f", stored.Score)
|
||||
}
|
||||
}
|
||||
|
||||
func TestElectionManager_FindElectionWinner(t *testing.T) {
|
||||
cfg := &config.Config{
|
||||
Agent: config.AgentConfig{
|
||||
ID: "test-node",
|
||||
},
|
||||
}
|
||||
|
||||
em := NewElectionManager(cfg)
|
||||
|
||||
// Add candidates with different scores
|
||||
candidates := []*AdminCandidate{
|
||||
{
|
||||
NodeID: "candidate-1",
|
||||
Term: 1,
|
||||
Score: 0.6,
|
||||
Capabilities: []string{"admin"},
|
||||
LastSeen: time.Now(),
|
||||
},
|
||||
{
|
||||
NodeID: "candidate-2",
|
||||
Term: 1,
|
||||
Score: 0.8,
|
||||
Capabilities: []string{"admin", "leader"},
|
||||
LastSeen: time.Now(),
|
||||
},
|
||||
{
|
||||
NodeID: "candidate-3",
|
||||
Term: 1,
|
||||
Score: 0.7,
|
||||
Capabilities: []string{"admin"},
|
||||
LastSeen: time.Now(),
|
||||
},
|
||||
}
|
||||
|
||||
em.mu.Lock()
|
||||
for _, candidate := range candidates {
|
||||
em.candidates[candidate.NodeID] = candidate
|
||||
}
|
||||
|
||||
// Add some votes
|
||||
em.votes["voter-1"] = "candidate-2"
|
||||
em.votes["voter-2"] = "candidate-2"
|
||||
em.votes["voter-3"] = "candidate-1"
|
||||
em.mu.Unlock()
|
||||
|
||||
// Find winner
|
||||
winner := em.findElectionWinner()
|
||||
|
||||
if winner == nil {
|
||||
t.Fatal("Expected findElectionWinner to return a winner")
|
||||
}
|
||||
|
||||
// candidate-2 should win with most votes (2 votes)
|
||||
if winner.NodeID != "candidate-2" {
|
||||
t.Errorf("Expected winner to be 'candidate-2', got %s", winner.NodeID)
|
||||
}
|
||||
}
|
||||
|
||||
func TestElectionManager_FindElectionWinnerNoVotes(t *testing.T) {
|
||||
cfg := &config.Config{
|
||||
Agent: config.AgentConfig{
|
||||
ID: "test-node",
|
||||
},
|
||||
}
|
||||
|
||||
em := NewElectionManager(cfg)
|
||||
|
||||
// Add candidates but no votes - should fall back to highest score
|
||||
candidates := []*AdminCandidate{
|
||||
{
|
||||
NodeID: "candidate-1",
|
||||
Term: 1,
|
||||
Score: 0.6,
|
||||
Capabilities: []string{"admin"},
|
||||
LastSeen: time.Now(),
|
||||
},
|
||||
{
|
||||
NodeID: "candidate-2",
|
||||
Term: 1,
|
||||
Score: 0.9, // Highest score
|
||||
Capabilities: []string{"admin", "leader"},
|
||||
LastSeen: time.Now(),
|
||||
},
|
||||
}
|
||||
|
||||
em.mu.Lock()
|
||||
for _, candidate := range candidates {
|
||||
em.candidates[candidate.NodeID] = candidate
|
||||
}
|
||||
em.mu.Unlock()
|
||||
|
||||
// Find winner without any votes
|
||||
winner := em.findElectionWinner()
|
||||
|
||||
if winner == nil {
|
||||
t.Fatal("Expected findElectionWinner to return a winner")
|
||||
}
|
||||
|
||||
// candidate-2 should win with highest score
|
||||
if winner.NodeID != "candidate-2" {
|
||||
t.Errorf("Expected winner to be 'candidate-2' (highest score), got %s", winner.NodeID)
|
||||
}
|
||||
}
|
||||
|
||||
func TestElectionManager_HandleElectionVote(t *testing.T) {
|
||||
cfg := &config.Config{
|
||||
Agent: config.AgentConfig{
|
||||
ID: "test-node",
|
||||
},
|
||||
}
|
||||
|
||||
em := NewElectionManager(cfg)
|
||||
|
||||
// Add a candidate first
|
||||
candidate := &AdminCandidate{
|
||||
NodeID: "candidate-1",
|
||||
Term: 1,
|
||||
Score: 0.8,
|
||||
Capabilities: []string{"admin"},
|
||||
LastSeen: time.Now(),
|
||||
}
|
||||
|
||||
em.mu.Lock()
|
||||
em.candidates["candidate-1"] = candidate
|
||||
em.mu.Unlock()
|
||||
|
||||
// Create vote message
|
||||
msg := ElectionMessage{
|
||||
Type: MessageTypeVote,
|
||||
NodeID: "voter-1",
|
||||
Data: map[string]interface{}{
|
||||
"candidate": "candidate-1",
|
||||
},
|
||||
}
|
||||
|
||||
// Handle the vote
|
||||
em.handleElectionVote(msg)
|
||||
|
||||
// Verify vote was recorded
|
||||
em.mu.RLock()
|
||||
vote, exists := em.votes["voter-1"]
|
||||
em.mu.RUnlock()
|
||||
|
||||
if !exists {
|
||||
t.Error("Expected vote to be recorded after handling vote message")
|
||||
}
|
||||
|
||||
if vote != "candidate-1" {
|
||||
t.Errorf("Expected recorded vote to be for 'candidate-1', got %s", vote)
|
||||
}
|
||||
}
|
||||
|
||||
func TestElectionManager_HandleElectionVoteInvalidData(t *testing.T) {
|
||||
cfg := &config.Config{
|
||||
Agent: config.AgentConfig{
|
||||
ID: "test-node",
|
||||
},
|
||||
}
|
||||
|
||||
em := NewElectionManager(cfg)
|
||||
|
||||
// Create vote message with invalid data
|
||||
msg := ElectionMessage{
|
||||
Type: MessageTypeVote,
|
||||
NodeID: "voter-1",
|
||||
Data: "invalid-data", // Should be map[string]interface{}
|
||||
}
|
||||
|
||||
// Handle the vote - should not crash
|
||||
em.handleElectionVote(msg)
|
||||
|
||||
// Verify no vote was recorded
|
||||
em.mu.RLock()
|
||||
_, exists := em.votes["voter-1"]
|
||||
em.mu.RUnlock()
|
||||
|
||||
if exists {
|
||||
t.Error("Expected no vote to be recorded with invalid data")
|
||||
}
|
||||
}
|
||||
|
||||
func TestElectionManager_CompleteElection(t *testing.T) {
|
||||
cfg := &config.Config{
|
||||
Agent: config.AgentConfig{
|
||||
ID: "test-node",
|
||||
},
|
||||
}
|
||||
|
||||
em := NewElectionManager(cfg)
|
||||
|
||||
// Set up election state
|
||||
em.mu.Lock()
|
||||
em.state = StateCandidate
|
||||
em.currentTerm = 1
|
||||
em.mu.Unlock()
|
||||
|
||||
// Add a candidate
|
||||
candidate := &AdminCandidate{
|
||||
NodeID: "winner",
|
||||
Term: 1,
|
||||
Score: 0.9,
|
||||
Capabilities: []string{"admin", "leader"},
|
||||
LastSeen: time.Now(),
|
||||
}
|
||||
|
||||
em.mu.Lock()
|
||||
em.candidates["winner"] = candidate
|
||||
em.mu.Unlock()
|
||||
|
||||
// Complete election
|
||||
em.CompleteElection()
|
||||
|
||||
// Verify state reset
|
||||
em.mu.RLock()
|
||||
state := em.state
|
||||
em.mu.RUnlock()
|
||||
|
||||
if state != StateIdle {
|
||||
t.Errorf("Expected state to be StateIdle after completing election, got %v", state)
|
||||
}
|
||||
}
|
||||
|
||||
func TestElectionManager_Concurrency(t *testing.T) {
|
||||
cfg := &config.Config{
|
||||
Agent: config.AgentConfig{
|
||||
ID: "test-node",
|
||||
},
|
||||
}
|
||||
|
||||
em := NewElectionManager(cfg)
|
||||
|
||||
// Test concurrent access to vote and candidate operations
|
||||
ctx, cancel := context.WithTimeout(context.Background(), 2*time.Second)
|
||||
defer cancel()
|
||||
|
||||
// Add a candidate
|
||||
candidate := &AdminCandidate{
|
||||
NodeID: "candidate-1",
|
||||
Term: 1,
|
||||
Score: 0.8,
|
||||
Capabilities: []string{"admin"},
|
||||
LastSeen: time.Now(),
|
||||
}
|
||||
|
||||
err := em.AddCandidate(candidate)
|
||||
if err != nil {
|
||||
t.Fatalf("Failed to add candidate: %v", err)
|
||||
}
|
||||
|
||||
// Run concurrent operations
|
||||
done := make(chan bool, 2)
|
||||
|
||||
// Concurrent voting
|
||||
go func() {
|
||||
defer func() { done <- true }()
|
||||
for i := 0; i < 10; i++ {
|
||||
select {
|
||||
case <-ctx.Done():
|
||||
return
|
||||
default:
|
||||
em.Vote("candidate-1") // Ignore errors in concurrent test
|
||||
time.Sleep(10 * time.Millisecond)
|
||||
}
|
||||
}
|
||||
}()
|
||||
|
||||
// Concurrent state checking
|
||||
go func() {
|
||||
defer func() { done <- true }()
|
||||
for i := 0; i < 10; i++ {
|
||||
select {
|
||||
case <-ctx.Done():
|
||||
return
|
||||
default:
|
||||
em.findElectionWinner() // Just check for races
|
||||
time.Sleep(10 * time.Millisecond)
|
||||
}
|
||||
}
|
||||
}()
|
||||
|
||||
// Wait for completion
|
||||
for i := 0; i < 2; i++ {
|
||||
select {
|
||||
case <-done:
|
||||
case <-ctx.Done():
|
||||
t.Fatal("Concurrent test timed out")
|
||||
}
|
||||
}
|
||||
}
|
||||
163
pkg/election/interfaces.go
Normal file
163
pkg/election/interfaces.go
Normal file
@@ -0,0 +1,163 @@
|
||||
// Package election provides election interfaces and types
|
||||
// This file contains shared interfaces to avoid circular dependencies.
|
||||
|
||||
package election
|
||||
|
||||
import (
|
||||
"context"
|
||||
"time"
|
||||
)
|
||||
|
||||
// LeaderInfo represents information about the current leader
|
||||
type LeaderInfo struct {
|
||||
NodeID string `json:"node_id"` // Leader node ID
|
||||
Role string `json:"role"` // Leader role
|
||||
Term int64 `json:"term"` // Election term
|
||||
ElectedAt time.Time `json:"elected_at"` // When elected
|
||||
LastSeen time.Time `json:"last_seen"` // Last heartbeat
|
||||
Capabilities []string `json:"capabilities"` // Leader capabilities
|
||||
}
|
||||
|
||||
// GenerationStatus represents status of context generation operations
|
||||
type GenerationStatus struct {
|
||||
IsGenerating bool `json:"is_generating"` // Whether generation is active
|
||||
ActiveRequests int `json:"active_requests"` // Number of active requests
|
||||
QueuedRequests int `json:"queued_requests"` // Number of queued requests
|
||||
LastGeneration time.Time `json:"last_generation"` // Last generation time
|
||||
GenerationCount int64 `json:"generation_count"` // Total generations
|
||||
LeaderID string `json:"leader_id"` // Current leader
|
||||
}
|
||||
|
||||
// ContextGenerationRequest represents a request for context generation
|
||||
type ContextGenerationRequest struct {
|
||||
ID string `json:"id"` // Request ID
|
||||
RequesterID string `json:"requester_id"` // Node requesting
|
||||
Priority int `json:"priority"` // Request priority
|
||||
Context map[string]interface{} `json:"context"` // Request context
|
||||
CreatedAt time.Time `json:"created_at"` // Request creation time
|
||||
Deadline *time.Time `json:"deadline"` // Optional deadline
|
||||
}
|
||||
|
||||
// ContextGenerationResult represents the result of a context generation request
|
||||
type ContextGenerationResult struct {
|
||||
RequestID string `json:"request_id"` // Original request ID
|
||||
Success bool `json:"success"` // Whether successful
|
||||
Error string `json:"error"` // Error message if failed
|
||||
GeneratedAt time.Time `json:"generated_at"` // When generated
|
||||
GeneratedBy string `json:"generated_by"` // Node that generated
|
||||
Context []byte `json:"context"` // Generated context data
|
||||
}
|
||||
|
||||
// ContextLeadershipCallbacks defines callbacks for context leadership events
|
||||
type ContextLeadershipCallbacks struct {
|
||||
// OnBecomeContextLeader is called when this node becomes context leader
|
||||
OnBecomeContextLeader func(ctx context.Context, term int64) error
|
||||
|
||||
// OnLoseContextLeadership is called when this node loses context leadership
|
||||
OnLoseContextLeadership func(ctx context.Context, newLeader string) error
|
||||
|
||||
// OnContextLeaderChanged is called when any leadership change occurs
|
||||
OnContextLeaderChanged func(oldLeader, newLeader string, term int64)
|
||||
|
||||
// OnContextGenerationStarted is called when context generation starts
|
||||
OnContextGenerationStarted func(leaderID string)
|
||||
|
||||
// OnContextGenerationStopped is called when context generation stops
|
||||
OnContextGenerationStopped func(leaderID string, reason string)
|
||||
|
||||
// OnContextFailover is called when context leadership failover occurs
|
||||
OnContextFailover func(oldLeader, newLeader string, duration time.Duration)
|
||||
|
||||
// OnContextError is called when context-related errors occur
|
||||
OnContextError func(err error, severity ErrorSeverity)
|
||||
}
|
||||
|
||||
// ErrorSeverity represents severity levels for election errors
|
||||
type ErrorSeverity string
|
||||
|
||||
const (
|
||||
ErrorSeverityLow ErrorSeverity = "low" // Low severity error
|
||||
ErrorSeverityMedium ErrorSeverity = "medium" // Medium severity error
|
||||
ErrorSeverityHigh ErrorSeverity = "high" // High severity error
|
||||
ErrorSeverityCritical ErrorSeverity = "critical" // Critical error
|
||||
)
|
||||
|
||||
// ContextManager defines interface for managing context generation
|
||||
type ContextManager interface {
|
||||
// Context generation management
|
||||
RequestContextGeneration(req *ContextGenerationRequest) error
|
||||
GetGenerationStatus() (*GenerationStatus, error)
|
||||
StartGeneration(ctx context.Context) error
|
||||
StopGeneration(ctx context.Context) error
|
||||
|
||||
// Leadership awareness
|
||||
IsLeader() bool
|
||||
SetLeader(isLeader bool)
|
||||
|
||||
// Health and status
|
||||
GetHealth() (bool, error)
|
||||
GetMetrics() map[string]interface{}
|
||||
}
|
||||
|
||||
// Additional types for context failover (simplified versions)
|
||||
|
||||
// ContextGenerationJob represents a context generation job
|
||||
type ContextGenerationJob struct {
|
||||
ID string `json:"id"` // Job ID
|
||||
RequestID string `json:"request_id"` // Original request ID
|
||||
Status string `json:"status"` // Job status
|
||||
CreatedAt time.Time `json:"created_at"` // Creation time
|
||||
UpdatedAt time.Time `json:"updated_at"` // Last update
|
||||
CompletedAt *time.Time `json:"completed_at"` // Completion time
|
||||
Context map[string]interface{} `json:"context"` // Job context
|
||||
}
|
||||
|
||||
// ClusterState represents simplified cluster state
|
||||
type ClusterState struct {
|
||||
Nodes map[string]interface{} `json:"nodes"` // Node states
|
||||
Leadership map[string]string `json:"leadership"` // Leadership assignments
|
||||
LastUpdated time.Time `json:"last_updated"` // Last state update
|
||||
StateVersion int64 `json:"state_version"` // State version
|
||||
}
|
||||
|
||||
// ResourceAllocation represents resource allocation
|
||||
type ResourceAllocation struct {
|
||||
NodeID string `json:"node_id"` // Target node
|
||||
Resources map[string]interface{} `json:"resources"` // Allocated resources
|
||||
AllocatedAt time.Time `json:"allocated_at"` // Allocation time
|
||||
ExpiresAt *time.Time `json:"expires_at"` // Expiration time
|
||||
}
|
||||
|
||||
// ManagerConfig represents manager configuration
|
||||
type ManagerConfig struct {
|
||||
MaxConcurrentJobs int `json:"max_concurrent_jobs"` // Max concurrent jobs
|
||||
QueueSize int `json:"queue_size"` // Queue size limit
|
||||
TimeoutDuration time.Duration `json:"timeout_duration"` // Job timeout
|
||||
Settings map[string]interface{} `json:"settings"` // Additional settings
|
||||
}
|
||||
|
||||
// GenerationPolicy represents context generation policy
|
||||
type GenerationPolicy struct {
|
||||
Priority string `json:"priority"` // Priority scheme
|
||||
MaxRetries int `json:"max_retries"` // Maximum retries
|
||||
BackoffType string `json:"backoff_type"` // Backoff strategy
|
||||
Settings map[string]interface{} `json:"settings"` // Policy settings
|
||||
}
|
||||
|
||||
// QueuePolicy represents queue management policy
|
||||
type QueuePolicy struct {
|
||||
Strategy string `json:"strategy"` // Queue strategy
|
||||
MaxSize int `json:"max_size"` // Maximum queue size
|
||||
DropPolicy string `json:"drop_policy"` // What to drop when full
|
||||
Settings map[string]interface{} `json:"settings"` // Queue settings
|
||||
}
|
||||
|
||||
// DefaultManagerConfig returns default manager configuration
|
||||
func DefaultManagerConfig() *ManagerConfig {
|
||||
return &ManagerConfig{
|
||||
MaxConcurrentJobs: 10,
|
||||
QueueSize: 100,
|
||||
TimeoutDuration: 30 * time.Minute,
|
||||
Settings: make(map[string]interface{}),
|
||||
}
|
||||
}
|
||||
261
pkg/election/slurp_election.go
Normal file
261
pkg/election/slurp_election.go
Normal file
@@ -0,0 +1,261 @@
|
||||
package election
|
||||
|
||||
import (
|
||||
"context"
|
||||
"time"
|
||||
|
||||
// slurpContext "chorus.services/bzzz/pkg/slurp/context"
|
||||
)
|
||||
|
||||
// SLURPElection extends the base Election interface to include Project Manager contextual intelligence duties
|
||||
type SLURPElection interface {
|
||||
Election // Embed base election interface
|
||||
|
||||
// Project Manager specific capabilities
|
||||
|
||||
// RegisterContextManager registers a SLURP context manager for leader duties
|
||||
RegisterContextManager(manager ContextManager) error
|
||||
|
||||
// IsContextLeader returns whether this node is the current context generation leader
|
||||
IsContextLeader() bool
|
||||
|
||||
// GetContextManager returns the registered context manager (if leader)
|
||||
GetContextManager() (ContextManager, error)
|
||||
|
||||
// TransferContextLeadership initiates graceful context leadership transfer
|
||||
TransferContextLeadership(ctx context.Context, targetNodeID string) error
|
||||
|
||||
// GetContextLeaderInfo returns information about current context leader
|
||||
GetContextLeaderInfo() (*LeaderInfo, error)
|
||||
|
||||
// Context generation coordination
|
||||
|
||||
// StartContextGeneration begins context generation operations (leader only)
|
||||
StartContextGeneration(ctx context.Context) error
|
||||
|
||||
// StopContextGeneration stops context generation operations
|
||||
StopContextGeneration(ctx context.Context) error
|
||||
|
||||
// GetContextGenerationStatus returns status of context operations
|
||||
GetContextGenerationStatus() (*GenerationStatus, error)
|
||||
|
||||
// RequestContextGeneration queues a context generation request
|
||||
RequestContextGeneration(req *ContextGenerationRequest) error
|
||||
|
||||
// Context leadership monitoring
|
||||
|
||||
// SetContextLeadershipCallbacks sets callbacks for context leadership changes
|
||||
SetContextLeadershipCallbacks(callbacks *ContextLeadershipCallbacks) error
|
||||
|
||||
// GetContextClusterHealth returns health of context generation cluster
|
||||
GetContextClusterHealth() (*ContextClusterHealth, error)
|
||||
|
||||
// Failover and recovery
|
||||
|
||||
// PrepareContextFailover prepares context state for leadership failover
|
||||
PrepareContextFailover(ctx context.Context) (*ContextFailoverState, error)
|
||||
|
||||
// ExecuteContextFailover executes context leadership failover
|
||||
ExecuteContextFailover(ctx context.Context, state *ContextFailoverState) error
|
||||
|
||||
// ValidateContextState validates context failover state
|
||||
ValidateContextState(state *ContextFailoverState) (*ContextStateValidation, error)
|
||||
}
|
||||
|
||||
// Election represents the base election interface (extracted from existing code)
|
||||
type Election interface {
|
||||
// Basic election operations
|
||||
Start() error
|
||||
Stop()
|
||||
TriggerElection(trigger ElectionTrigger)
|
||||
|
||||
// Leadership queries
|
||||
GetCurrentAdmin() string
|
||||
IsCurrentAdmin() bool
|
||||
GetElectionState() ElectionState
|
||||
|
||||
// Callback management
|
||||
SetCallbacks(onAdminChanged func(oldAdmin, newAdmin string), onElectionComplete func(winner string))
|
||||
|
||||
// Admin operations
|
||||
SendAdminHeartbeat() error
|
||||
}
|
||||
|
||||
// ContextLeadershipCallbacks is defined in interfaces.go
|
||||
|
||||
// ContextClusterHealth represents health of context generation cluster
|
||||
type ContextClusterHealth struct {
|
||||
TotalNodes int `json:"total_nodes"` // Total nodes in cluster
|
||||
HealthyNodes int `json:"healthy_nodes"` // Healthy nodes
|
||||
UnhealthyNodes []string `json:"unhealthy_nodes"` // Unhealthy node IDs
|
||||
CurrentLeader string `json:"current_leader"` // Current context leader
|
||||
LeaderHealthy bool `json:"leader_healthy"` // Leader health status
|
||||
GenerationActive bool `json:"generation_active"` // Context generation status
|
||||
QueueHealth *QueueHealthStatus `json:"queue_health"` // Queue health
|
||||
NodeHealths map[string]*NodeHealthStatus `json:"node_healths"` // Per-node health
|
||||
LastElection time.Time `json:"last_election"` // Last election time
|
||||
NextHealthCheck time.Time `json:"next_health_check"` // Next health check
|
||||
OverallHealthScore float64 `json:"overall_health_score"` // Overall health (0-1)
|
||||
}
|
||||
|
||||
// QueueHealthStatus represents health of context generation queue
|
||||
type QueueHealthStatus struct {
|
||||
QueueLength int `json:"queue_length"` // Current queue length
|
||||
MaxQueueSize int `json:"max_queue_size"` // Maximum queue capacity
|
||||
QueueUtilization float64 `json:"queue_utilization"` // Queue utilization (0-1)
|
||||
ProcessingRate float64 `json:"processing_rate"` // Requests per second
|
||||
AverageWaitTime time.Duration `json:"average_wait_time"` // Average wait time
|
||||
OldestRequest *time.Time `json:"oldest_request"` // Oldest queued request
|
||||
HealthScore float64 `json:"health_score"` // Queue health score (0-1)
|
||||
Issues []string `json:"issues,omitempty"` // Queue health issues
|
||||
}
|
||||
|
||||
// NodeHealthStatus represents health status of individual node
|
||||
type NodeHealthStatus struct {
|
||||
NodeID string `json:"node_id"` // Node ID
|
||||
IsLeader bool `json:"is_leader"` // Whether node is leader
|
||||
LastHeartbeat time.Time `json:"last_heartbeat"` // Last heartbeat
|
||||
ResponseTime time.Duration `json:"response_time"` // Response time
|
||||
LoadAverage float64 `json:"load_average"` // System load
|
||||
ActiveTasks int `json:"active_tasks"` // Active context tasks
|
||||
CompletedTasks int64 `json:"completed_tasks"` // Completed tasks
|
||||
FailedTasks int64 `json:"failed_tasks"` // Failed tasks
|
||||
HealthScore float64 `json:"health_score"` // Health score (0-1)
|
||||
Status NodeStatus `json:"status"` // Node status
|
||||
Issues []string `json:"issues,omitempty"` // Health issues
|
||||
}
|
||||
|
||||
// NodeStatus represents status of cluster node
|
||||
type NodeStatus string
|
||||
|
||||
const (
|
||||
NodeStatusHealthy NodeStatus = "healthy" // Node is healthy
|
||||
NodeStatusDegraded NodeStatus = "degraded" // Node performance degraded
|
||||
NodeStatusUnhealthy NodeStatus = "unhealthy" // Node is unhealthy
|
||||
NodeStatusUnresponsive NodeStatus = "unresponsive" // Node not responding
|
||||
NodeStatusOffline NodeStatus = "offline" // Node is offline
|
||||
)
|
||||
|
||||
// ContextFailoverState represents state to transfer during context leadership failover
|
||||
type ContextFailoverState struct {
|
||||
// Basic failover state
|
||||
LeaderID string `json:"leader_id"` // Previous leader
|
||||
Term int64 `json:"term"` // Leadership term
|
||||
TransferTime time.Time `json:"transfer_time"` // When transfer occurred
|
||||
|
||||
// Context generation state
|
||||
QueuedRequests []*ContextGenerationRequest `json:"queued_requests"` // Queued requests
|
||||
ActiveJobs map[string]*ContextGenerationJob `json:"active_jobs"` // Active jobs
|
||||
CompletedJobs []*ContextGenerationJob `json:"completed_jobs"` // Recent completed jobs
|
||||
|
||||
// Cluster coordination state
|
||||
ClusterState *ClusterState `json:"cluster_state"` // Current cluster state
|
||||
ResourceAllocations map[string]*ResourceAllocation `json:"resource_allocations"` // Resource allocations
|
||||
NodeAssignments map[string][]string `json:"node_assignments"` // Task assignments per node
|
||||
|
||||
// Configuration state
|
||||
ManagerConfig *ManagerConfig `json:"manager_config"` // Manager configuration
|
||||
GenerationPolicy *GenerationPolicy `json:"generation_policy"` // Generation policy
|
||||
QueuePolicy *QueuePolicy `json:"queue_policy"` // Queue policy
|
||||
|
||||
// State validation
|
||||
StateVersion int64 `json:"state_version"` // State version
|
||||
Checksum string `json:"checksum"` // State checksum
|
||||
HealthSnapshot *ContextClusterHealth `json:"health_snapshot"` // Health at transfer
|
||||
|
||||
// Transfer metadata
|
||||
TransferReason string `json:"transfer_reason"` // Reason for transfer
|
||||
TransferSource string `json:"transfer_source"` // Who initiated transfer
|
||||
TransferDuration time.Duration `json:"transfer_duration"` // How long transfer took
|
||||
ValidationResults *ContextStateValidation `json:"validation_results"` // State validation results
|
||||
}
|
||||
|
||||
// ContextStateValidation represents validation results for failover state
|
||||
type ContextStateValidation struct {
|
||||
Valid bool `json:"valid"` // Overall validity
|
||||
Issues []string `json:"issues,omitempty"` // Validation issues
|
||||
|
||||
// Component validations
|
||||
ChecksumValid bool `json:"checksum_valid"` // Checksum validation
|
||||
VersionConsistent bool `json:"version_consistent"` // Version consistency
|
||||
TimestampValid bool `json:"timestamp_valid"` // Timestamp validity
|
||||
QueueStateValid bool `json:"queue_state_valid"` // Queue state validity
|
||||
ClusterStateValid bool `json:"cluster_state_valid"` // Cluster state validity
|
||||
ConfigValid bool `json:"config_valid"` // Configuration validity
|
||||
|
||||
// Validation metadata
|
||||
ValidatedAt time.Time `json:"validated_at"` // When validation occurred
|
||||
ValidatedBy string `json:"validated_by"` // Node that performed validation
|
||||
ValidationDuration time.Duration `json:"validation_duration"` // Time taken for validation
|
||||
|
||||
// Recommendations
|
||||
Recommendations []string `json:"recommendations,omitempty"` // Recommendations for issues
|
||||
RequiresRecovery bool `json:"requires_recovery"` // Whether recovery is needed
|
||||
RecoverySteps []string `json:"recovery_steps,omitempty"` // Recovery steps if needed
|
||||
}
|
||||
|
||||
// ErrorSeverity is defined in interfaces.go
|
||||
|
||||
// SLURPElectionConfig represents configuration for SLURP-enhanced elections
|
||||
type SLURPElectionConfig struct {
|
||||
// Context leadership configuration
|
||||
EnableContextLeadership bool `json:"enable_context_leadership"` // Enable context leadership
|
||||
ContextLeadershipWeight float64 `json:"context_leadership_weight"` // Weight for context leadership scoring
|
||||
RequireContextCapability bool `json:"require_context_capability"` // Require context capability for leadership
|
||||
|
||||
// Context generation configuration
|
||||
AutoStartGeneration bool `json:"auto_start_generation"` // Auto-start generation on leadership
|
||||
GenerationStartDelay time.Duration `json:"generation_start_delay"` // Delay before starting generation
|
||||
GenerationStopTimeout time.Duration `json:"generation_stop_timeout"` // Timeout for stopping generation
|
||||
|
||||
// Failover configuration
|
||||
ContextFailoverTimeout time.Duration `json:"context_failover_timeout"` // Context failover timeout
|
||||
StateTransferTimeout time.Duration `json:"state_transfer_timeout"` // State transfer timeout
|
||||
ValidationTimeout time.Duration `json:"validation_timeout"` // State validation timeout
|
||||
RequireStateValidation bool `json:"require_state_validation"` // Require state validation
|
||||
|
||||
// Health monitoring configuration
|
||||
ContextHealthCheckInterval time.Duration `json:"context_health_check_interval"` // Context health check interval
|
||||
ClusterHealthThreshold float64 `json:"cluster_health_threshold"` // Minimum cluster health for operations
|
||||
LeaderHealthThreshold float64 `json:"leader_health_threshold"` // Minimum leader health
|
||||
|
||||
// Queue management configuration
|
||||
MaxQueueTransferSize int `json:"max_queue_transfer_size"` // Max requests to transfer
|
||||
QueueDrainTimeout time.Duration `json:"queue_drain_timeout"` // Timeout for draining queue
|
||||
PreserveCompletedJobs bool `json:"preserve_completed_jobs"` // Preserve completed jobs on transfer
|
||||
|
||||
// Coordination configuration
|
||||
CoordinationTimeout time.Duration `json:"coordination_timeout"` // Coordination operation timeout
|
||||
MaxCoordinationRetries int `json:"max_coordination_retries"` // Max coordination retries
|
||||
CoordinationBackoff time.Duration `json:"coordination_backoff"` // Backoff between coordination retries
|
||||
}
|
||||
|
||||
// DefaultSLURPElectionConfig returns default configuration for SLURP elections
|
||||
func DefaultSLURPElectionConfig() *SLURPElectionConfig {
|
||||
return &SLURPElectionConfig{
|
||||
EnableContextLeadership: true,
|
||||
ContextLeadershipWeight: 0.3, // 30% weight for context capabilities
|
||||
RequireContextCapability: true,
|
||||
|
||||
AutoStartGeneration: true,
|
||||
GenerationStartDelay: 5 * time.Second,
|
||||
GenerationStopTimeout: 30 * time.Second,
|
||||
|
||||
ContextFailoverTimeout: 60 * time.Second,
|
||||
StateTransferTimeout: 30 * time.Second,
|
||||
ValidationTimeout: 10 * time.Second,
|
||||
RequireStateValidation: true,
|
||||
|
||||
ContextHealthCheckInterval: 30 * time.Second,
|
||||
ClusterHealthThreshold: 0.7, // 70% minimum cluster health
|
||||
LeaderHealthThreshold: 0.8, // 80% minimum leader health
|
||||
|
||||
MaxQueueTransferSize: 1000,
|
||||
QueueDrainTimeout: 60 * time.Second,
|
||||
PreserveCompletedJobs: true,
|
||||
|
||||
CoordinationTimeout: 10 * time.Second,
|
||||
MaxCoordinationRetries: 3,
|
||||
CoordinationBackoff: 2 * time.Second,
|
||||
}
|
||||
}
|
||||
772
pkg/election/slurp_manager.go
Normal file
772
pkg/election/slurp_manager.go
Normal file
@@ -0,0 +1,772 @@
|
||||
package election
|
||||
|
||||
import (
|
||||
"context"
|
||||
"crypto/md5"
|
||||
"encoding/json"
|
||||
"fmt"
|
||||
"log"
|
||||
"sync"
|
||||
"time"
|
||||
|
||||
"chorus.services/bzzz/pkg/config"
|
||||
"chorus.services/bzzz/pubsub"
|
||||
libp2p "github.com/libp2p/go-libp2p/core/host"
|
||||
)
|
||||
|
||||
// SLURPElectionManager extends ElectionManager with SLURP contextual intelligence capabilities
|
||||
type SLURPElectionManager struct {
|
||||
*ElectionManager // Embed base election manager
|
||||
|
||||
// SLURP-specific state
|
||||
contextMu sync.RWMutex
|
||||
contextManager ContextManager
|
||||
slurpConfig *SLURPElectionConfig
|
||||
contextCallbacks *ContextLeadershipCallbacks
|
||||
|
||||
// Context leadership state
|
||||
isContextLeader bool
|
||||
contextTerm int64
|
||||
contextStartedAt *time.Time
|
||||
lastHealthCheck time.Time
|
||||
|
||||
// Failover state
|
||||
failoverState *ContextFailoverState
|
||||
transferInProgress bool
|
||||
|
||||
// Monitoring
|
||||
healthMonitor *ContextHealthMonitor
|
||||
metricsCollector *ContextMetricsCollector
|
||||
|
||||
// Shutdown coordination
|
||||
contextShutdown chan struct{}
|
||||
contextWg sync.WaitGroup
|
||||
}
|
||||
|
||||
// NewSLURPElectionManager creates a new SLURP-enhanced election manager
|
||||
func NewSLURPElectionManager(
|
||||
ctx context.Context,
|
||||
cfg *config.Config,
|
||||
host libp2p.Host,
|
||||
ps *pubsub.PubSub,
|
||||
nodeID string,
|
||||
slurpConfig *SLURPElectionConfig,
|
||||
) *SLURPElectionManager {
|
||||
// Create base election manager
|
||||
baseManager := NewElectionManager(ctx, cfg, host, ps, nodeID)
|
||||
|
||||
if slurpConfig == nil {
|
||||
slurpConfig = DefaultSLURPElectionConfig()
|
||||
}
|
||||
|
||||
sem := &SLURPElectionManager{
|
||||
ElectionManager: baseManager,
|
||||
slurpConfig: slurpConfig,
|
||||
contextShutdown: make(chan struct{}),
|
||||
healthMonitor: NewContextHealthMonitor(),
|
||||
metricsCollector: NewContextMetricsCollector(),
|
||||
}
|
||||
|
||||
// Override base callbacks to include SLURP handling
|
||||
sem.setupSLURPCallbacks()
|
||||
|
||||
return sem
|
||||
}
|
||||
|
||||
// RegisterContextManager registers a SLURP context manager for leader duties
|
||||
func (sem *SLURPElectionManager) RegisterContextManager(manager ContextManager) error {
|
||||
sem.contextMu.Lock()
|
||||
defer sem.contextMu.Unlock()
|
||||
|
||||
if sem.contextManager != nil {
|
||||
return fmt.Errorf("context manager already registered")
|
||||
}
|
||||
|
||||
sem.contextManager = manager
|
||||
|
||||
// If we're already the leader, start context generation
|
||||
if sem.IsCurrentAdmin() && sem.slurpConfig.AutoStartGeneration {
|
||||
go sem.startContextGenerationDelayed()
|
||||
}
|
||||
|
||||
log.Printf("✅ Context manager registered with SLURP election")
|
||||
return nil
|
||||
}
|
||||
|
||||
// IsContextLeader returns whether this node is the current context generation leader
|
||||
func (sem *SLURPElectionManager) IsContextLeader() bool {
|
||||
sem.contextMu.RLock()
|
||||
defer sem.contextMu.RUnlock()
|
||||
return sem.isContextLeader && sem.IsCurrentAdmin()
|
||||
}
|
||||
|
||||
// GetContextManager returns the registered context manager (if leader)
|
||||
func (sem *SLURPElectionManager) GetContextManager() (ContextManager, error) {
|
||||
sem.contextMu.RLock()
|
||||
defer sem.contextMu.RUnlock()
|
||||
|
||||
if !sem.isContextLeader {
|
||||
return nil, fmt.Errorf("not context leader")
|
||||
}
|
||||
|
||||
if sem.contextManager == nil {
|
||||
return nil, fmt.Errorf("no context manager registered")
|
||||
}
|
||||
|
||||
return sem.contextManager, nil
|
||||
}
|
||||
|
||||
// TransferContextLeadership initiates graceful context leadership transfer
|
||||
func (sem *SLURPElectionManager) TransferContextLeadership(ctx context.Context, targetNodeID string) error {
|
||||
if !sem.IsContextLeader() {
|
||||
return fmt.Errorf("not context leader, cannot transfer")
|
||||
}
|
||||
|
||||
sem.contextMu.Lock()
|
||||
if sem.transferInProgress {
|
||||
sem.contextMu.Unlock()
|
||||
return fmt.Errorf("transfer already in progress")
|
||||
}
|
||||
sem.transferInProgress = true
|
||||
sem.contextMu.Unlock()
|
||||
|
||||
defer func() {
|
||||
sem.contextMu.Lock()
|
||||
sem.transferInProgress = false
|
||||
sem.contextMu.Unlock()
|
||||
}()
|
||||
|
||||
log.Printf("🔄 Initiating context leadership transfer to %s", targetNodeID)
|
||||
|
||||
// Prepare failover state
|
||||
state, err := sem.PrepareContextFailover(ctx)
|
||||
if err != nil {
|
||||
return fmt.Errorf("failed to prepare context failover: %w", err)
|
||||
}
|
||||
|
||||
// Send transfer message
|
||||
transferMsg := ElectionMessage{
|
||||
Type: "context_leadership_transfer",
|
||||
NodeID: sem.nodeID,
|
||||
Timestamp: time.Now(),
|
||||
Term: int(sem.contextTerm),
|
||||
Data: map[string]interface{}{
|
||||
"target_node": targetNodeID,
|
||||
"failover_state": state,
|
||||
"reason": "manual_transfer",
|
||||
},
|
||||
}
|
||||
|
||||
if err := sem.publishElectionMessage(transferMsg); err != nil {
|
||||
return fmt.Errorf("failed to send transfer message: %w", err)
|
||||
}
|
||||
|
||||
// Stop context generation
|
||||
if err := sem.StopContextGeneration(ctx); err != nil {
|
||||
log.Printf("⚠️ Error stopping context generation during transfer: %v", err)
|
||||
}
|
||||
|
||||
// Trigger new election if needed
|
||||
sem.TriggerElection(TriggerManual)
|
||||
|
||||
log.Printf("✅ Context leadership transfer initiated")
|
||||
return nil
|
||||
}
|
||||
|
||||
// GetContextLeaderInfo returns information about current context leader
|
||||
func (sem *SLURPElectionManager) GetContextLeaderInfo() (*LeaderInfo, error) {
|
||||
sem.contextMu.RLock()
|
||||
defer sem.contextMu.RUnlock()
|
||||
|
||||
leaderID := sem.GetCurrentAdmin()
|
||||
if leaderID == "" {
|
||||
return nil, fmt.Errorf("no current leader")
|
||||
}
|
||||
|
||||
info := &LeaderInfo{
|
||||
NodeID: leaderID,
|
||||
Term: sem.contextTerm,
|
||||
ElectedAt: time.Now(), // TODO: Track actual election time
|
||||
// Version: "1.0.0", // TODO: Add Version field to LeaderInfo struct
|
||||
}
|
||||
|
||||
// TODO: Add missing fields to LeaderInfo struct
|
||||
// if sem.isContextLeader && sem.contextStartedAt != nil {
|
||||
// info.ActiveSince = time.Since(*sem.contextStartedAt)
|
||||
// }
|
||||
|
||||
// Add generation capacity and load info
|
||||
// if sem.contextManager != nil && sem.isContextLeader {
|
||||
// if status, err := sem.contextManager.GetGenerationStatus(); err == nil {
|
||||
// info.GenerationCapacity = 100 // TODO: Get from config
|
||||
// if status.ActiveTasks > 0 {
|
||||
// info.CurrentLoad = float64(status.ActiveTasks) / float64(info.GenerationCapacity)
|
||||
// }
|
||||
// info.HealthStatus = "healthy" // TODO: Get from health monitor
|
||||
// }
|
||||
// }
|
||||
|
||||
return info, nil
|
||||
}
|
||||
|
||||
// StartContextGeneration begins context generation operations (leader only)
|
||||
func (sem *SLURPElectionManager) StartContextGeneration(ctx context.Context) error {
|
||||
if !sem.IsCurrentAdmin() {
|
||||
return fmt.Errorf("not admin, cannot start context generation")
|
||||
}
|
||||
|
||||
sem.contextMu.Lock()
|
||||
defer sem.contextMu.Unlock()
|
||||
|
||||
if sem.isContextLeader {
|
||||
return fmt.Errorf("context generation already active")
|
||||
}
|
||||
|
||||
if sem.contextManager == nil {
|
||||
return fmt.Errorf("no context manager registered")
|
||||
}
|
||||
|
||||
log.Printf("🚀 Starting context generation as leader")
|
||||
|
||||
// Mark as context leader
|
||||
sem.isContextLeader = true
|
||||
sem.contextTerm++
|
||||
now := time.Now()
|
||||
sem.contextStartedAt = &now
|
||||
|
||||
// Start background processes
|
||||
sem.contextWg.Add(2)
|
||||
go sem.runHealthMonitoring()
|
||||
go sem.runMetricsCollection()
|
||||
|
||||
// Call callback
|
||||
if sem.contextCallbacks != nil && sem.contextCallbacks.OnBecomeContextLeader != nil {
|
||||
if err := sem.contextCallbacks.OnBecomeContextLeader(ctx, sem.contextTerm); err != nil {
|
||||
log.Printf("⚠️ Context leadership callback error: %v", err)
|
||||
}
|
||||
}
|
||||
|
||||
if sem.contextCallbacks != nil && sem.contextCallbacks.OnContextGenerationStarted != nil {
|
||||
sem.contextCallbacks.OnContextGenerationStarted(sem.nodeID)
|
||||
}
|
||||
|
||||
// Broadcast context leadership start
|
||||
startMsg := ElectionMessage{
|
||||
Type: "context_generation_started",
|
||||
NodeID: sem.nodeID,
|
||||
Timestamp: time.Now(),
|
||||
Term: int(sem.contextTerm),
|
||||
Data: map[string]interface{}{
|
||||
"leader_id": sem.nodeID,
|
||||
},
|
||||
}
|
||||
|
||||
if err := sem.publishElectionMessage(startMsg); err != nil {
|
||||
log.Printf("⚠️ Failed to broadcast context generation start: %v", err)
|
||||
}
|
||||
|
||||
log.Printf("✅ Context generation started successfully")
|
||||
return nil
|
||||
}
|
||||
|
||||
// StopContextGeneration stops context generation operations
|
||||
func (sem *SLURPElectionManager) StopContextGeneration(ctx context.Context) error {
|
||||
sem.contextMu.Lock()
|
||||
isLeader := sem.isContextLeader
|
||||
sem.contextMu.Unlock()
|
||||
|
||||
if !isLeader {
|
||||
return nil // Already stopped
|
||||
}
|
||||
|
||||
log.Printf("⏹️ Stopping context generation")
|
||||
|
||||
// Signal shutdown to background processes
|
||||
select {
|
||||
case <-sem.contextShutdown:
|
||||
// Already shutting down
|
||||
default:
|
||||
close(sem.contextShutdown)
|
||||
}
|
||||
|
||||
// Wait for background processes with timeout
|
||||
done := make(chan struct{})
|
||||
go func() {
|
||||
sem.contextWg.Wait()
|
||||
close(done)
|
||||
}()
|
||||
|
||||
select {
|
||||
case <-done:
|
||||
log.Printf("✅ Background processes stopped cleanly")
|
||||
case <-time.After(sem.slurpConfig.GenerationStopTimeout):
|
||||
log.Printf("⚠️ Timeout waiting for background processes to stop")
|
||||
}
|
||||
|
||||
sem.contextMu.Lock()
|
||||
sem.isContextLeader = false
|
||||
sem.contextStartedAt = nil
|
||||
sem.contextMu.Unlock()
|
||||
|
||||
// Call callbacks
|
||||
if sem.contextCallbacks != nil && sem.contextCallbacks.OnLoseContextLeadership != nil {
|
||||
if err := sem.contextCallbacks.OnLoseContextLeadership(ctx, ""); err != nil {
|
||||
log.Printf("⚠️ Context leadership loss callback error: %v", err)
|
||||
}
|
||||
}
|
||||
|
||||
if sem.contextCallbacks != nil && sem.contextCallbacks.OnContextGenerationStopped != nil {
|
||||
sem.contextCallbacks.OnContextGenerationStopped(sem.nodeID, "leadership_lost")
|
||||
}
|
||||
|
||||
// Broadcast context generation stop
|
||||
stopMsg := ElectionMessage{
|
||||
Type: "context_generation_stopped",
|
||||
NodeID: sem.nodeID,
|
||||
Timestamp: time.Now(),
|
||||
Term: int(sem.contextTerm),
|
||||
Data: map[string]interface{}{
|
||||
"reason": "leadership_lost",
|
||||
},
|
||||
}
|
||||
|
||||
if err := sem.publishElectionMessage(stopMsg); err != nil {
|
||||
log.Printf("⚠️ Failed to broadcast context generation stop: %v", err)
|
||||
}
|
||||
|
||||
// Reset shutdown channel for next start
|
||||
sem.contextShutdown = make(chan struct{})
|
||||
|
||||
log.Printf("✅ Context generation stopped")
|
||||
return nil
|
||||
}
|
||||
|
||||
// GetContextGenerationStatus returns status of context operations
|
||||
func (sem *SLURPElectionManager) GetContextGenerationStatus() (*GenerationStatus, error) {
|
||||
sem.contextMu.RLock()
|
||||
manager := sem.contextManager
|
||||
// isLeader := sem.isContextLeader // TODO: Use when IsLeader field is added
|
||||
sem.contextMu.RUnlock()
|
||||
|
||||
if manager == nil {
|
||||
return &GenerationStatus{
|
||||
// IsLeader: false, // TODO: Add IsLeader field to GenerationStatus
|
||||
LeaderID: sem.GetCurrentAdmin(),
|
||||
// LastUpdate: time.Now(), // TODO: Add LastUpdate field to GenerationStatus
|
||||
}, nil
|
||||
}
|
||||
|
||||
status, err := manager.GetGenerationStatus()
|
||||
if err != nil {
|
||||
return nil, err
|
||||
}
|
||||
|
||||
// Override leader status from election state
|
||||
// status.IsLeader = isLeader // TODO: Add IsLeader field to GenerationStatus
|
||||
status.LeaderID = sem.GetCurrentAdmin()
|
||||
|
||||
return status, nil
|
||||
}
|
||||
|
||||
// RequestContextGeneration queues a context generation request
|
||||
func (sem *SLURPElectionManager) RequestContextGeneration(req *ContextGenerationRequest) error {
|
||||
sem.contextMu.RLock()
|
||||
manager := sem.contextManager
|
||||
isLeader := sem.isContextLeader
|
||||
sem.contextMu.RUnlock()
|
||||
|
||||
if !isLeader {
|
||||
return fmt.Errorf("not context leader")
|
||||
}
|
||||
|
||||
if manager == nil {
|
||||
return fmt.Errorf("no context manager registered")
|
||||
}
|
||||
|
||||
return manager.RequestContextGeneration(req)
|
||||
}
|
||||
|
||||
// SetContextLeadershipCallbacks sets callbacks for context leadership changes
|
||||
func (sem *SLURPElectionManager) SetContextLeadershipCallbacks(callbacks *ContextLeadershipCallbacks) error {
|
||||
sem.contextMu.Lock()
|
||||
defer sem.contextMu.Unlock()
|
||||
|
||||
sem.contextCallbacks = callbacks
|
||||
return nil
|
||||
}
|
||||
|
||||
// GetContextClusterHealth returns health of context generation cluster
|
||||
func (sem *SLURPElectionManager) GetContextClusterHealth() (*ContextClusterHealth, error) {
|
||||
return sem.healthMonitor.GetClusterHealth(), nil
|
||||
}
|
||||
|
||||
// PrepareContextFailover prepares context state for leadership failover
|
||||
func (sem *SLURPElectionManager) PrepareContextFailover(ctx context.Context) (*ContextFailoverState, error) {
|
||||
if !sem.IsContextLeader() {
|
||||
return nil, fmt.Errorf("not context leader")
|
||||
}
|
||||
|
||||
sem.contextMu.Lock()
|
||||
defer sem.contextMu.Unlock()
|
||||
|
||||
log.Printf("📦 Preparing context failover state")
|
||||
|
||||
state := &ContextFailoverState{
|
||||
LeaderID: sem.nodeID,
|
||||
Term: sem.contextTerm,
|
||||
TransferTime: time.Now(),
|
||||
StateVersion: time.Now().Unix(),
|
||||
}
|
||||
|
||||
// Get current state from context manager
|
||||
if sem.contextManager != nil {
|
||||
// Get queued requests (if supported)
|
||||
// TODO: Add interface method to get queued requests
|
||||
state.QueuedRequests = []*ContextGenerationRequest{}
|
||||
|
||||
// Get active jobs (if supported)
|
||||
// TODO: Add interface method to get active jobs
|
||||
state.ActiveJobs = make(map[string]*ContextGenerationJob)
|
||||
|
||||
// Get manager configuration
|
||||
// TODO: Add interface method to get configuration
|
||||
state.ManagerConfig = DefaultManagerConfig()
|
||||
}
|
||||
|
||||
// Get cluster health snapshot
|
||||
if health, err := sem.GetContextClusterHealth(); err == nil {
|
||||
state.HealthSnapshot = health
|
||||
}
|
||||
|
||||
// Calculate checksum
|
||||
if data, err := json.Marshal(state); err == nil {
|
||||
hash := md5.Sum(data)
|
||||
state.Checksum = fmt.Sprintf("%x", hash)
|
||||
}
|
||||
|
||||
sem.failoverState = state
|
||||
|
||||
log.Printf("✅ Context failover state prepared (version: %d)", state.StateVersion)
|
||||
return state, nil
|
||||
}
|
||||
|
||||
// ExecuteContextFailover executes context leadership failover
|
||||
func (sem *SLURPElectionManager) ExecuteContextFailover(ctx context.Context, state *ContextFailoverState) error {
|
||||
if sem.IsContextLeader() {
|
||||
return fmt.Errorf("already context leader")
|
||||
}
|
||||
|
||||
log.Printf("🔄 Executing context failover from state (version: %d)", state.StateVersion)
|
||||
|
||||
// Validate state first
|
||||
validation, err := sem.ValidateContextState(state)
|
||||
if err != nil {
|
||||
return fmt.Errorf("failed to validate failover state: %w", err)
|
||||
}
|
||||
|
||||
if !validation.Valid {
|
||||
return fmt.Errorf("invalid failover state: %v", validation.Issues)
|
||||
}
|
||||
|
||||
sem.contextMu.Lock()
|
||||
defer sem.contextMu.Unlock()
|
||||
|
||||
// Restore context leadership state
|
||||
sem.isContextLeader = true
|
||||
sem.contextTerm = state.Term + 1 // Increment term
|
||||
now := time.Now()
|
||||
sem.contextStartedAt = &now
|
||||
|
||||
// TODO: Restore queued requests to context manager
|
||||
// TODO: Restore active jobs to context manager
|
||||
// TODO: Apply manager configuration
|
||||
|
||||
// Start background processes
|
||||
sem.contextWg.Add(2)
|
||||
go sem.runHealthMonitoring()
|
||||
go sem.runMetricsCollection()
|
||||
|
||||
log.Printf("✅ Context failover executed successfully (new term: %d)", sem.contextTerm)
|
||||
return nil
|
||||
}
|
||||
|
||||
// ValidateContextState validates context failover state
|
||||
func (sem *SLURPElectionManager) ValidateContextState(state *ContextFailoverState) (*ContextStateValidation, error) {
|
||||
if state == nil {
|
||||
return &ContextStateValidation{
|
||||
Valid: false,
|
||||
Issues: []string{"nil failover state"},
|
||||
ValidatedAt: time.Now(),
|
||||
}, nil
|
||||
}
|
||||
|
||||
validation := &ContextStateValidation{
|
||||
ValidatedAt: time.Now(),
|
||||
ValidatedBy: sem.nodeID,
|
||||
Valid: true,
|
||||
}
|
||||
|
||||
// Check basic fields
|
||||
if state.LeaderID == "" {
|
||||
validation.Issues = append(validation.Issues, "missing leader ID")
|
||||
validation.Valid = false
|
||||
}
|
||||
|
||||
if state.Term <= 0 {
|
||||
validation.Issues = append(validation.Issues, "invalid term")
|
||||
validation.Valid = false
|
||||
}
|
||||
|
||||
if state.StateVersion <= 0 {
|
||||
validation.Issues = append(validation.Issues, "invalid state version")
|
||||
validation.Valid = false
|
||||
}
|
||||
|
||||
// Validate checksum
|
||||
if state.Checksum != "" {
|
||||
tempState := *state
|
||||
tempState.Checksum = ""
|
||||
if data, err := json.Marshal(tempState); err == nil {
|
||||
hash := md5.Sum(data)
|
||||
expectedChecksum := fmt.Sprintf("%x", hash)
|
||||
validation.ChecksumValid = expectedChecksum == state.Checksum
|
||||
if !validation.ChecksumValid {
|
||||
validation.Issues = append(validation.Issues, "checksum validation failed")
|
||||
validation.Valid = false
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
// Validate timestamps
|
||||
if state.TransferTime.IsZero() {
|
||||
validation.Issues = append(validation.Issues, "missing transfer time")
|
||||
validation.TimestampValid = false
|
||||
validation.Valid = false
|
||||
} else {
|
||||
validation.TimestampValid = true
|
||||
}
|
||||
|
||||
// Version consistency check
|
||||
validation.VersionConsistent = true // TODO: Implement actual version checking
|
||||
|
||||
// Queue state validation
|
||||
validation.QueueStateValid = state.QueuedRequests != nil
|
||||
if !validation.QueueStateValid {
|
||||
validation.Issues = append(validation.Issues, "invalid queue state")
|
||||
}
|
||||
|
||||
// Cluster state validation
|
||||
validation.ClusterStateValid = state.ClusterState != nil
|
||||
if !validation.ClusterStateValid {
|
||||
validation.Issues = append(validation.Issues, "missing cluster state")
|
||||
}
|
||||
|
||||
// Config validation
|
||||
validation.ConfigValid = state.ManagerConfig != nil
|
||||
if !validation.ConfigValid {
|
||||
validation.Issues = append(validation.Issues, "missing manager configuration")
|
||||
}
|
||||
|
||||
// Set recovery requirements
|
||||
if len(validation.Issues) > 0 {
|
||||
validation.RequiresRecovery = true
|
||||
validation.RecoverySteps = []string{
|
||||
"Review validation issues",
|
||||
"Perform partial state recovery",
|
||||
"Restart context generation with defaults",
|
||||
}
|
||||
}
|
||||
|
||||
validation.ValidationDuration = time.Since(validation.ValidatedAt)
|
||||
|
||||
return validation, nil
|
||||
}
|
||||
|
||||
// setupSLURPCallbacks configures the base election manager with SLURP-aware callbacks
|
||||
func (sem *SLURPElectionManager) setupSLURPCallbacks() {
|
||||
sem.SetCallbacks(
|
||||
sem.onAdminChangedSLURP,
|
||||
sem.onElectionCompleteSLURP,
|
||||
)
|
||||
}
|
||||
|
||||
// onAdminChangedSLURP handles admin changes with SLURP context awareness
|
||||
func (sem *SLURPElectionManager) onAdminChangedSLURP(oldAdmin, newAdmin string) {
|
||||
log.Printf("🔄 Admin changed: %s -> %s (SLURP-aware)", oldAdmin, newAdmin)
|
||||
|
||||
// If we lost leadership, stop context generation
|
||||
if oldAdmin == sem.nodeID && newAdmin != sem.nodeID {
|
||||
if err := sem.StopContextGeneration(context.Background()); err != nil {
|
||||
log.Printf("⚠️ Error stopping context generation: %v", err)
|
||||
}
|
||||
}
|
||||
|
||||
// If we gained leadership, start context generation
|
||||
if newAdmin == sem.nodeID && oldAdmin != sem.nodeID {
|
||||
if sem.slurpConfig.AutoStartGeneration {
|
||||
go sem.startContextGenerationDelayed()
|
||||
}
|
||||
}
|
||||
|
||||
// Call context callbacks
|
||||
if sem.contextCallbacks != nil && sem.contextCallbacks.OnContextLeaderChanged != nil {
|
||||
sem.contextCallbacks.OnContextLeaderChanged(oldAdmin, newAdmin, sem.contextTerm)
|
||||
}
|
||||
}
|
||||
|
||||
// onElectionCompleteSLURP handles election completion with SLURP context awareness
|
||||
func (sem *SLURPElectionManager) onElectionCompleteSLURP(winner string) {
|
||||
log.Printf("🏆 Election complete: %s (SLURP-aware)", winner)
|
||||
|
||||
// Update context term on election completion
|
||||
sem.contextMu.Lock()
|
||||
sem.contextTerm++
|
||||
sem.contextMu.Unlock()
|
||||
}
|
||||
|
||||
// startContextGenerationDelayed starts context generation after a delay
|
||||
func (sem *SLURPElectionManager) startContextGenerationDelayed() {
|
||||
time.Sleep(sem.slurpConfig.GenerationStartDelay)
|
||||
|
||||
if err := sem.StartContextGeneration(context.Background()); err != nil {
|
||||
log.Printf("⚠️ Error starting context generation: %v", err)
|
||||
}
|
||||
}
|
||||
|
||||
// runHealthMonitoring runs background health monitoring
|
||||
func (sem *SLURPElectionManager) runHealthMonitoring() {
|
||||
defer sem.contextWg.Done()
|
||||
|
||||
ticker := time.NewTicker(sem.slurpConfig.ContextHealthCheckInterval)
|
||||
defer ticker.Stop()
|
||||
|
||||
for {
|
||||
select {
|
||||
case <-ticker.C:
|
||||
sem.performHealthCheck()
|
||||
case <-sem.contextShutdown:
|
||||
return
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
// runMetricsCollection runs background metrics collection
|
||||
func (sem *SLURPElectionManager) runMetricsCollection() {
|
||||
defer sem.contextWg.Done()
|
||||
|
||||
ticker := time.NewTicker(30 * time.Second) // TODO: Make configurable
|
||||
defer ticker.Stop()
|
||||
|
||||
for {
|
||||
select {
|
||||
case <-ticker.C:
|
||||
sem.collectMetrics()
|
||||
case <-sem.contextShutdown:
|
||||
return
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
// performHealthCheck performs a context health check
|
||||
func (sem *SLURPElectionManager) performHealthCheck() {
|
||||
sem.contextMu.Lock()
|
||||
sem.lastHealthCheck = time.Now()
|
||||
sem.contextMu.Unlock()
|
||||
|
||||
// TODO: Implement actual health checking logic
|
||||
if sem.contextManager != nil && sem.isContextLeader {
|
||||
if status, err := sem.contextManager.GetGenerationStatus(); err != nil {
|
||||
if sem.contextCallbacks != nil && sem.contextCallbacks.OnContextError != nil {
|
||||
sem.contextCallbacks.OnContextError(err, ErrorSeverityMedium)
|
||||
}
|
||||
} else {
|
||||
// Update health monitor with status
|
||||
sem.healthMonitor.UpdateGenerationStatus(status)
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
// collectMetrics collects context generation metrics
|
||||
func (sem *SLURPElectionManager) collectMetrics() {
|
||||
// TODO: Implement metrics collection
|
||||
sem.metricsCollector.CollectMetrics(sem)
|
||||
}
|
||||
|
||||
// Stop overrides the base Stop to include SLURP cleanup
|
||||
func (sem *SLURPElectionManager) Stop() {
|
||||
log.Printf("🛑 Stopping SLURP election manager")
|
||||
|
||||
// Stop context generation first
|
||||
if err := sem.StopContextGeneration(context.Background()); err != nil {
|
||||
log.Printf("⚠️ Error stopping context generation: %v", err)
|
||||
}
|
||||
|
||||
// Stop base election manager
|
||||
sem.ElectionManager.Stop()
|
||||
|
||||
log.Printf("✅ SLURP election manager stopped")
|
||||
}
|
||||
|
||||
// Placeholder types for health monitoring and metrics collection
|
||||
|
||||
// ContextHealthMonitor monitors the health of context generation cluster
|
||||
type ContextHealthMonitor struct {
|
||||
mu sync.RWMutex
|
||||
lastHealth *ContextClusterHealth
|
||||
lastUpdate time.Time
|
||||
}
|
||||
|
||||
// NewContextHealthMonitor creates a new context health monitor
|
||||
func NewContextHealthMonitor() *ContextHealthMonitor {
|
||||
return &ContextHealthMonitor{
|
||||
lastUpdate: time.Now(),
|
||||
}
|
||||
}
|
||||
|
||||
// GetClusterHealth returns current cluster health
|
||||
func (chm *ContextHealthMonitor) GetClusterHealth() *ContextClusterHealth {
|
||||
chm.mu.RLock()
|
||||
defer chm.mu.RUnlock()
|
||||
|
||||
if chm.lastHealth == nil {
|
||||
return &ContextClusterHealth{
|
||||
TotalNodes: 1,
|
||||
HealthyNodes: 1,
|
||||
GenerationActive: false,
|
||||
OverallHealthScore: 1.0,
|
||||
LastElection: time.Now(),
|
||||
NextHealthCheck: time.Now().Add(30 * time.Second),
|
||||
}
|
||||
}
|
||||
|
||||
return chm.lastHealth
|
||||
}
|
||||
|
||||
// UpdateGenerationStatus updates health based on generation status
|
||||
func (chm *ContextHealthMonitor) UpdateGenerationStatus(status *GenerationStatus) {
|
||||
chm.mu.Lock()
|
||||
defer chm.mu.Unlock()
|
||||
|
||||
// TODO: Implement health status update based on generation status
|
||||
chm.lastUpdate = time.Now()
|
||||
}
|
||||
|
||||
// ContextMetricsCollector collects metrics for context operations
|
||||
type ContextMetricsCollector struct {
|
||||
mu sync.RWMutex
|
||||
lastCollection time.Time
|
||||
}
|
||||
|
||||
// NewContextMetricsCollector creates a new context metrics collector
|
||||
func NewContextMetricsCollector() *ContextMetricsCollector {
|
||||
return &ContextMetricsCollector{}
|
||||
}
|
||||
|
||||
// CollectMetrics collects current metrics
|
||||
func (cmc *ContextMetricsCollector) CollectMetrics(manager *SLURPElectionManager) {
|
||||
cmc.mu.Lock()
|
||||
defer cmc.mu.Unlock()
|
||||
|
||||
// TODO: Implement metrics collection
|
||||
cmc.lastCollection = time.Now()
|
||||
}
|
||||
560
pkg/election/slurp_scoring.go
Normal file
560
pkg/election/slurp_scoring.go
Normal file
@@ -0,0 +1,560 @@
|
||||
package election
|
||||
|
||||
import (
|
||||
"fmt"
|
||||
"log"
|
||||
"time"
|
||||
|
||||
"chorus.services/bzzz/pkg/config"
|
||||
)
|
||||
|
||||
// SLURPCandidateCapabilities represents SLURP-specific capabilities for election candidates
|
||||
type SLURPCandidateCapabilities struct {
|
||||
// Context generation capabilities
|
||||
ContextGeneration bool `json:"context_generation"` // Can generate context
|
||||
ContextCuration bool `json:"context_curation"` // Can curate context
|
||||
ContextDistribution bool `json:"context_distribution"` // Can distribute context
|
||||
ContextStorage bool `json:"context_storage"` // Has context storage
|
||||
|
||||
// Intelligence capabilities
|
||||
SemanticAnalysis bool `json:"semantic_analysis"` // Can perform semantic analysis
|
||||
RAGIntegration bool `json:"rag_integration"` // Has RAG integration
|
||||
TemporalAnalysis bool `json:"temporal_analysis"` // Can do temporal analysis
|
||||
DecisionTracking bool `json:"decision_tracking"` // Can track decisions
|
||||
|
||||
// Coordination capabilities
|
||||
ClusterCoordination bool `json:"cluster_coordination"` // Can coordinate cluster
|
||||
LoadBalancing bool `json:"load_balancing"` // Can balance load
|
||||
HealthMonitoring bool `json:"health_monitoring"` // Can monitor health
|
||||
ResourceManagement bool `json:"resource_management"` // Can manage resources
|
||||
|
||||
// Quality and performance metrics
|
||||
GenerationQuality float64 `json:"generation_quality"` // Context generation quality (0-1)
|
||||
ProcessingSpeed float64 `json:"processing_speed"` // Processing speed score (0-1)
|
||||
AccuracyScore float64 `json:"accuracy_score"` // Accuracy score (0-1)
|
||||
ReliabilityScore float64 `json:"reliability_score"` // Reliability score (0-1)
|
||||
|
||||
// Historical performance
|
||||
SuccessfulOperations int64 `json:"successful_operations"` // Number of successful operations
|
||||
FailedOperations int64 `json:"failed_operations"` // Number of failed operations
|
||||
AverageResponseTime time.Duration `json:"average_response_time"` // Average response time
|
||||
UptimePercentage float64 `json:"uptime_percentage"` // Uptime percentage
|
||||
|
||||
// Specialized capabilities
|
||||
Languages []string `json:"languages"` // Programming languages supported
|
||||
Frameworks []string `json:"frameworks"` // Frameworks supported
|
||||
Technologies []string `json:"technologies"` // Technologies supported
|
||||
DomainExpertise []string `json:"domain_expertise"` // Domain expertise areas
|
||||
|
||||
// Resource availability
|
||||
AvailableCPU float64 `json:"available_cpu"` // Available CPU cores
|
||||
AvailableMemory int64 `json:"available_memory"` // Available memory in bytes
|
||||
AvailableStorage int64 `json:"available_storage"` // Available storage in bytes
|
||||
NetworkBandwidth int64 `json:"network_bandwidth"` // Network bandwidth
|
||||
|
||||
// Configuration and preferences
|
||||
MaxConcurrentTasks int `json:"max_concurrent_tasks"` // Maximum concurrent tasks
|
||||
PreferredTaskTypes []string `json:"preferred_task_types"` // Preferred task types
|
||||
SpecializationScore float64 `json:"specialization_score"` // Specialization score (0-1)
|
||||
GeneralCapabilityScore float64 `json:"general_capability_score"` // General capability score (0-1)
|
||||
}
|
||||
|
||||
// SLURPScoringWeights defines weights for SLURP-specific candidate scoring
|
||||
type SLURPScoringWeights struct {
|
||||
// Base election weights (from existing system)
|
||||
UptimeWeight float64 `json:"uptime_weight"` // Weight for uptime
|
||||
CapabilityWeight float64 `json:"capability_weight"` // Weight for capabilities
|
||||
ResourceWeight float64 `json:"resource_weight"` // Weight for resources
|
||||
NetworkWeight float64 `json:"network_weight"` // Weight for network quality
|
||||
ExperienceWeight float64 `json:"experience_weight"` // Weight for experience
|
||||
|
||||
// SLURP-specific weights
|
||||
ContextCapabilityWeight float64 `json:"context_capability_weight"` // Weight for context capabilities
|
||||
IntelligenceWeight float64 `json:"intelligence_weight"` // Weight for intelligence capabilities
|
||||
CoordinationWeight float64 `json:"coordination_weight"` // Weight for coordination capabilities
|
||||
QualityWeight float64 `json:"quality_weight"` // Weight for quality metrics
|
||||
PerformanceWeight float64 `json:"performance_weight"` // Weight for performance history
|
||||
SpecializationWeight float64 `json:"specialization_weight"` // Weight for specialization
|
||||
AvailabilityWeight float64 `json:"availability_weight"` // Weight for resource availability
|
||||
ReliabilityWeight float64 `json:"reliability_weight"` // Weight for reliability
|
||||
}
|
||||
|
||||
// SLURPCandidateScorer handles SLURP-specific candidate scoring
|
||||
type SLURPCandidateScorer struct {
|
||||
weights *SLURPScoringWeights
|
||||
config *config.Config
|
||||
|
||||
// Capability requirements
|
||||
requirements *SLURPLeadershipRequirements
|
||||
|
||||
// Performance thresholds
|
||||
minQualityScore float64
|
||||
minReliabilityScore float64
|
||||
minUptimeThreshold float64
|
||||
}
|
||||
|
||||
// SLURPLeadershipRequirements defines requirements for SLURP leadership
|
||||
type SLURPLeadershipRequirements struct {
|
||||
// Required capabilities
|
||||
RequiredCapabilities []string `json:"required_capabilities"` // Must-have capabilities
|
||||
PreferredCapabilities []string `json:"preferred_capabilities"` // Nice-to-have capabilities
|
||||
MinQualityScore float64 `json:"min_quality_score"` // Minimum quality score
|
||||
MinReliabilityScore float64 `json:"min_reliability_score"` // Minimum reliability score
|
||||
MinUptimePercentage float64 `json:"min_uptime_percentage"` // Minimum uptime percentage
|
||||
|
||||
// Resource requirements
|
||||
MinCPU float64 `json:"min_cpu"` // Minimum CPU cores
|
||||
MinMemory int64 `json:"min_memory"` // Minimum memory
|
||||
MinStorage int64 `json:"min_storage"` // Minimum storage
|
||||
MinNetworkBandwidth int64 `json:"min_network_bandwidth"` // Minimum network bandwidth
|
||||
|
||||
// Experience requirements
|
||||
MinSuccessfulOperations int64 `json:"min_successful_operations"` // Minimum successful operations
|
||||
MaxFailureRate float64 `json:"max_failure_rate"` // Maximum failure rate
|
||||
MaxResponseTime time.Duration `json:"max_response_time"` // Maximum average response time
|
||||
}
|
||||
|
||||
// NewSLURPCandidateScorer creates a new SLURP candidate scorer
|
||||
func NewSLURPCandidateScorer(cfg *config.Config) *SLURPCandidateScorer {
|
||||
weights := DefaultSLURPScoringWeights()
|
||||
requirements := DefaultSLURPLeadershipRequirements()
|
||||
|
||||
// Override with config values if available
|
||||
// TODO: Fix SecurityConfig and ElectionConfig pointer checks
|
||||
// if cfg.Security != nil && cfg.Security.ElectionConfig != nil {
|
||||
// // Map existing election config weights to SLURP weights
|
||||
// if cfg.Security.ElectionConfig.LeadershipScoring != nil {
|
||||
// scoring := cfg.Security.ElectionConfig.LeadershipScoring
|
||||
// weights.UptimeWeight = scoring.UptimeWeight
|
||||
// weights.CapabilityWeight = scoring.CapabilityWeight
|
||||
// weights.ResourceWeight = scoring.ResourceWeight
|
||||
// weights.NetworkWeight = scoring.NetworkWeight
|
||||
// weights.ExperienceWeight = scoring.ExperienceWeight
|
||||
// }
|
||||
// }
|
||||
|
||||
return &SLURPCandidateScorer{
|
||||
weights: weights,
|
||||
config: cfg,
|
||||
requirements: requirements,
|
||||
minQualityScore: 0.7,
|
||||
minReliabilityScore: 0.8,
|
||||
minUptimeThreshold: 0.9,
|
||||
}
|
||||
}
|
||||
|
||||
// CalculateSLURPCandidateScore calculates comprehensive SLURP-aware candidate score
|
||||
func (scs *SLURPCandidateScorer) CalculateSLURPCandidateScore(
|
||||
candidate *AdminCandidate,
|
||||
slurpCapabilities *SLURPCandidateCapabilities,
|
||||
) (float64, *SLURPScoringBreakdown, error) {
|
||||
|
||||
if candidate == nil {
|
||||
return 0.0, nil, fmt.Errorf("candidate is nil")
|
||||
}
|
||||
|
||||
if slurpCapabilities == nil {
|
||||
// Use default/minimal capabilities if none provided
|
||||
slurpCapabilities = &SLURPCandidateCapabilities{
|
||||
GeneralCapabilityScore: 0.5,
|
||||
ReliabilityScore: 0.7,
|
||||
UptimePercentage: 0.9,
|
||||
}
|
||||
}
|
||||
|
||||
breakdown := &SLURPScoringBreakdown{
|
||||
CandidateID: candidate.NodeID,
|
||||
Timestamp: time.Now(),
|
||||
}
|
||||
|
||||
// Calculate base election score (from existing system)
|
||||
baseScore := scs.calculateBaseElectionScore(candidate, breakdown)
|
||||
|
||||
// Calculate SLURP-specific scores
|
||||
contextScore := scs.calculateContextCapabilityScore(slurpCapabilities, breakdown)
|
||||
intelligenceScore := scs.calculateIntelligenceScore(slurpCapabilities, breakdown)
|
||||
coordinationScore := scs.calculateCoordinationScore(slurpCapabilities, breakdown)
|
||||
qualityScore := scs.calculateQualityScore(slurpCapabilities, breakdown)
|
||||
performanceScore := scs.calculatePerformanceScore(slurpCapabilities, breakdown)
|
||||
specializationScore := scs.calculateSpecializationScore(slurpCapabilities, breakdown)
|
||||
availabilityScore := scs.calculateAvailabilityScore(slurpCapabilities, breakdown)
|
||||
reliabilityScore := scs.calculateReliabilityScore(slurpCapabilities, breakdown)
|
||||
|
||||
// Apply requirements filtering
|
||||
if !scs.meetsRequirements(candidate, slurpCapabilities, breakdown) {
|
||||
breakdown.MeetsRequirements = false
|
||||
breakdown.DisqualificationReasons = append(breakdown.DisqualificationReasons,
|
||||
"Does not meet minimum SLURP leadership requirements")
|
||||
return 0.0, breakdown, nil
|
||||
}
|
||||
breakdown.MeetsRequirements = true
|
||||
|
||||
// Calculate weighted final score
|
||||
weights := scs.weights
|
||||
finalScore :=
|
||||
baseScore * (weights.UptimeWeight + weights.CapabilityWeight + weights.ResourceWeight +
|
||||
weights.NetworkWeight + weights.ExperienceWeight) +
|
||||
contextScore * weights.ContextCapabilityWeight +
|
||||
intelligenceScore * weights.IntelligenceWeight +
|
||||
coordinationScore * weights.CoordinationWeight +
|
||||
qualityScore * weights.QualityWeight +
|
||||
performanceScore * weights.PerformanceWeight +
|
||||
specializationScore * weights.SpecializationWeight +
|
||||
availabilityScore * weights.AvailabilityWeight +
|
||||
reliabilityScore * weights.ReliabilityWeight
|
||||
|
||||
// Normalize to 0-1 range
|
||||
totalWeight := weights.UptimeWeight + weights.CapabilityWeight + weights.ResourceWeight +
|
||||
weights.NetworkWeight + weights.ExperienceWeight + weights.ContextCapabilityWeight +
|
||||
weights.IntelligenceWeight + weights.CoordinationWeight + weights.QualityWeight +
|
||||
weights.PerformanceWeight + weights.SpecializationWeight + weights.AvailabilityWeight +
|
||||
weights.ReliabilityWeight
|
||||
|
||||
if totalWeight > 0 {
|
||||
finalScore = finalScore / totalWeight
|
||||
}
|
||||
|
||||
// Apply bonus/penalty adjustments
|
||||
finalScore = scs.applyAdjustments(candidate, slurpCapabilities, finalScore, breakdown)
|
||||
|
||||
// Clamp to valid range
|
||||
if finalScore < 0 {
|
||||
finalScore = 0
|
||||
}
|
||||
if finalScore > 1 {
|
||||
finalScore = 1
|
||||
}
|
||||
|
||||
breakdown.FinalScore = finalScore
|
||||
|
||||
log.Printf("📊 SLURP candidate score for %s: %.3f (base: %.3f, context: %.3f, intelligence: %.3f)",
|
||||
candidate.NodeID, finalScore, baseScore, contextScore, intelligenceScore)
|
||||
|
||||
return finalScore, breakdown, nil
|
||||
}
|
||||
|
||||
// calculateBaseElectionScore calculates the base election score using existing logic
|
||||
func (scs *SLURPCandidateScorer) calculateBaseElectionScore(candidate *AdminCandidate, breakdown *SLURPScoringBreakdown) float64 {
|
||||
// Replicate logic from existing calculateCandidateScore function
|
||||
weights := scs.weights
|
||||
|
||||
// Normalize metrics to 0-1 range
|
||||
uptimeScore := min(1.0, candidate.Uptime.Hours()/24.0) // Up to 24 hours gets full score
|
||||
|
||||
// Capability score - higher for admin/coordination capabilities
|
||||
capabilityScore := 0.0
|
||||
adminCapabilities := []string{"admin_election", "context_curation", "key_reconstruction", "semantic_analysis"}
|
||||
for _, cap := range candidate.Capabilities {
|
||||
for _, adminCap := range adminCapabilities {
|
||||
if cap == adminCap {
|
||||
capabilityScore += 0.25 // Each admin capability adds 25%
|
||||
}
|
||||
}
|
||||
}
|
||||
capabilityScore = min(1.0, capabilityScore)
|
||||
|
||||
// Resource score - lower usage is better
|
||||
resourceScore := (1.0 - candidate.Resources.CPUUsage) * 0.3 +
|
||||
(1.0 - candidate.Resources.MemoryUsage) * 0.3 +
|
||||
(1.0 - candidate.Resources.DiskUsage) * 0.2 +
|
||||
candidate.Resources.NetworkQuality * 0.2
|
||||
|
||||
experienceScore := min(1.0, candidate.Experience.Hours()/168.0) // Up to 1 week gets full score
|
||||
|
||||
// Store breakdown
|
||||
breakdown.BaseScores = &BaseElectionScores{
|
||||
UptimeScore: uptimeScore,
|
||||
CapabilityScore: capabilityScore,
|
||||
ResourceScore: resourceScore,
|
||||
NetworkScore: candidate.Resources.NetworkQuality,
|
||||
ExperienceScore: experienceScore,
|
||||
}
|
||||
|
||||
// Weighted base score
|
||||
baseScore := uptimeScore*weights.UptimeWeight +
|
||||
capabilityScore*weights.CapabilityWeight +
|
||||
resourceScore*weights.ResourceWeight +
|
||||
candidate.Resources.NetworkQuality*weights.NetworkWeight +
|
||||
experienceScore*weights.ExperienceWeight
|
||||
|
||||
return baseScore
|
||||
}
|
||||
|
||||
// calculateContextCapabilityScore calculates score for context-related capabilities
|
||||
func (scs *SLURPCandidateScorer) calculateContextCapabilityScore(caps *SLURPCandidateCapabilities, breakdown *SLURPScoringBreakdown) float64 {
|
||||
score := 0.0
|
||||
|
||||
// Core context capabilities (required for leadership)
|
||||
if caps.ContextGeneration { score += 0.3 }
|
||||
if caps.ContextCuration { score += 0.2 }
|
||||
if caps.ContextDistribution { score += 0.2 }
|
||||
if caps.ContextStorage { score += 0.1 }
|
||||
|
||||
// Advanced context capabilities (bonus)
|
||||
if caps.SemanticAnalysis { score += 0.1 }
|
||||
if caps.RAGIntegration { score += 0.1 }
|
||||
|
||||
breakdown.ContextCapabilityScore = min(1.0, score)
|
||||
return breakdown.ContextCapabilityScore
|
||||
}
|
||||
|
||||
// calculateIntelligenceScore calculates score for intelligence capabilities
|
||||
func (scs *SLURPCandidateScorer) calculateIntelligenceScore(caps *SLURPCandidateCapabilities, breakdown *SLURPScoringBreakdown) float64 {
|
||||
score := 0.0
|
||||
|
||||
if caps.SemanticAnalysis { score += 0.25 }
|
||||
if caps.RAGIntegration { score += 0.25 }
|
||||
if caps.TemporalAnalysis { score += 0.25 }
|
||||
if caps.DecisionTracking { score += 0.25 }
|
||||
|
||||
// Quality multiplier
|
||||
score = score * caps.GenerationQuality
|
||||
|
||||
breakdown.IntelligenceScore = score
|
||||
return score
|
||||
}
|
||||
|
||||
// calculateCoordinationScore calculates score for coordination capabilities
|
||||
func (scs *SLURPCandidateScorer) calculateCoordinationScore(caps *SLURPCandidateCapabilities, breakdown *SLURPScoringBreakdown) float64 {
|
||||
score := 0.0
|
||||
|
||||
if caps.ClusterCoordination { score += 0.3 }
|
||||
if caps.LoadBalancing { score += 0.25 }
|
||||
if caps.HealthMonitoring { score += 0.2 }
|
||||
if caps.ResourceManagement { score += 0.25 }
|
||||
|
||||
breakdown.CoordinationScore = min(1.0, score)
|
||||
return breakdown.CoordinationScore
|
||||
}
|
||||
|
||||
// calculateQualityScore calculates score based on quality metrics
|
||||
func (scs *SLURPCandidateScorer) calculateQualityScore(caps *SLURPCandidateCapabilities, breakdown *SLURPScoringBreakdown) float64 {
|
||||
// Average of quality metrics
|
||||
score := (caps.GenerationQuality + caps.ProcessingSpeed + caps.AccuracyScore) / 3.0
|
||||
|
||||
breakdown.QualityScore = score
|
||||
return score
|
||||
}
|
||||
|
||||
// calculatePerformanceScore calculates score based on historical performance
|
||||
func (scs *SLURPCandidateScorer) calculatePerformanceScore(caps *SLURPCandidateCapabilities, breakdown *SLURPScoringBreakdown) float64 {
|
||||
if caps.SuccessfulOperations + caps.FailedOperations == 0 {
|
||||
// No history, return neutral score
|
||||
breakdown.PerformanceScore = 0.5
|
||||
return 0.5
|
||||
}
|
||||
|
||||
// Calculate success rate
|
||||
totalOperations := caps.SuccessfulOperations + caps.FailedOperations
|
||||
successRate := float64(caps.SuccessfulOperations) / float64(totalOperations)
|
||||
|
||||
// Response time score (lower is better, normalize to reasonable range)
|
||||
responseTimeScore := 1.0
|
||||
if caps.AverageResponseTime > 0 {
|
||||
// Assume 1 second is optimal, 10 seconds is poor
|
||||
maxAcceptableTime := 10 * time.Second
|
||||
if caps.AverageResponseTime <= time.Second {
|
||||
responseTimeScore = 1.0
|
||||
} else if caps.AverageResponseTime >= maxAcceptableTime {
|
||||
responseTimeScore = 0.1
|
||||
} else {
|
||||
responseTimeScore = 1.0 - (float64(caps.AverageResponseTime - time.Second) / float64(maxAcceptableTime - time.Second)) * 0.9
|
||||
}
|
||||
}
|
||||
|
||||
// Combine success rate and response time
|
||||
score := (successRate * 0.7) + (responseTimeScore * 0.3)
|
||||
|
||||
breakdown.PerformanceScore = score
|
||||
return score
|
||||
}
|
||||
|
||||
// calculateSpecializationScore calculates score based on specialization
|
||||
func (scs *SLURPCandidateScorer) calculateSpecializationScore(caps *SLURPCandidateCapabilities, breakdown *SLURPScoringBreakdown) float64 {
|
||||
// Combine specialization score with domain coverage
|
||||
domainCoverage := float64(len(caps.DomainExpertise)) / 10.0 // Assume 10 domains is excellent coverage
|
||||
if domainCoverage > 1.0 {
|
||||
domainCoverage = 1.0
|
||||
}
|
||||
|
||||
score := (caps.SpecializationScore * 0.6) + (domainCoverage * 0.4)
|
||||
|
||||
breakdown.SpecializationScore = score
|
||||
return score
|
||||
}
|
||||
|
||||
// calculateAvailabilityScore calculates score based on resource availability
|
||||
func (scs *SLURPCandidateScorer) calculateAvailabilityScore(caps *SLURPCandidateCapabilities, breakdown *SLURPScoringBreakdown) float64 {
|
||||
// Normalize resource availability (assuming reasonable ranges)
|
||||
cpuScore := min(1.0, caps.AvailableCPU / 8.0) // 8 cores is excellent
|
||||
memoryScore := min(1.0, float64(caps.AvailableMemory) / (16 * 1024 * 1024 * 1024)) // 16GB is excellent
|
||||
storageScore := min(1.0, float64(caps.AvailableStorage) / (1024 * 1024 * 1024 * 1024)) // 1TB is excellent
|
||||
networkScore := min(1.0, float64(caps.NetworkBandwidth) / (1024 * 1024 * 1024)) // 1Gbps is excellent
|
||||
|
||||
score := (cpuScore * 0.3) + (memoryScore * 0.3) + (storageScore * 0.2) + (networkScore * 0.2)
|
||||
|
||||
breakdown.AvailabilityScore = score
|
||||
return score
|
||||
}
|
||||
|
||||
// calculateReliabilityScore calculates score based on reliability metrics
|
||||
func (scs *SLURPCandidateScorer) calculateReliabilityScore(caps *SLURPCandidateCapabilities, breakdown *SLURPScoringBreakdown) float64 {
|
||||
// Combine reliability score with uptime percentage
|
||||
score := (caps.ReliabilityScore * 0.6) + (caps.UptimePercentage * 0.4)
|
||||
|
||||
breakdown.ReliabilityScore = score
|
||||
return score
|
||||
}
|
||||
|
||||
// meetsRequirements checks if candidate meets minimum SLURP leadership requirements
|
||||
func (scs *SLURPCandidateScorer) meetsRequirements(candidate *AdminCandidate, caps *SLURPCandidateCapabilities, breakdown *SLURPScoringBreakdown) bool {
|
||||
req := scs.requirements
|
||||
issues := []string{}
|
||||
|
||||
// Check quality thresholds
|
||||
if caps.GenerationQuality < req.MinQualityScore {
|
||||
issues = append(issues, fmt.Sprintf("Quality score %.2f below minimum %.2f", caps.GenerationQuality, req.MinQualityScore))
|
||||
}
|
||||
|
||||
if caps.ReliabilityScore < req.MinReliabilityScore {
|
||||
issues = append(issues, fmt.Sprintf("Reliability score %.2f below minimum %.2f", caps.ReliabilityScore, req.MinReliabilityScore))
|
||||
}
|
||||
|
||||
if caps.UptimePercentage < req.MinUptimePercentage {
|
||||
issues = append(issues, fmt.Sprintf("Uptime %.2f%% below minimum %.2f%%", caps.UptimePercentage*100, req.MinUptimePercentage*100))
|
||||
}
|
||||
|
||||
// Check resource requirements
|
||||
if caps.AvailableCPU < req.MinCPU {
|
||||
issues = append(issues, fmt.Sprintf("Available CPU %.1f below minimum %.1f", caps.AvailableCPU, req.MinCPU))
|
||||
}
|
||||
|
||||
if caps.AvailableMemory < req.MinMemory {
|
||||
issues = append(issues, fmt.Sprintf("Available memory %d below minimum %d", caps.AvailableMemory, req.MinMemory))
|
||||
}
|
||||
|
||||
// Check failure rate
|
||||
if caps.SuccessfulOperations + caps.FailedOperations > 0 {
|
||||
failureRate := float64(caps.FailedOperations) / float64(caps.SuccessfulOperations + caps.FailedOperations)
|
||||
if failureRate > req.MaxFailureRate {
|
||||
issues = append(issues, fmt.Sprintf("Failure rate %.2f%% above maximum %.2f%%", failureRate*100, req.MaxFailureRate*100))
|
||||
}
|
||||
}
|
||||
|
||||
breakdown.RequirementIssues = issues
|
||||
return len(issues) == 0
|
||||
}
|
||||
|
||||
// applyAdjustments applies bonus/penalty adjustments to the final score
|
||||
func (scs *SLURPCandidateScorer) applyAdjustments(candidate *AdminCandidate, caps *SLURPCandidateCapabilities, baseScore float64, breakdown *SLURPScoringBreakdown) float64 {
|
||||
adjustments := []string{}
|
||||
finalScore := baseScore
|
||||
|
||||
// Bonus for exceptional capabilities
|
||||
if caps.GenerationQuality > 0.95 {
|
||||
finalScore += 0.05
|
||||
adjustments = append(adjustments, "Exceptional generation quality bonus (+0.05)")
|
||||
}
|
||||
|
||||
if caps.UptimePercentage > 0.99 {
|
||||
finalScore += 0.03
|
||||
adjustments = append(adjustments, "Exceptional uptime bonus (+0.03)")
|
||||
}
|
||||
|
||||
// Bonus for broad capability coverage
|
||||
if caps.ContextGeneration && caps.ContextCuration && caps.SemanticAnalysis && caps.ClusterCoordination {
|
||||
finalScore += 0.02
|
||||
adjustments = append(adjustments, "Full capability coverage bonus (+0.02)")
|
||||
}
|
||||
|
||||
// Penalty for concerning metrics
|
||||
if caps.GenerationQuality < 0.5 {
|
||||
finalScore -= 0.1
|
||||
adjustments = append(adjustments, "Low generation quality penalty (-0.1)")
|
||||
}
|
||||
|
||||
if caps.FailedOperations > caps.SuccessfulOperations {
|
||||
finalScore -= 0.15
|
||||
adjustments = append(adjustments, "High failure rate penalty (-0.15)")
|
||||
}
|
||||
|
||||
breakdown.ScoreAdjustments = adjustments
|
||||
return finalScore
|
||||
}
|
||||
|
||||
// Supporting types and defaults
|
||||
|
||||
// SLURPScoringBreakdown provides detailed breakdown of SLURP candidate scoring
|
||||
type SLURPScoringBreakdown struct {
|
||||
CandidateID string `json:"candidate_id"`
|
||||
Timestamp time.Time `json:"timestamp"`
|
||||
FinalScore float64 `json:"final_score"`
|
||||
MeetsRequirements bool `json:"meets_requirements"`
|
||||
|
||||
// Score components
|
||||
BaseScores *BaseElectionScores `json:"base_scores"`
|
||||
ContextCapabilityScore float64 `json:"context_capability_score"`
|
||||
IntelligenceScore float64 `json:"intelligence_score"`
|
||||
CoordinationScore float64 `json:"coordination_score"`
|
||||
QualityScore float64 `json:"quality_score"`
|
||||
PerformanceScore float64 `json:"performance_score"`
|
||||
SpecializationScore float64 `json:"specialization_score"`
|
||||
AvailabilityScore float64 `json:"availability_score"`
|
||||
ReliabilityScore float64 `json:"reliability_score"`
|
||||
|
||||
// Requirements and adjustments
|
||||
RequirementIssues []string `json:"requirement_issues,omitempty"`
|
||||
DisqualificationReasons []string `json:"disqualification_reasons,omitempty"`
|
||||
ScoreAdjustments []string `json:"score_adjustments,omitempty"`
|
||||
}
|
||||
|
||||
// BaseElectionScores contains base election scoring breakdown
|
||||
type BaseElectionScores struct {
|
||||
UptimeScore float64 `json:"uptime_score"`
|
||||
CapabilityScore float64 `json:"capability_score"`
|
||||
ResourceScore float64 `json:"resource_score"`
|
||||
NetworkScore float64 `json:"network_score"`
|
||||
ExperienceScore float64 `json:"experience_score"`
|
||||
}
|
||||
|
||||
// DefaultSLURPScoringWeights returns default SLURP scoring weights
|
||||
func DefaultSLURPScoringWeights() *SLURPScoringWeights {
|
||||
return &SLURPScoringWeights{
|
||||
// Base election weights (total: 0.4)
|
||||
UptimeWeight: 0.08,
|
||||
CapabilityWeight: 0.10,
|
||||
ResourceWeight: 0.08,
|
||||
NetworkWeight: 0.06,
|
||||
ExperienceWeight: 0.08,
|
||||
|
||||
// SLURP-specific weights (total: 0.6)
|
||||
ContextCapabilityWeight: 0.15, // Most important for context leadership
|
||||
IntelligenceWeight: 0.12,
|
||||
CoordinationWeight: 0.10,
|
||||
QualityWeight: 0.08,
|
||||
PerformanceWeight: 0.06,
|
||||
SpecializationWeight: 0.04,
|
||||
AvailabilityWeight: 0.03,
|
||||
ReliabilityWeight: 0.02,
|
||||
}
|
||||
}
|
||||
|
||||
// DefaultSLURPLeadershipRequirements returns default SLURP leadership requirements
|
||||
func DefaultSLURPLeadershipRequirements() *SLURPLeadershipRequirements {
|
||||
return &SLURPLeadershipRequirements{
|
||||
RequiredCapabilities: []string{"context_generation", "context_curation"},
|
||||
PreferredCapabilities: []string{"semantic_analysis", "cluster_coordination", "rag_integration"},
|
||||
MinQualityScore: 0.6,
|
||||
MinReliabilityScore: 0.7,
|
||||
MinUptimePercentage: 0.8,
|
||||
|
||||
MinCPU: 2.0, // 2 CPU cores minimum
|
||||
MinMemory: 4 * 1024 * 1024 * 1024, // 4GB minimum
|
||||
MinStorage: 100 * 1024 * 1024 * 1024, // 100GB minimum
|
||||
MinNetworkBandwidth: 100 * 1024 * 1024, // 100 Mbps minimum
|
||||
|
||||
MinSuccessfulOperations: 10,
|
||||
MaxFailureRate: 0.1, // 10% max failure rate
|
||||
MaxResponseTime: 5 * time.Second,
|
||||
}
|
||||
}
|
||||
Reference in New Issue
Block a user