distributed

type AggregationStrategy interface {
	Aggregate(results []*PartitionResult) (interface{}, error)
}

type AnalysisAggregator struct{}

type AttackAggregator struct{}

type CapacityTracker struct {
	// contains filtered or unexported fields
}

type ChainAggregator struct{}

type ConsensusManager struct {
	// contains filtered or unexported fields
}

type ConsensusNode struct {
	ID          string
	Address     string
	LastContact time.Time
	State       ConsensusState
}

type ConsensusState string

type Coordinator struct {
	// contains filtered or unexported fields
}

type DistributedConfig struct {
	MaxNodes            int
	TaskTimeout         time.Duration
	HeartbeatInterval   time.Duration
	ReplicationFactor   int
	PartitionStrategy   PartitionStrategy
	LoadBalancingPolicy LoadBalancingPolicy
	FaultTolerance      bool
	AutoScaling         bool
}

type DistributedExecutor struct {
	// contains filtered or unexported fields
}

type DistributedLock struct {
	Key        string
	Owner      string
	AcquiredAt time.Time
	TTL        time.Duration
	Renewals   int
}

type DistributedLockManager struct {
	// contains filtered or unexported fields
}

type DistributedRequest struct {
	Type       TaskType
	Payload    interface{}
	Timeout    time.Duration
	Priority   int
	Partitions int
}

type DistributedResult struct {
	TaskID              string
	Success             bool
	TotalPartitions     int
	CompletedPartitions int
	FailedPartitions    int
	AggregatedData      interface{}
	ExecutionTime       time.Duration
	NodeMetrics         map[string]*NodeMetrics
}

type DistributedTask struct {
	ID            string
	Type          TaskType
	Payload       interface{}
	Partitions    []TaskPartition
	Status        TaskStatus
	AssignedNodes []string
	StartTime     time.Time
	Deadline      time.Time
	RetryCount    int
	Results       map[string]*PartitionResult
	// contains filtered or unexported fields
}

type DynamicPartitioner struct{}

type HashPartitioner struct{}

type HealthCheck struct {
	NodeID           string
	LastCheck        time.Time
	Status           HealthStatus
	ResponseTime     time.Duration
	FailureCount     int
	ConsecutiveFails int
}

type HealthChecker struct {
	// contains filtered or unexported fields
}

type HealthStatus string

type LoadBalancer struct {
	// contains filtered or unexported fields
}

type LoadBalancingPolicy string

type Node struct {
	ID            string
	Address       string
	Status        NodeStatus
	Capacity      NodeCapacity
	CurrentLoad   NodeLoad
	LastHeartbeat time.Time
	Tasks         map[string]*DistributedTask
	// contains filtered or unexported fields
}

type NodeCapacity struct {
	CPU              int
	Memory           int64
	MaxConcurrency   int
	NetworkBandwidth int64
	Specializations  []string
}

type NodeConfig struct {
	Address  string
	Capacity NodeCapacity
}

type NodeGroup struct {
	ID             string
	Name           string
	Nodes          []string
	Specialization string
	LoadBalancer   *LoadBalancer
}

type NodeLoad struct {
	CPUUsage       float64
	MemoryUsage    int64
	ActiveTasks    int32
	TasksCompleted int64
	AverageLatency time.Duration
}

type NodeManager struct {
	// contains filtered or unexported fields
}

type NodeMetrics struct {
	NodeID         string
	TasksProcessed int
	AverageLatency time.Duration
	ErrorRate      float64
	ResourceUsage  ResourceUsage
}

type NodeStatus string

type PartitionResult struct {
	PartitionID   string
	Success       bool
	Data          interface{}
	Error         error
	ExecutionTime time.Duration
	NodeID        string
}

type PartitionStatus string

type PartitionStrategy string

type Partitioner interface {
	Partition(data interface{}, numPartitions int) []interface{}
}

type RangePartitioner struct{}

type ResourceUsage struct {
	CPUPercent  float64
	MemoryMB    int64
	NetworkMBps float64
}

type ResultAggregator struct {
	// contains filtered or unexported fields
}

type RoundRobinPartitioner struct{}

type ScanAggregator struct{}

type ScanPartition struct {
	Targets   []string
	Templates []string
}

type ScanRequest struct {
	Targets   []string
	Templates []string
	Options   map[string]interface{}
}

type StateManager struct {
	// contains filtered or unexported fields
}

type StateReplica struct {
	NodeID     string
	Version    int64
	LastSync   time.Time
	Consistent bool
}

type SystemMetrics struct {
	NodeCount      int
	TotalCapacity  int
	CurrentLoad    int32
	Utilization    float64
	AverageLatency time.Duration
	PendingTasks   int
}

type TaskDistributor struct {
	// contains filtered or unexported fields
}

type TaskPartition struct {
	ID         string
	TaskID     string
	Index      int
	Data       interface{}
	Size       int64
	AssignedTo string
	Status     PartitionStatus
	Result     *PartitionResult
}

type TaskStatus string

type TaskType string

type TrackedCapacity struct {
	NodeID           string
	TotalCapacity    NodeCapacity
	UsedCapacity     NodeCapacity
	ReservedCapacity NodeCapacity
	UpdatedAt        time.Time
}