first commit
This commit is contained in:
379
internal/cluster/node.go
Normal file
379
internal/cluster/node.go
Normal file
@@ -0,0 +1,379 @@
|
||||
// Файл: internal/cluster/node.go
|
||||
// Назначение: Реализация узла кластера (node) для распределённой СУБД.
|
||||
// Реализация узла кластера (node) для распределённой СУБД.
|
||||
// Полностью lock-free с использованием атомарных операций.
|
||||
|
||||
package cluster
|
||||
|
||||
import (
|
||||
"encoding/json"
|
||||
"fmt"
|
||||
"net"
|
||||
"sync/atomic"
|
||||
"time"
|
||||
|
||||
"futriis/internal/log"
|
||||
"futriis/internal/storage"
|
||||
"github.com/google/uuid"
|
||||
)
|
||||
|
||||
// NodeStatus представляет состояние узла кластера
|
||||
type NodeStatus int32
|
||||
|
||||
const (
|
||||
StatusOffline NodeStatus = iota
|
||||
StatusActive
|
||||
StatusSyncing
|
||||
StatusFailed
|
||||
)
|
||||
|
||||
// Node представляет отдельный узел в распределённой системе
|
||||
type Node struct {
|
||||
ID string // Уникальный идентификатор узла
|
||||
IP string // IP-адрес узла
|
||||
Port int // Порт для коммуникации
|
||||
Status atomic.Int32 // Атомарный статус узла (NodeStatus)
|
||||
Storage *storage.Storage
|
||||
logger *log.Logger
|
||||
coordinator *RaftCoordinator // Ссылка на координатора (теперь RaftCoordinator)
|
||||
lastSeen atomic.Int64 // Время последнего heartbeat (Unix nano)
|
||||
incomingConn chan net.Conn // Канал для входящих соединений (wait-free)
|
||||
stopChan chan struct{}
|
||||
}
|
||||
|
||||
// NodeConfig содержит конфигурацию для создания узла
|
||||
type NodeConfig struct {
|
||||
IP string
|
||||
Port int
|
||||
Storage *storage.Storage
|
||||
Logger *log.Logger
|
||||
Coordinator *RaftCoordinator
|
||||
}
|
||||
|
||||
// NewNode создаёт новый экземпляр узла кластера
|
||||
func NewNode(ip string, port int, store *storage.Storage, logger *log.Logger) *Node {
|
||||
node := &Node{
|
||||
ID: uuid.New().String(),
|
||||
IP: ip,
|
||||
Port: port,
|
||||
Storage: store,
|
||||
logger: logger,
|
||||
incomingConn: make(chan net.Conn, 1000), // Буферизованный канал для wait-free приёма
|
||||
stopChan: make(chan struct{}),
|
||||
}
|
||||
node.Status.Store(int32(StatusActive))
|
||||
node.lastSeen.Store(time.Now().UnixNano())
|
||||
|
||||
// Запуск сервера для приёма межузловых соединений
|
||||
go node.startTCPServer()
|
||||
|
||||
// Запуск обработчика входящих соединений
|
||||
go node.handleIncomingConnections()
|
||||
|
||||
// Запуск heartbeat-отправки (если координатор известен)
|
||||
go node.heartbeatLoop()
|
||||
|
||||
return node
|
||||
}
|
||||
|
||||
// startTCPServer запускает TCP-сервер для приёма запросов от других узлов
|
||||
func (n *Node) startTCPServer() {
|
||||
addr := fmt.Sprintf("%s:%d", n.IP, n.Port)
|
||||
listener, err := net.Listen("tcp", addr)
|
||||
if err != nil {
|
||||
if n.logger != nil {
|
||||
n.logger.Error(fmt.Sprintf("Node %s failed to start TCP server: %v", n.ID, err))
|
||||
}
|
||||
n.Status.Store(int32(StatusFailed))
|
||||
return
|
||||
}
|
||||
defer listener.Close()
|
||||
|
||||
if n.logger != nil {
|
||||
n.logger.Info(fmt.Sprintf("Node %s listening on %s", n.ID, addr))
|
||||
}
|
||||
|
||||
for {
|
||||
select {
|
||||
case <-n.stopChan:
|
||||
return
|
||||
default:
|
||||
conn, err := listener.Accept()
|
||||
if err != nil {
|
||||
if n.logger != nil {
|
||||
n.logger.Error(fmt.Sprintf("Node %s accept error: %v", n.ID, err))
|
||||
}
|
||||
continue
|
||||
}
|
||||
// Неблокирующая отправка в канал
|
||||
select {
|
||||
case n.incomingConn <- conn:
|
||||
default:
|
||||
if n.logger != nil {
|
||||
n.logger.Warn(fmt.Sprintf("Node %s incoming connection queue full, dropping connection", n.ID))
|
||||
}
|
||||
conn.Close()
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
// handleIncomingConnections обрабатывает входящие соединения wait-free способом
|
||||
func (n *Node) handleIncomingConnections() {
|
||||
for {
|
||||
select {
|
||||
case <-n.stopChan:
|
||||
return
|
||||
case conn := <-n.incomingConn:
|
||||
go n.handleNodeRequest(conn)
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
// handleNodeRequest обрабатывает конкретный запрос от другого узла
|
||||
func (n *Node) handleNodeRequest(conn net.Conn) {
|
||||
defer conn.Close()
|
||||
|
||||
decoder := json.NewDecoder(conn)
|
||||
var req NodeRequest
|
||||
if err := decoder.Decode(&req); err != nil {
|
||||
if n.logger != nil {
|
||||
n.logger.Error(fmt.Sprintf("Node %s failed to decode request: %v", n.ID, err))
|
||||
}
|
||||
return
|
||||
}
|
||||
|
||||
// Обновляем время последнего контакта
|
||||
n.lastSeen.Store(time.Now().UnixNano())
|
||||
|
||||
// Маршрутизация запроса в зависимости от типа
|
||||
switch req.Type {
|
||||
case "replicate":
|
||||
n.handleReplicateRequest(req.Data)
|
||||
case "query":
|
||||
n.handleQueryRequest(req.Data, conn)
|
||||
case "sync":
|
||||
n.handleSyncRequest(req.Data, conn)
|
||||
default:
|
||||
if n.logger != nil {
|
||||
n.logger.Warn(fmt.Sprintf("Node %s unknown request type: %s", n.ID, req.Type))
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
// handleReplicateRequest обрабатывает запрос на репликацию документа
|
||||
func (n *Node) handleReplicateRequest(data []byte) {
|
||||
var repData struct {
|
||||
Database string `json:"database"`
|
||||
Collection string `json:"collection"`
|
||||
Document map[string]interface{} `json:"document"`
|
||||
}
|
||||
|
||||
if err := json.Unmarshal(data, &repData); err != nil {
|
||||
if n.logger != nil {
|
||||
n.logger.Error(fmt.Sprintf("Node %s failed to unmarshal replicate data: %v", n.ID, err))
|
||||
}
|
||||
return
|
||||
}
|
||||
|
||||
// Получаем базу данных
|
||||
db, err := n.Storage.GetDatabase(repData.Database)
|
||||
if err != nil {
|
||||
if n.logger != nil {
|
||||
n.logger.Error(fmt.Sprintf("Node %s database not found for replication: %s", n.ID, repData.Database))
|
||||
}
|
||||
return
|
||||
}
|
||||
|
||||
// Получаем коллекцию
|
||||
coll, err := db.GetCollection(repData.Collection)
|
||||
if err != nil {
|
||||
if n.logger != nil {
|
||||
n.logger.Error(fmt.Sprintf("Node %s collection not found for replication: %s", n.ID, repData.Collection))
|
||||
}
|
||||
return
|
||||
}
|
||||
|
||||
// Создаём документ и вставляем
|
||||
doc := &storage.Document{
|
||||
ID: repData.Document["_id"].(string),
|
||||
Fields: repData.Document,
|
||||
}
|
||||
|
||||
if err := coll.Insert(doc); err != nil {
|
||||
if n.logger != nil {
|
||||
n.logger.Error(fmt.Sprintf("Node %s failed to replicate document: %v", n.ID, err))
|
||||
}
|
||||
} else {
|
||||
if n.logger != nil {
|
||||
n.logger.Debug(fmt.Sprintf("Node %s replicated document %s", n.ID, doc.ID))
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
// handleQueryRequest обрабатывает запрос на чтение данных с узла
|
||||
func (n *Node) handleQueryRequest(data []byte, conn net.Conn) {
|
||||
var queryData struct {
|
||||
Database string `json:"database"`
|
||||
Collection string `json:"collection"`
|
||||
DocumentID string `json:"document_id"`
|
||||
}
|
||||
|
||||
if err := json.Unmarshal(data, &queryData); err != nil {
|
||||
n.sendErrorResponse(conn, err.Error())
|
||||
return
|
||||
}
|
||||
|
||||
// Получаем базу данных
|
||||
db, err := n.Storage.GetDatabase(queryData.Database)
|
||||
if err != nil {
|
||||
n.sendErrorResponse(conn, err.Error())
|
||||
return
|
||||
}
|
||||
|
||||
// Получаем коллекцию
|
||||
coll, err := db.GetCollection(queryData.Collection)
|
||||
if err != nil {
|
||||
n.sendErrorResponse(conn, err.Error())
|
||||
return
|
||||
}
|
||||
|
||||
// Находим документ
|
||||
doc, err := coll.Find(queryData.DocumentID)
|
||||
if err != nil {
|
||||
n.sendErrorResponse(conn, err.Error())
|
||||
return
|
||||
}
|
||||
|
||||
// Отправляем успешный ответ
|
||||
response := map[string]interface{}{
|
||||
"status": "success",
|
||||
"data": doc,
|
||||
}
|
||||
encoder := json.NewEncoder(conn)
|
||||
encoder.Encode(response)
|
||||
}
|
||||
|
||||
// handleSyncRequest обрабатывает запрос на синхронизацию всей коллекции
|
||||
func (n *Node) handleSyncRequest(data []byte, conn net.Conn) {
|
||||
var syncData struct {
|
||||
Database string `json:"database"`
|
||||
Collection string `json:"collection"`
|
||||
}
|
||||
|
||||
if err := json.Unmarshal(data, &syncData); err != nil {
|
||||
n.sendErrorResponse(conn, err.Error())
|
||||
return
|
||||
}
|
||||
|
||||
// Получаем базу данных
|
||||
db, err := n.Storage.GetDatabase(syncData.Database)
|
||||
if err != nil {
|
||||
n.sendErrorResponse(conn, err.Error())
|
||||
return
|
||||
}
|
||||
|
||||
// Получаем коллекцию
|
||||
coll, err := db.GetCollection(syncData.Collection)
|
||||
if err != nil {
|
||||
n.sendErrorResponse(conn, err.Error())
|
||||
return
|
||||
}
|
||||
|
||||
// Получаем все документы
|
||||
docs := coll.GetAllDocuments()
|
||||
|
||||
response := map[string]interface{}{
|
||||
"status": "success",
|
||||
"docs": docs,
|
||||
"count": len(docs),
|
||||
}
|
||||
encoder := json.NewEncoder(conn)
|
||||
encoder.Encode(response)
|
||||
}
|
||||
|
||||
// sendErrorResponse отправляет ошибку в ответ на запрос
|
||||
func (n *Node) sendErrorResponse(conn net.Conn, errMsg string) {
|
||||
response := map[string]interface{}{
|
||||
"status": "error",
|
||||
"error": errMsg,
|
||||
}
|
||||
encoder := json.NewEncoder(conn)
|
||||
encoder.Encode(response)
|
||||
}
|
||||
|
||||
// heartbeatLoop отправляет периодические сигналы жизни координатору
|
||||
func (n *Node) heartbeatLoop() {
|
||||
ticker := time.NewTicker(5 * time.Second)
|
||||
defer ticker.Stop()
|
||||
|
||||
for {
|
||||
select {
|
||||
case <-n.stopChan:
|
||||
return
|
||||
case <-ticker.C:
|
||||
if n.coordinator != nil {
|
||||
n.coordinator.SendHeartbeat(n.ID)
|
||||
n.lastSeen.Store(time.Now().UnixNano())
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
// GetNodeStatus возвращает текущий статус узла (атомарно)
|
||||
func (n *Node) GetNodeStatus() NodeStatus {
|
||||
return NodeStatus(n.Status.Load())
|
||||
}
|
||||
|
||||
// IsActive проверяет, активен ли узел
|
||||
func (n *Node) IsActive() bool {
|
||||
return NodeStatus(n.Status.Load()) == StatusActive
|
||||
}
|
||||
|
||||
// SetCoordinator устанавливает координатора для узла
|
||||
func (n *Node) SetCoordinator(coord *RaftCoordinator) {
|
||||
n.coordinator = coord
|
||||
if n.logger != nil {
|
||||
n.logger.Info(fmt.Sprintf("Node %s connected to coordinator", n.ID))
|
||||
}
|
||||
}
|
||||
|
||||
// Stop останавливает работу узла
|
||||
func (n *Node) Stop() {
|
||||
n.Status.Store(int32(StatusOffline))
|
||||
close(n.stopChan)
|
||||
if n.logger != nil {
|
||||
n.logger.Info(fmt.Sprintf("Node %s stopped", n.ID))
|
||||
}
|
||||
}
|
||||
|
||||
// GetAddress возвращает адрес узла в формате "ip:port"
|
||||
func (n *Node) GetAddress() string {
|
||||
return fmt.Sprintf("%s:%d", n.IP, n.Port)
|
||||
}
|
||||
|
||||
// ReplicateDocument отправляет документ на репликацию всем активным узлам
|
||||
func (n *Node) ReplicateDocument(database, collection string, doc *storage.Document) error {
|
||||
if n.coordinator == nil {
|
||||
if n.logger != nil {
|
||||
n.logger.Warn("No coordinator set, skipping replication")
|
||||
}
|
||||
return fmt.Errorf("no coordinator set")
|
||||
}
|
||||
|
||||
// Получаем список всех узлов от координатора
|
||||
nodes := n.coordinator.GetActiveNodes()
|
||||
|
||||
for _, nodeInfo := range nodes {
|
||||
if nodeInfo.ID == n.ID {
|
||||
continue // Пропускаем себя
|
||||
}
|
||||
|
||||
// В реальной реализации здесь была бы отправка на узел
|
||||
if n.logger != nil {
|
||||
n.logger.Debug(fmt.Sprintf("Would replicate to node %s", nodeInfo.ID))
|
||||
}
|
||||
}
|
||||
|
||||
return nil
|
||||
}
|
||||
722
internal/cluster/raft_coordinator.go
Normal file
722
internal/cluster/raft_coordinator.go
Normal file
@@ -0,0 +1,722 @@
|
||||
// Файл: internal/cluster/raft_coordinator.go
|
||||
// Назначение: Реализация координатора распределённого кластера на основе Raft консенсус-алгоритма.
|
||||
// Обеспечивает управление узлами кластера, выборы лидера, репликацию данных и отказоустойчивость.
|
||||
// Поддерживает как одноузловой режим работы, так и многокластерную конфигурацию с синхронной/асинхронной репликацией.
|
||||
|
||||
package cluster
|
||||
|
||||
import (
|
||||
"encoding/json"
|
||||
"fmt"
|
||||
"io"
|
||||
"net"
|
||||
"os"
|
||||
"path/filepath"
|
||||
"sync"
|
||||
"sync/atomic"
|
||||
"time"
|
||||
|
||||
"github.com/hashicorp/raft"
|
||||
raftboltdb "github.com/hashicorp/raft-boltdb/v2"
|
||||
"futriis/internal/log"
|
||||
"futriis/internal/config"
|
||||
)
|
||||
|
||||
// RaftClusterState представляет состояние кластера для Raft FSM
|
||||
type RaftClusterState struct {
|
||||
Nodes map[string]*NodeInfo `json:"nodes"`
|
||||
ReplicationFactor int32 `json:"replication_factor"`
|
||||
mu sync.RWMutex
|
||||
}
|
||||
|
||||
// RaftCoordinator реализует координацию кластера через Raft
|
||||
type RaftCoordinator struct {
|
||||
raft *raft.Raft
|
||||
fsm *RaftFSM
|
||||
address string
|
||||
raftAddr string
|
||||
clusterName string
|
||||
logger *log.Logger
|
||||
config *config.Config
|
||||
stopChan chan struct{}
|
||||
nodes sync.Map
|
||||
replicationFactor atomic.Int32
|
||||
replicationEnabled bool
|
||||
masterMasterEnabled bool
|
||||
syncReplication bool
|
||||
isLeader atomic.Bool
|
||||
leaderMonitor chan bool
|
||||
}
|
||||
|
||||
// RaftFSM реализует конечный автомат для Raft
|
||||
type RaftFSM struct {
|
||||
state *RaftClusterState
|
||||
logger *log.Logger
|
||||
}
|
||||
|
||||
// NodeRegistrationCommand команда регистрации узла
|
||||
type NodeRegistrationCommand struct {
|
||||
Type string `json:"type"`
|
||||
Node NodeInfo `json:"node,omitempty"`
|
||||
NodeID string `json:"node_id,omitempty"`
|
||||
Factor int32 `json:"factor,omitempty"`
|
||||
}
|
||||
|
||||
// getLocalIP получает локальный IP адрес
|
||||
func getLocalIP() string {
|
||||
addrs, err := net.InterfaceAddrs()
|
||||
if err != nil {
|
||||
return "127.0.0.1"
|
||||
}
|
||||
for _, addr := range addrs {
|
||||
if ipnet, ok := addr.(*net.IPNet); ok && !ipnet.IP.IsLoopback() && ipnet.IP.To4() != nil {
|
||||
return ipnet.IP.String()
|
||||
}
|
||||
}
|
||||
return "127.0.0.1"
|
||||
}
|
||||
|
||||
// NewRaftCoordinator создаёт новый Raft координатор
|
||||
func NewRaftCoordinator(cfg *config.Config, logger *log.Logger) (*RaftCoordinator, error) {
|
||||
// Используем IP из конфига или автоматически определяем
|
||||
nodeIP := cfg.Cluster.NodeIP
|
||||
if nodeIP == "" || nodeIP == "0.0.0.0" {
|
||||
nodeIP = getLocalIP()
|
||||
}
|
||||
|
||||
raftAddr := fmt.Sprintf("%s:%d", nodeIP, cfg.Cluster.RaftPort)
|
||||
|
||||
logger.Debug(fmt.Sprintf("Creating Raft coordinator at %s", raftAddr))
|
||||
|
||||
rc := &RaftCoordinator{
|
||||
address: fmt.Sprintf("%s:%d", nodeIP, cfg.Cluster.NodePort),
|
||||
raftAddr: raftAddr,
|
||||
clusterName: cfg.Cluster.Name,
|
||||
logger: logger,
|
||||
config: cfg,
|
||||
stopChan: make(chan struct{}),
|
||||
leaderMonitor: make(chan bool, 1),
|
||||
replicationEnabled: cfg.Replication.Enabled,
|
||||
masterMasterEnabled: cfg.Replication.MasterMaster,
|
||||
syncReplication: cfg.Replication.SyncReplication,
|
||||
}
|
||||
rc.replicationFactor.Store(int32(3))
|
||||
|
||||
// Создаём FSM
|
||||
rc.fsm = &RaftFSM{
|
||||
state: &RaftClusterState{
|
||||
Nodes: make(map[string]*NodeInfo),
|
||||
},
|
||||
logger: logger,
|
||||
}
|
||||
|
||||
// Настраиваем Raft
|
||||
raftConfig := raft.DefaultConfig()
|
||||
raftConfig.LocalID = raft.ServerID(fmt.Sprintf("%s-%s", rc.clusterName, nodeIP))
|
||||
raftConfig.HeartbeatTimeout = 1000 * time.Millisecond
|
||||
raftConfig.ElectionTimeout = 1000 * time.Millisecond
|
||||
raftConfig.CommitTimeout = 500 * time.Millisecond
|
||||
raftConfig.LeaderLeaseTimeout = 500 * time.Millisecond
|
||||
|
||||
// Для одноузлового кластера используем специальные настройки и подавляем предупреждения
|
||||
singleNodeMode := len(cfg.Cluster.Nodes) <= 1 || cfg.Cluster.Bootstrap
|
||||
if singleNodeMode {
|
||||
raftConfig.HeartbeatTimeout = 500 * time.Millisecond
|
||||
raftConfig.ElectionTimeout = 500 * time.Millisecond
|
||||
raftConfig.LeaderLeaseTimeout = 500 * time.Millisecond
|
||||
// Подавляем вывод предупреждений для одноузлового режима
|
||||
raftConfig.LogOutput = io.Discard
|
||||
logger.Debug("Running in single-node mode (warnings suppressed)")
|
||||
} else {
|
||||
raftConfig.LogOutput = os.Stderr
|
||||
}
|
||||
|
||||
// Создаём директорию для Raft данных
|
||||
dataDir := cfg.Cluster.RaftDataDir
|
||||
if err := os.MkdirAll(dataDir, 0755); err != nil {
|
||||
return nil, fmt.Errorf("failed to create raft data dir: %v", err)
|
||||
}
|
||||
|
||||
logger.Debug(fmt.Sprintf("Raft data directory: %s", dataDir))
|
||||
|
||||
// Создаём хранилище для логов
|
||||
logStore, err := raftboltdb.NewBoltStore(filepath.Join(dataDir, "raft-log.bolt"))
|
||||
if err != nil {
|
||||
return nil, fmt.Errorf("failed to create log store: %v", err)
|
||||
}
|
||||
|
||||
// Создаём хранилище для стабильных данных
|
||||
stableStore, err := raftboltdb.NewBoltStore(filepath.Join(dataDir, "raft-stable.bolt"))
|
||||
if err != nil {
|
||||
return nil, fmt.Errorf("failed to create stable store: %v", err)
|
||||
}
|
||||
|
||||
// Создаём снапшот хранилище
|
||||
snapshotStore, err := raft.NewFileSnapshotStore(dataDir, 2, os.Stderr)
|
||||
if err != nil {
|
||||
return nil, fmt.Errorf("failed to create snapshot store: %v", err)
|
||||
}
|
||||
|
||||
// Создаём транспорт
|
||||
transport, err := raft.NewTCPTransport(raftAddr, nil, 3, 10*time.Second, os.Stderr)
|
||||
if err != nil {
|
||||
return nil, fmt.Errorf("failed to create transport: %v", err)
|
||||
}
|
||||
|
||||
// Создаём Raft инстанс
|
||||
r, err := raft.NewRaft(raftConfig, rc.fsm, logStore, stableStore, snapshotStore, transport)
|
||||
if err != nil {
|
||||
return nil, fmt.Errorf("failed to create raft: %v", err)
|
||||
}
|
||||
|
||||
rc.raft = r
|
||||
|
||||
// Ждём некоторое время для инициализации Raft
|
||||
time.Sleep(500 * time.Millisecond)
|
||||
|
||||
// Проверяем, нужно ли делать bootstrap
|
||||
bootstrapPath := filepath.Join(dataDir, "raft-log.bolt")
|
||||
_, statErr := os.Stat(bootstrapPath)
|
||||
needsBootstrap := os.IsNotExist(statErr)
|
||||
|
||||
if needsBootstrap && singleNodeMode {
|
||||
logger.Debug("Bootstrapping single-node cluster...")
|
||||
|
||||
configuration := raft.Configuration{
|
||||
Servers: []raft.Server{
|
||||
{
|
||||
ID: raftConfig.LocalID,
|
||||
Address: transport.LocalAddr(),
|
||||
},
|
||||
},
|
||||
}
|
||||
|
||||
future := r.BootstrapCluster(configuration)
|
||||
if err := future.Error(); err != nil {
|
||||
logger.Warn(fmt.Sprintf("Bootstrap error: %v", err))
|
||||
} else {
|
||||
logger.Debug("Single-node cluster bootstrapped successfully")
|
||||
}
|
||||
|
||||
// Ждём после bootstrap
|
||||
time.Sleep(1 * time.Second)
|
||||
|
||||
// Принудительно становимся лидером в одноузловом режиме
|
||||
logger.Debug("Setting as leader in single-node mode...")
|
||||
rc.isLeader.Store(true)
|
||||
|
||||
} else if needsBootstrap && len(cfg.Cluster.Nodes) > 1 {
|
||||
logger.Debug("Bootstrapping multi-node cluster...")
|
||||
|
||||
servers := make([]raft.Server, 0, len(cfg.Cluster.Nodes))
|
||||
for i, nodeAddr := range cfg.Cluster.Nodes {
|
||||
serverID := raft.ServerID(fmt.Sprintf("%s-node%d", rc.clusterName, i+1))
|
||||
servers = append(servers, raft.Server{
|
||||
ID: serverID,
|
||||
Address: raft.ServerAddress(nodeAddr),
|
||||
})
|
||||
}
|
||||
|
||||
configuration := raft.Configuration{
|
||||
Servers: servers,
|
||||
}
|
||||
|
||||
future := r.BootstrapCluster(configuration)
|
||||
if err := future.Error(); err != nil {
|
||||
logger.Warn(fmt.Sprintf("Bootstrap error: %v", err))
|
||||
} else {
|
||||
logger.Debug("Multi-node cluster bootstrapped successfully")
|
||||
}
|
||||
|
||||
// Запускаем мониторинг лидера
|
||||
go rc.monitorLeadership()
|
||||
|
||||
// Ждём выборов лидера
|
||||
logger.Debug("Waiting for leader election...")
|
||||
timeout := time.After(5 * time.Second)
|
||||
leaderElected := false
|
||||
|
||||
for !leaderElected {
|
||||
select {
|
||||
case isLeader := <-rc.leaderMonitor:
|
||||
if isLeader {
|
||||
leaderElected = true
|
||||
rc.isLeader.Store(true)
|
||||
logger.Debug("This node is now the cluster leader")
|
||||
}
|
||||
case <-timeout:
|
||||
logger.Warn("Leader election timeout")
|
||||
leaderElected = true
|
||||
}
|
||||
}
|
||||
} else {
|
||||
// Существующее состояние, просто подключаемся
|
||||
logger.Debug("Existing Raft state found, joining cluster...")
|
||||
go rc.monitorLeadership()
|
||||
|
||||
// Проверяем, не являемся ли мы лидером
|
||||
if r.State() == raft.Leader {
|
||||
rc.isLeader.Store(true)
|
||||
logger.Debug("This node is the cluster leader")
|
||||
}
|
||||
}
|
||||
|
||||
logger.Debug(fmt.Sprintf("Raft coordinator started at %s, IsLeader: %v", raftAddr, rc.isLeader.Load()))
|
||||
|
||||
return rc, nil
|
||||
}
|
||||
|
||||
// monitorLeadership отслеживает изменения лидера
|
||||
func (rc *RaftCoordinator) monitorLeadership() {
|
||||
ticker := time.NewTicker(500 * time.Millisecond)
|
||||
defer ticker.Stop()
|
||||
|
||||
wasLeader := false
|
||||
|
||||
for {
|
||||
select {
|
||||
case <-rc.stopChan:
|
||||
return
|
||||
case <-ticker.C:
|
||||
if rc.raft == nil {
|
||||
continue
|
||||
}
|
||||
isLeader := rc.raft.State() == raft.Leader
|
||||
if isLeader != wasLeader {
|
||||
wasLeader = isLeader
|
||||
select {
|
||||
case rc.leaderMonitor <- isLeader:
|
||||
default:
|
||||
}
|
||||
if isLeader {
|
||||
rc.isLeader.Store(true)
|
||||
rc.logger.Debug("Leadership acquired")
|
||||
} else {
|
||||
rc.isLeader.Store(false)
|
||||
rc.logger.Debug("Leadership lost")
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
// Apply применяет команду к FSM
|
||||
func (f *RaftFSM) Apply(log *raft.Log) interface{} {
|
||||
var cmd NodeRegistrationCommand
|
||||
if err := json.Unmarshal(log.Data, &cmd); err != nil {
|
||||
f.logger.Error(fmt.Sprintf("Failed to unmarshal raft command: %v", err))
|
||||
return err
|
||||
}
|
||||
|
||||
f.state.mu.Lock()
|
||||
defer f.state.mu.Unlock()
|
||||
|
||||
switch cmd.Type {
|
||||
case "register":
|
||||
f.state.Nodes[cmd.Node.ID] = &cmd.Node
|
||||
f.logger.Debug(fmt.Sprintf("Raft: Node registered: %s", cmd.Node.ID))
|
||||
case "remove":
|
||||
delete(f.state.Nodes, cmd.NodeID)
|
||||
f.logger.Debug(fmt.Sprintf("Raft: Node removed: %s", cmd.NodeID))
|
||||
case "set_replication_factor":
|
||||
f.state.ReplicationFactor = cmd.Factor
|
||||
f.logger.Debug(fmt.Sprintf("Raft: Replication factor set to %d", cmd.Factor))
|
||||
}
|
||||
|
||||
return nil
|
||||
}
|
||||
|
||||
// Snapshot реализует создание снапшота
|
||||
func (f *RaftFSM) Snapshot() (raft.FSMSnapshot, error) {
|
||||
f.state.mu.RLock()
|
||||
defer f.state.mu.RUnlock()
|
||||
|
||||
stateCopy := &RaftClusterState{
|
||||
Nodes: make(map[string]*NodeInfo),
|
||||
ReplicationFactor: f.state.ReplicationFactor,
|
||||
}
|
||||
for k, v := range f.state.Nodes {
|
||||
stateCopy.Nodes[k] = v
|
||||
}
|
||||
|
||||
return &RaftSnapshot{state: stateCopy}, nil
|
||||
}
|
||||
|
||||
// Restore восстанавливает состояние из снапшота
|
||||
func (f *RaftFSM) Restore(snapshot io.ReadCloser) error {
|
||||
defer snapshot.Close()
|
||||
|
||||
var state RaftClusterState
|
||||
decoder := json.NewDecoder(snapshot)
|
||||
if err := decoder.Decode(&state); err != nil {
|
||||
return err
|
||||
}
|
||||
|
||||
f.state.mu.Lock()
|
||||
defer f.state.mu.Unlock()
|
||||
f.state.Nodes = state.Nodes
|
||||
f.state.ReplicationFactor = state.ReplicationFactor
|
||||
|
||||
return nil
|
||||
}
|
||||
|
||||
// RaftSnapshot реализует интерфейс FSMSnapshot
|
||||
type RaftSnapshot struct {
|
||||
state *RaftClusterState
|
||||
}
|
||||
|
||||
// Persist сохраняет снапшот
|
||||
func (s *RaftSnapshot) Persist(sink raft.SnapshotSink) error {
|
||||
err := func() error {
|
||||
data, err := json.Marshal(s.state)
|
||||
if err != nil {
|
||||
return err
|
||||
}
|
||||
|
||||
if _, err := sink.Write(data); err != nil {
|
||||
return err
|
||||
}
|
||||
|
||||
return sink.Close()
|
||||
}()
|
||||
|
||||
if err != nil {
|
||||
sink.Cancel()
|
||||
return err
|
||||
}
|
||||
|
||||
return nil
|
||||
}
|
||||
|
||||
// Release освобождает ресурсы
|
||||
func (s *RaftSnapshot) Release() {}
|
||||
|
||||
// RegisterNode регистрирует узел через Raft
|
||||
func (rc *RaftCoordinator) RegisterNode(node *Node) error {
|
||||
// В одноузловом режиме всегда считаем себя лидером
|
||||
if len(rc.config.Cluster.Nodes) <= 1 {
|
||||
rc.logger.Debug("Single-node mode: registering node without Raft consensus")
|
||||
|
||||
// Просто сохраняем узел локально
|
||||
rc.nodes.Store(node.ID, &NodeInfo{
|
||||
ID: node.ID,
|
||||
IP: node.IP,
|
||||
Port: node.Port,
|
||||
Status: "active",
|
||||
LastSeen: time.Now().Unix(),
|
||||
})
|
||||
|
||||
// Также сохраняем в FSM
|
||||
rc.fsm.state.mu.Lock()
|
||||
rc.fsm.state.Nodes[node.ID] = &NodeInfo{
|
||||
ID: node.ID,
|
||||
IP: node.IP,
|
||||
Port: node.Port,
|
||||
Status: "active",
|
||||
LastSeen: time.Now().Unix(),
|
||||
}
|
||||
rc.fsm.state.mu.Unlock()
|
||||
|
||||
rc.logger.Debug(fmt.Sprintf("Node registered locally in single-node mode: %s", node.ID))
|
||||
return nil
|
||||
}
|
||||
|
||||
// Проверяем, является ли текущий узел лидером
|
||||
if !rc.IsLeader() {
|
||||
leader := rc.GetLeader()
|
||||
if leader != nil {
|
||||
rc.logger.Warn(fmt.Sprintf("Current node is not leader. Leader is %s:%d", leader.IP, leader.Port))
|
||||
return fmt.Errorf("node is not the leader. Please connect to leader at %s:%d", leader.IP, leader.Port)
|
||||
}
|
||||
return fmt.Errorf("node is not the leader and no leader found")
|
||||
}
|
||||
|
||||
cmd := NodeRegistrationCommand{
|
||||
Type: "register",
|
||||
Node: NodeInfo{
|
||||
ID: node.ID,
|
||||
IP: node.IP,
|
||||
Port: node.Port,
|
||||
Status: "active",
|
||||
LastSeen: time.Now().Unix(),
|
||||
},
|
||||
}
|
||||
|
||||
data, err := json.Marshal(cmd)
|
||||
if err != nil {
|
||||
return err
|
||||
}
|
||||
|
||||
future := rc.raft.Apply(data, 5*time.Second)
|
||||
if err := future.Error(); err != nil {
|
||||
return fmt.Errorf("failed to register node via raft: %v", err)
|
||||
}
|
||||
|
||||
rc.nodes.Store(node.ID, &NodeInfo{
|
||||
ID: node.ID,
|
||||
IP: node.IP,
|
||||
Port: node.Port,
|
||||
Status: "active",
|
||||
LastSeen: time.Now().Unix(),
|
||||
})
|
||||
|
||||
rc.logger.Debug(fmt.Sprintf("Node registered via Raft: %s", node.ID))
|
||||
return nil
|
||||
}
|
||||
|
||||
// RemoveNode удаляет узел через Raft
|
||||
func (rc *RaftCoordinator) RemoveNode(nodeID string) error {
|
||||
if len(rc.config.Cluster.Nodes) <= 1 {
|
||||
rc.nodes.Delete(nodeID)
|
||||
rc.fsm.state.mu.Lock()
|
||||
delete(rc.fsm.state.Nodes, nodeID)
|
||||
rc.fsm.state.mu.Unlock()
|
||||
rc.logger.Debug(fmt.Sprintf("Node removed locally in single-node mode: %s", nodeID))
|
||||
return nil
|
||||
}
|
||||
|
||||
if !rc.IsLeader() {
|
||||
return fmt.Errorf("node is not the leader")
|
||||
}
|
||||
|
||||
cmd := NodeRegistrationCommand{
|
||||
Type: "remove",
|
||||
NodeID: nodeID,
|
||||
}
|
||||
|
||||
data, err := json.Marshal(cmd)
|
||||
if err != nil {
|
||||
return err
|
||||
}
|
||||
|
||||
future := rc.raft.Apply(data, 5*time.Second)
|
||||
if err := future.Error(); err != nil {
|
||||
return fmt.Errorf("failed to remove node via raft: %v", err)
|
||||
}
|
||||
|
||||
rc.nodes.Delete(nodeID)
|
||||
rc.logger.Debug(fmt.Sprintf("Node removed via Raft: %s", nodeID))
|
||||
return nil
|
||||
}
|
||||
|
||||
// GetActiveNodes возвращает активные узлы
|
||||
func (rc *RaftCoordinator) GetActiveNodes() []*NodeInfo {
|
||||
nodes := make([]*NodeInfo, 0)
|
||||
now := time.Now().Unix()
|
||||
|
||||
state := rc.fsm.state
|
||||
state.mu.RLock()
|
||||
defer state.mu.RUnlock()
|
||||
|
||||
for _, nodeInfo := range state.Nodes {
|
||||
if now-nodeInfo.LastSeen < 30 {
|
||||
nodes = append(nodes, nodeInfo)
|
||||
}
|
||||
}
|
||||
|
||||
return nodes
|
||||
}
|
||||
|
||||
// GetAllNodes возвращает все узлы
|
||||
func (rc *RaftCoordinator) GetAllNodes() []*NodeInfo {
|
||||
state := rc.fsm.state
|
||||
state.mu.RLock()
|
||||
defer state.mu.RUnlock()
|
||||
|
||||
nodes := make([]*NodeInfo, 0, len(state.Nodes))
|
||||
for _, node := range state.Nodes {
|
||||
nodes = append(nodes, node)
|
||||
}
|
||||
return nodes
|
||||
}
|
||||
|
||||
// GetLeader возвращает лидера
|
||||
func (rc *RaftCoordinator) GetLeader() *NodeInfo {
|
||||
if len(rc.config.Cluster.Nodes) <= 1 {
|
||||
// В одноузловом режиме возвращаем единственный узел
|
||||
nodes := rc.GetAllNodes()
|
||||
if len(nodes) > 0 {
|
||||
return nodes[0]
|
||||
}
|
||||
return nil
|
||||
}
|
||||
|
||||
leaderAddr := rc.raft.Leader()
|
||||
if leaderAddr == "" {
|
||||
return nil
|
||||
}
|
||||
|
||||
state := rc.fsm.state
|
||||
state.mu.RLock()
|
||||
defer state.mu.RUnlock()
|
||||
|
||||
for _, node := range state.Nodes {
|
||||
nodeAddr := fmt.Sprintf("%s:%d", node.IP, node.Port)
|
||||
if nodeAddr == string(leaderAddr) {
|
||||
return node
|
||||
}
|
||||
}
|
||||
return nil
|
||||
}
|
||||
|
||||
// IsLeader проверяет, является ли текущий узел лидером
|
||||
func (rc *RaftCoordinator) IsLeader() bool {
|
||||
// В одноузловом режиме всегда лидер
|
||||
if len(rc.config.Cluster.Nodes) <= 1 {
|
||||
return true
|
||||
}
|
||||
return rc.isLeader.Load()
|
||||
}
|
||||
|
||||
// SendHeartbeat обновляет heartbeat узла
|
||||
func (rc *RaftCoordinator) SendHeartbeat(nodeID string) {
|
||||
if val, ok := rc.nodes.Load(nodeID); ok {
|
||||
nodeInfo := val.(*NodeInfo)
|
||||
nodeInfo.LastSeen = time.Now().Unix()
|
||||
rc.nodes.Store(nodeID, nodeInfo)
|
||||
}
|
||||
}
|
||||
|
||||
// GetClusterStatus возвращает статус кластера
|
||||
func (rc *RaftCoordinator) GetClusterStatus() *ClusterStatus {
|
||||
nodes := rc.GetAllNodes()
|
||||
activeNodes := rc.GetActiveNodes()
|
||||
|
||||
syncingNodes := 0
|
||||
for _, node := range nodes {
|
||||
if node.Status == "syncing" {
|
||||
syncingNodes++
|
||||
}
|
||||
}
|
||||
|
||||
leader := rc.GetLeader()
|
||||
leaderID := ""
|
||||
if leader != nil {
|
||||
leaderID = leader.ID
|
||||
}
|
||||
|
||||
return &ClusterStatus{
|
||||
Name: rc.clusterName,
|
||||
TotalNodes: len(nodes),
|
||||
ActiveNodes: len(activeNodes),
|
||||
SyncingNodes: syncingNodes,
|
||||
FailedNodes: len(nodes) - len(activeNodes),
|
||||
ReplicationFactor: int(rc.replicationFactor.Load()),
|
||||
LeaderID: leaderID,
|
||||
Health: rc.calculateHealth(),
|
||||
}
|
||||
}
|
||||
|
||||
// calculateHealth вычисляет здоровье кластера
|
||||
func (rc *RaftCoordinator) calculateHealth() string {
|
||||
activeNodes := rc.GetActiveNodes()
|
||||
totalNodes := rc.GetAllNodes()
|
||||
|
||||
if len(totalNodes) == 0 {
|
||||
return "critical"
|
||||
}
|
||||
|
||||
ratio := float64(len(activeNodes)) / float64(len(totalNodes))
|
||||
if ratio >= 0.8 {
|
||||
return "healthy"
|
||||
} else if ratio >= 0.5 {
|
||||
return "degraded"
|
||||
}
|
||||
return "critical"
|
||||
}
|
||||
|
||||
// GetReplicationFactor возвращает фактор репликации
|
||||
func (rc *RaftCoordinator) GetReplicationFactor() int {
|
||||
return int(rc.replicationFactor.Load())
|
||||
}
|
||||
|
||||
// SetReplicationFactor устанавливает фактор репликации через Raft
|
||||
func (rc *RaftCoordinator) SetReplicationFactor(factor int) error {
|
||||
if !rc.IsLeader() {
|
||||
return fmt.Errorf("node is not the leader")
|
||||
}
|
||||
|
||||
cmd := NodeRegistrationCommand{
|
||||
Type: "set_replication_factor",
|
||||
Factor: int32(factor),
|
||||
}
|
||||
|
||||
data, err := json.Marshal(cmd)
|
||||
if err != nil {
|
||||
return err
|
||||
}
|
||||
|
||||
future := rc.raft.Apply(data, 5*time.Second)
|
||||
if err := future.Error(); err != nil {
|
||||
return fmt.Errorf("failed to set replication factor via raft: %v", err)
|
||||
}
|
||||
|
||||
rc.replicationFactor.Store(int32(factor))
|
||||
rc.logger.Debug(fmt.Sprintf("Replication factor set to %d via Raft", factor))
|
||||
return nil
|
||||
}
|
||||
|
||||
// GetClusterHealth возвращает детальную информацию о здоровье кластера
|
||||
func (rc *RaftCoordinator) GetClusterHealth() *ClusterHealth {
|
||||
health := &ClusterHealth{
|
||||
Nodes: make(map[string]*NodeHealth),
|
||||
OverallScore: 100.0,
|
||||
Recommendations: "",
|
||||
}
|
||||
|
||||
now := time.Now().Unix()
|
||||
state := rc.fsm.state
|
||||
state.mu.RLock()
|
||||
defer state.mu.RUnlock()
|
||||
|
||||
for nodeID, nodeInfo := range state.Nodes {
|
||||
nodeHealth := &NodeHealth{
|
||||
Status: nodeInfo.Status,
|
||||
LatencyMs: 0,
|
||||
LastCheck: now,
|
||||
}
|
||||
|
||||
if now-nodeInfo.LastSeen > 30 {
|
||||
nodeHealth.Status = "offline"
|
||||
health.OverallScore -= 10
|
||||
} else if nodeInfo.Status == "syncing" {
|
||||
health.OverallScore -= 5
|
||||
}
|
||||
|
||||
health.Nodes[nodeID] = nodeHealth
|
||||
}
|
||||
|
||||
if health.OverallScore < 50 {
|
||||
health.Recommendations = "Critical: Check network connectivity and node health immediately"
|
||||
} else if health.OverallScore < 80 {
|
||||
health.Recommendations = "Warning: Some nodes are offline or syncing, consider adding more nodes"
|
||||
} else {
|
||||
health.Recommendations = "Cluster is healthy, all systems operational"
|
||||
}
|
||||
|
||||
return health
|
||||
}
|
||||
|
||||
// IsReplicationEnabled возвращает статус репликации
|
||||
func (rc *RaftCoordinator) IsReplicationEnabled() bool {
|
||||
return rc.replicationEnabled
|
||||
}
|
||||
|
||||
// IsMasterMasterEnabled возвращает статус мастер-мастер репликации
|
||||
func (rc *RaftCoordinator) IsMasterMasterEnabled() bool {
|
||||
return rc.masterMasterEnabled
|
||||
}
|
||||
|
||||
// IsSyncReplicationEnabled возвращает статус синхронной репликации
|
||||
func (rc *RaftCoordinator) IsSyncReplicationEnabled() bool {
|
||||
return rc.syncReplication
|
||||
}
|
||||
|
||||
// Stop останавливает координатор
|
||||
func (rc *RaftCoordinator) Stop() {
|
||||
close(rc.stopChan)
|
||||
if rc.raft != nil {
|
||||
rc.raft.Shutdown()
|
||||
}
|
||||
rc.logger.Debug("Raft coordinator stopped")
|
||||
}
|
||||
47
internal/cluster/types.go
Normal file
47
internal/cluster/types.go
Normal file
@@ -0,0 +1,47 @@
|
||||
// Файл: internal/cluster/types.go
|
||||
// Назначение: Общие типы данных для кластерных операций
|
||||
|
||||
package cluster
|
||||
|
||||
// NodeInfo представляет информацию об узле для координатора
|
||||
type NodeInfo struct {
|
||||
ID string `json:"id"`
|
||||
IP string `json:"ip"`
|
||||
Port int `json:"port"`
|
||||
Status string `json:"status"`
|
||||
LastSeen int64 `json:"last_seen"`
|
||||
}
|
||||
|
||||
// ClusterStatus представляет статус кластера
|
||||
type ClusterStatus struct {
|
||||
Name string `json:"name"`
|
||||
TotalNodes int `json:"total_nodes"`
|
||||
ActiveNodes int `json:"active_nodes"`
|
||||
SyncingNodes int `json:"syncing_nodes"`
|
||||
FailedNodes int `json:"failed_nodes"`
|
||||
ReplicationFactor int `json:"replication_factor"`
|
||||
LeaderID string `json:"leader_id"`
|
||||
Health string `json:"health"`
|
||||
}
|
||||
|
||||
// ClusterHealth представляет информацию о здоровье кластера
|
||||
type ClusterHealth struct {
|
||||
Nodes map[string]*NodeHealth `json:"nodes"`
|
||||
OverallScore float64 `json:"overall_score"`
|
||||
Recommendations string `json:"recommendations"`
|
||||
}
|
||||
|
||||
// NodeHealth представляет здоровье отдельного узла
|
||||
type NodeHealth struct {
|
||||
Status string `json:"status"`
|
||||
LatencyMs int64 `json:"latency_ms"`
|
||||
LastCheck int64 `json:"last_check"`
|
||||
}
|
||||
|
||||
// NodeRequest представляет запрос от одного узла к другому
|
||||
type NodeRequest struct {
|
||||
Type string `json:"type"` // replicate, query, sync, heartbeat
|
||||
Data []byte `json:"data"` // Данные запроса
|
||||
FromNode string `json:"from_node"` // ID узла-отправителя
|
||||
RequestID string `json:"request_id"` // Уникальный ID запроса
|
||||
}
|
||||
Reference in New Issue
Block a user