`53d9636`

complete Go coordination server with gRPC/HTTP APIs, BBolt/PostgreSQL support, health monitoring, and production Docker config

Authored by mfwolffe <wolffemf@dukes.jmu.edu> 8 months ago

SHA: 53d96360d8c7c69f567f8bb450660819491d6926
Parents: 050dfd3
Tree: e05018a

15 changed files

Status	File	+	-
M	`Dockerfile`	42	22
A	`README.md`	481	0
A	`cmd/coordinator/main.go`	159	0
A	`config.yaml.example`	62	0
A	`internal/config/config.go`	162	0
A	`internal/coordinator/coordinator.go`	500	0
A	`internal/coordinator/coordinator_test.go`	516	0
A	`internal/coordinator/helpers.go`	472	0
A	`internal/database/bbolt.go`	242	0
A	`internal/database/database.go`	55	0
A	`internal/database/postgres.go`	358	0
A	`internal/health/monitor.go`	431	0
A	`internal/models/models.go`	222	0
A	`internal/server/grpc.go`	422	0
A	`internal/server/http.go`	448	0

Dockerfilemodified

  FROM golang:1.21-alpine AS builder
  # Install build dependencies
 -RUN apk add --no-cache git ca-certificates
 +RUN apk add --no-cache git ca-certificates tzdata
  WORKDIR /app
 -# Copy go mod files
 +# Copy go mod files first for better caching
  COPY go.mod go.sum ./
 -RUN go mod download
 +RUN go mod download && go mod verify
  # Copy source code
  COPY . .
 -# Build the binary
 -RUN CGO_ENABLED=0 GOOS=linux go build -a -installsuffix cgo -o coordinator ./cmd/coordinator/
 +# Build the application with optimizations
 +RUN CGO_ENABLED=0 GOOS=linux GOARCH=amd64 go build \
 +    -a -installsuffix cgo \
 +    -ldflags='-w -s -extldflags "-static"' \
 +    -o coordinator cmd/coordinator/main.go
 -# Final runtime image
 -FROM alpine:3.19
 +# Runtime stage
 +FROM alpine:3.18
 -# Install ca-certificates for TLS
 -RUN apk --no-cache add ca-certificates
 +# Install runtime dependencies
 +RUN apk --no-cache add \
 +    ca-certificates \
 +    tzdata \
 +    wget \
 +    && update-ca-certificates
 -WORKDIR /root/
 +# Create non-root user for security
 +RUN addgroup -g 1000 zephyrfs && \
 +    adduser -D -s /bin/sh -u 1000 -G zephyrfs zephyrfs
 -# Create non-root user
 -RUN addgroup -g 1000 zephyr && adduser -D -s /bin/sh -u 1000 -G zephyr zephyr
 +# Create necessary directories
 +RUN mkdir -p /data /config /logs && \
 +    chown -R zephyrfs:zephyrfs /data /config /logs
 -# Create data directory
 -RUN mkdir -p /var/lib/zephyrfs && chown zephyr:zephyr /var/lib/zephyrfs
 +WORKDIR /app
  # Copy binary from builder stage
 -COPY --from=builder /app/coordinator .
 -COPY --from=builder /app/configs/config.yaml ./config.yaml
 +COPY --from=builder --chown=zephyrfs:zephyrfs /app/coordinator .
++
 +# Create default configuration
 +RUN echo 'database:\n  type: "bbolt"\n  path: "/data/coordinator.db"\ngrpc:\n  port: 8080\nhttp:\n  enabled: true\n  port: 8090\nhealth:\n  metrics_enabled: true\n  metrics_port: 8091' > /config/config.yaml && \
 +    chown zephyrfs:zephyrfs /config/config.yaml
 -USER zephyr
 +# Switch to non-root user
 +USER zephyrfs
 -# Expose coordinator API port
 -EXPOSE 9090
 +# Expose ports
 +EXPOSE 8080 8090 8091
  # Health check
 -HEALTHCHECK --interval=30s --timeout=3s --start-period=5s --retries=3 \
 -    CMD ./coordinator --health-check || exit 1
 +HEALTHCHECK --interval=30s --timeout=10s --start-period=60s --retries=3 \
 +    CMD wget --no-verbose --tries=1 --spider http://localhost:8091/health || exit 1
++
 +# Set default environment variables
 +ENV CONFIG_PATH=/config/config.yaml
 +ENV DATA_PATH=/data
 +ENV LOG_LEVEL=info
 -ENTRYPOINT ["./coordinator"]
 +# Run the coordinator
 +ENTRYPOINT ["./coordinator"]
 +CMD ["-config", "/config/config.yaml", "-log-level", "info"]

README.mdadded

 +# ZephyrFS Coordinator
++
 +The coordination server for ZephyrFS distributed storage network, written in Go.
++
 +## Overview
++
 +The ZephyrFS Coordinator is a centralized service that manages:
++
 +- **Node Discovery & Registration**: Track active storage nodes in the network
 +- **File & Chunk Metadata**: Coordinate file registration and chunk placement
 +- **Network Health**: Monitor node health and network statistics
 +- **Replication Management**: Ensure proper chunk replication across nodes
++
 +## Architecture
++
 +```
 +┌─────────────────┐    ┌─────────────────┐    ┌─────────────────┐
 +│  ZephyrFS Node  │────│   Coordinator   │────│  ZephyrFS Node  │
 +│                 │    │                 │    │                 │
 +│ • Register      │    │ • Node Registry │    │ • Register      │
 +│ • Heartbeat     │    │ • Chunk Tracker │    │ • Heartbeat     │
 +│ • Report Stats  │    │ • Health Monitor│    │ • Report Stats  │
 +└─────────────────┘    └─────────────────┘    └─────────────────┘
 +         │                       │                       │
 +         └───── File Storage ────┼───── File Storage ────┘
 +                                 │
 +                    ┌─────────────────┐
 +                    │   Web Client    │
 +                    │ • File Upload   │
 +                    │ • Download      │
 +                    │ • Management    │
 +                    └─────────────────┘
 +```
++
 +## Features
++
 +### Core Functionality
 +- **Node Management**: Registration, heartbeat processing, health tracking
 +- **File Coordination**: Metadata storage, chunk placement optimization
 +- **Network Monitoring**: Real-time statistics and health metrics
 +- **High Availability**: Support for multiple coordinator instances
++
 +### APIs
 +- **gRPC API**: High-performance binary protocol for node communication
 +- **REST API**: HTTP/JSON interface for web clients and management
 +- **Health Endpoints**: Kubernetes-compatible health checks
++
 +### Storage Options
 +- **BBolt**: Embedded key-value database (default)
 +- **PostgreSQL**: Production-ready relational database
++
 +### Monitoring
 +- **Prometheus Metrics**: Built-in metrics collection
 +- **Health Checks**: Liveness, readiness, and detailed health status
 +- **Performance Tracking**: Request times, error rates, resource usage
++
 +## Quick Start
++
 +### Prerequisites
++
 +- **Go 1.21+** for building from source
 +- **Docker** for containerized deployment
 +- **PostgreSQL** (optional, for production)
++
 +### Development
++
 +```bash
 +# Clone repository
 +git clone https://github.com/ZephyrFS/zephyrfs-coordinator
 +cd zephyrfs-coordinator
++
 +# Install dependencies
 +go mod download
++
 +# Run with default configuration
 +go run cmd/coordinator/main.go
++
 +# Or with custom config
 +go run cmd/coordinator/main.go -config config.yaml
 +```
++
 +### Docker Deployment
++
 +```bash
 +# Build image
 +docker build -t zephyrfs/coordinator .
++
 +# Run with default settings
 +docker run -p 8080:8080 -p 8090:8090 -p 8091:8091 zephyrfs/coordinator
++
 +# Run with custom configuration
 +docker run -v ./config.yaml:/config/config.yaml \
 +           -v ./data:/data \
 +           -p 8080:8080 -p 8090:8090 -p 8091:8091 \
 +           zephyrfs/coordinator
 +```
++
 +### Docker Compose
++
 +```yaml
 +version: '3.8'
 +services:
 +  coordinator:
 +    image: zephyrfs/coordinator:latest
 +    ports:
 +      - "8080:8080"   # gRPC
 +      - "8090:8090"   # HTTP API
 +      - "8091:8091"   # Metrics
 +    volumes:
 +      - ./data:/data
 +      - ./config.yaml:/config/config.yaml
 +    environment:
 +      - LOG_LEVEL=info
 +    healthcheck:
 +      test: ["CMD", "wget", "--spider", "http://localhost:8091/health"]
 +      interval: 30s
 +      timeout: 10s
 +      retries: 3
 +```
++
 +## Configuration
++
 +### Basic Configuration
++
 +```yaml
 +# config.yaml
 +database:
 +  type: "bbolt"
 +  path: "./coordinator.db"
++
 +grpc:
 +  port: 8080
++
 +http:
 +  enabled: true
 +  port: 8090
++
 +coordinator:
 +  replication_factor: 3
 +  node_timeout: "30s"
 +  heartbeat_interval: "10s"
++
 +health:
 +  metrics_enabled: true
 +  metrics_port: 8091
 +```
++
 +### Environment Variables
++
 +| Variable | Description | Default |
 +|----------|-------------|---------|
 +| `CONFIG_PATH` | Path to configuration file | `config.yaml` |
 +| `LOG_LEVEL` | Logging level (debug/info/warn/error) | `info` |
 +| `DATA_PATH` | Data directory path | `./data` |
 +| `DATABASE_URL` | PostgreSQL connection URL | - |
 +| `GRPC_PORT` | gRPC server port | `8080` |
 +| `HTTP_PORT` | HTTP API server port | `8090` |
 +| `METRICS_PORT` | Metrics server port | `8091` |
++
 +### Production Configuration
++
 +```yaml
 +database:
 +  type: "postgres"
 +  url: "${DATABASE_URL}"
++
 +grpc:
 +  port: 8080
 +  max_message_size: 16777216  # 16MB
++
 +coordinator:
 +  replication_factor: 5
 +  cleanup_interval: "10m"
 +  node_inactive_after: "120s"
++
 +health:
 +  check_interval: "60s"
 +  metrics_enabled: true
 +```
++
 +## API Reference
++
 +### gRPC API
++
 +**Node Management:**
 +```protobuf
 +service CoordinatorService {
 +  rpc RegisterNode(RegisterNodeRequest) returns (RegisterNodeResponse);
 +  rpc UnregisterNode(UnregisterNodeRequest) returns (UnregisterNodeResponse);
 +  rpc NodeHeartbeat(NodeHeartbeatRequest) returns (NodeHeartbeatResponse);
 +  rpc GetActiveNodes(GetActiveNodesRequest) returns (GetActiveNodesResponse);
 +}
 +```
++
 +**File & Chunk Management:**
 +```protobuf
 +rpc RegisterFile(RegisterFileRequest) returns (RegisterFileResponse);
 +rpc GetFileInfo(GetFileInfoRequest) returns (GetFileInfoResponse);
 +rpc FindChunkLocations(FindChunkLocationsRequest) returns (FindChunkLocationsResponse);
 +rpc UpdateChunkLocations(UpdateChunkLocationsRequest) returns (UpdateChunkLocationsResponse);
 +```
++
 +### REST API
++
 +**Node Management:**
 +- `POST /api/v1/nodes/register` - Register a new node
 +- `GET /api/v1/nodes/active` - Get active nodes
 +- `POST /api/v1/nodes/{id}/heartbeat` - Send heartbeat
 +- `POST /api/v1/nodes/{id}/unregister` - Unregister node
++
 +**File Management:**
 +- `POST /api/v1/files/register` - Register a file
 +- `GET /api/v1/files/{id}` - Get file information
 +- `DELETE /api/v1/files/{id}` - Delete file
++
 +**Network Status:**
 +- `GET /api/v1/network/status` - Get network status
 +- `GET /api/v1/network/stats` - Get network statistics
++
 +**Health & Monitoring:**
 +- `GET /health` - Health check
 +- `GET /ready` - Readiness check
 +- `GET /live` - Liveness check
 +- `GET /metrics` - Prometheus metrics
++
 +### Example Usage
++
 +**Register a Node (REST):**
 +```bash
 +curl -X POST http://localhost:8090/api/v1/nodes/register \
 +  -H "Content-Type: application/json" \
 +  -d '{
 +    "addresses": ["127.0.0.1:8080"],
 +    "storage_capacity": 1000000000,
 +    "capabilities": {"version": "1.0.0"}
 +  }'
 +```
++
 +**Get Network Status:**
 +```bash
 +curl http://localhost:8090/api/v1/network/status
 +```
++
 +**Health Check:**
 +```bash
 +curl http://localhost:8091/health
 +```
++
 +## Monitoring
++
 +### Metrics
++
 +The coordinator exposes Prometheus-compatible metrics at `/metrics`:
++
 +```
 +# HELP coordinator_nodes_total Total number of registered nodes
 +# TYPE coordinator_nodes_total gauge
 +coordinator_nodes_total{status="active"} 5
 +coordinator_nodes_total{status="inactive"} 1
++
 +# HELP coordinator_files_total Total number of registered files
 +# TYPE coordinator_files_total gauge
 +coordinator_files_total 150
++
 +# HELP coordinator_chunks_total Total number of tracked chunks
 +# TYPE coordinator_chunks_total gauge
 +coordinator_chunks_total 1500
 +```
++
 +### Health Checks
++
 +**Kubernetes Liveness Probe:**
 +```yaml
 +livenessProbe:
 +  httpGet:
 +    path: /live
 +    port: 8091
 +  initialDelaySeconds: 30
 +  periodSeconds: 10
 +```
++
 +**Kubernetes Readiness Probe:**
 +```yaml
 +readinessProbe:
 +  httpGet:
 +    path: /ready
 +    port: 8091
 +  initialDelaySeconds: 5
 +  periodSeconds: 5
 +```
++
 +### Logging
++
 +Structured JSON logging with configurable levels:
++
 +```json
 +{
 +  "level": "info",
 +  "time": "2024-01-15T10:30:45Z",
 +  "msg": "Node registered",
 +  "nodeID": "node-123",
 +  "addresses": ["127.0.0.1:8080"],
 +  "capacity": 1000000000
 +}
 +```
++
 +## Development
++
 +### Building
++
 +```bash
 +# Build binary
 +go build -o coordinator cmd/coordinator/main.go
++
 +# Build Docker image
 +docker build -t zephyrfs/coordinator .
++
 +# Run tests
 +go test ./...
++
 +# Run with race detection
 +go test -race ./...
++
 +# Generate protobuf code
 +make proto
 +```
++
 +### Testing
++
 +```bash
 +# Unit tests
 +go test ./internal/...
++
 +# Integration tests
 +go test -tags=integration ./...
++
 +# Benchmark tests
 +go test -bench=. ./internal/coordinator/
++
 +# Coverage report
 +go test -coverprofile=coverage.out ./...
 +go tool cover -html=coverage.out
 +```
++
 +### Contributing
++
 +1. Fork the repository
 +2. Create feature branch: `git checkout -b feature/amazing-feature`
 +3. Write tests for your changes
 +4. Run tests: `go test ./...`
 +5. Commit changes: `git commit -m "Add amazing feature"`
 +6. Push branch: `git push origin feature/amazing-feature`
 +7. Create Pull Request
++
 +## Deployment
++
 +### Production Checklist
++
 +- [ ] Configure PostgreSQL database
 +- [ ] Set up TLS certificates
 +- [ ] Configure monitoring and alerting
 +- [ ] Set resource limits and requests
 +- [ ] Configure backup strategy
 +- [ ] Set up log aggregation
 +- [ ] Configure service discovery
 +- [ ] Set up load balancing (for multiple instances)
++
 +### Kubernetes Deployment
++
 +```yaml
 +apiVersion: apps/v1
 +kind: Deployment
 +metadata:
 +  name: zephyrfs-coordinator
 +spec:
 +  replicas: 2
 +  selector:
 +    matchLabels:
 +      app: zephyrfs-coordinator
 +  template:
 +    metadata:
 +      labels:
 +        app: zephyrfs-coordinator
 +    spec:
 +      containers:
 +      - name: coordinator
 +        image: zephyrfs/coordinator:latest
 +        ports:
 +        - containerPort: 8080
 +          name: grpc
 +        - containerPort: 8090
 +          name: http
 +        - containerPort: 8091
 +          name: metrics
 +        env:
 +        - name: DATABASE_URL
 +          valueFrom:
 +            secretKeyRef:
 +              name: coordinator-secrets
 +              key: database-url
 +        livenessProbe:
 +          httpGet:
 +            path: /live
 +            port: 8091
 +        readinessProbe:
 +          httpGet:
 +            path: /ready
 +            port: 8091
 +        resources:
 +          requests:
 +            memory: "256Mi"
 +            cpu: "250m"
 +          limits:
 +            memory: "512Mi"
 +            cpu: "500m"
 +```
++
 +## Troubleshooting
++
 +### Common Issues
++
 +**Database Connection Failed:**
 +```
 +Error: failed to open database: connection refused
 +```
 +- Check database configuration
 +- Verify database server is running
 +- Check network connectivity
++
 +**High Memory Usage:**
 +```
 +Warning: memory usage above 80%
 +```
 +- Monitor node count and file metadata
 +- Consider increasing memory limits
 +- Check for memory leaks in logs
++
 +**Slow Response Times:**
 +```
 +Warning: API response time > 1s
 +```
 +- Check database performance
 +- Monitor active connections
 +- Consider database indexing
++
 +### Debug Mode
++
 +Enable debug logging for troubleshooting:
++
 +```bash
 +./coordinator -log-level debug
 +```
++
 +Or set environment variable:
 +```bash
 +export LOG_LEVEL=debug
 +./coordinator
 +```
++
 +### Performance Tuning
++
 +**Database Optimization:**
 +- Use PostgreSQL for production workloads
 +- Configure appropriate connection pooling
 +- Add database indexes for frequently queried fields
++
 +**Resource Limits:**
 +- Set appropriate memory limits based on node count
 +- Monitor CPU usage during peak operations
 +- Configure garbage collection settings
++
 +## License
++
 +MIT License - see LICENSE file for details.
++
 +## Support
++
 +- **Documentation**: [ZephyrFS Docs](https://docs.zephyrfs.io)
 +- **Issues**: [GitHub Issues](https://github.com/ZephyrFS/zephyrfs-coordinator/issues)
 +- **Discussions**: [GitHub Discussions](https://github.com/ZephyrFS/zephyrfs-coordinator/discussions)
 +- **Security**: [security@zephyrfs.io](mailto:security@zephyrfs.io)

cmd/coordinator/main.goadded

 +package main
++
 +import (
 +	"context"
 +	"flag"
 +	"fmt"
 +	"net"
 +	"net/http"
 +	"os"
 +	"os/signal"
 +	"syscall"
 +	"time"
++
 +	"github.com/gin-gonic/gin"
 +	"github.com/sirupsen/logrus"
 +	"google.golang.org/grpc"
 +	"google.golang.org/grpc/reflection"
++
 +	"github.com/ZephyrFS/zephyrfs-coordinator/internal/config"
 +	"github.com/ZephyrFS/zephyrfs-coordinator/internal/coordinator"
 +	"github.com/ZephyrFS/zephyrfs-coordinator/internal/database"
 +	"github.com/ZephyrFS/zephyrfs-coordinator/internal/health"
 +	"github.com/ZephyrFS/zephyrfs-coordinator/internal/server"
 +)
++
 +var (
 +	configPath = flag.String("config", "config.yaml", "Path to configuration file")
 +	logLevel   = flag.String("log-level", "info", "Log level (debug, info, warn, error)")
 +	version    = "dev" // Set during build
 +	buildTime  = "unknown"
 +)
++
 +func main() {
 +	flag.Parse()
++
 +	// Configure logging
 +	setupLogging(*logLevel)
++
 +	logrus.WithFields(logrus.Fields{
 +		"version":   version,
 +		"buildTime": buildTime,
 +	}).Info("Starting ZephyrFS Coordinator")
++
 +	// Load configuration
 +	cfg, err := config.Load(*configPath)
 +	if err != nil {
 +		logrus.WithError(err).Fatal("Failed to load configuration")
 +	}
++
 +	logrus.WithField("config", cfg).Debug("Configuration loaded")
++
 +	// Initialize database
 +	db, err := database.New(cfg.Database)
 +	if err != nil {
 +		logrus.WithError(err).Fatal("Failed to initialize database")
 +	}
 +	defer db.Close()
++
 +	// Initialize coordinator service
 +	coord := coordinator.New(db, cfg.Coordinator)
++
 +	// Setup graceful shutdown
 +	ctx, cancel := context.WithCancel(context.Background())
 +	defer cancel()
++
 +	// Start gRPC server
 +	go func() {
 +		if err := startGRPCServer(coord, cfg.GRPC); err != nil {
 +			logrus.WithError(err).Fatal("gRPC server failed")
 +		}
 +	}()
++
 +	// Start HTTP server
 +	go func() {
 +		if err := startHTTPServer(coord, cfg.HTTP); err != nil {
 +			logrus.WithError(err).Fatal("HTTP server failed")
 +		}
 +	}()
++
 +	// Start health monitoring
 +	go func() {
 +		health.Monitor(ctx, coord, cfg.Health)
 +	}()
++
 +	// Wait for shutdown signal
 +	sigChan := make(chan os.Signal, 1)
 +	signal.Notify(sigChan, syscall.SIGINT, syscall.SIGTERM)
++
 +	<-sigChan
 +	logrus.Info("Shutdown signal received, gracefully stopping...")
++
 +	// Graceful shutdown with timeout
 +	shutdownCtx, shutdownCancel := context.WithTimeout(context.Background(), 30*time.Second)
 +	defer shutdownCancel()
++
 +	cancel() // Cancel background goroutines
 +	coord.Shutdown(shutdownCtx)
++
 +	logrus.Info("ZephyrFS Coordinator stopped")
 +}
++
 +func setupLogging(level string) {
 +	logrus.SetFormatter(&logrus.JSONFormatter{
 +		TimestampFormat: time.RFC3339,
 +	})
++
 +	switch level {
 +	case "debug":
 +		logrus.SetLevel(logrus.DebugLevel)
 +	case "info":
 +		logrus.SetLevel(logrus.InfoLevel)
 +	case "warn":
 +		logrus.SetLevel(logrus.WarnLevel)
 +	case "error":
 +		logrus.SetLevel(logrus.ErrorLevel)
 +	default:
 +		logrus.SetLevel(logrus.InfoLevel)
 +	}
 +}
++
 +func startGRPCServer(coord *coordinator.Coordinator, cfg config.GRPCConfig) error {
 +	listener, err := net.Listen("tcp", fmt.Sprintf(":%d", cfg.Port))
 +	if err != nil {
 +		return fmt.Errorf("failed to listen on port %d: %w", cfg.Port, err)
 +	}
++
 +	grpcServer := grpc.NewServer(
 +		grpc.UnaryInterceptor(server.LoggingInterceptor),
 +		grpc.MaxRecvMsgSize(cfg.MaxMessageSize),
 +		grpc.MaxSendMsgSize(cfg.MaxMessageSize),
 +	)
++
 +	// Register coordinator service
 +	server.RegisterCoordinatorService(grpcServer, coord)
++
 +	// Enable reflection for development
 +	if cfg.EnableReflection {
 +		reflection.Register(grpcServer)
 +	}
++
 +	logrus.WithField("port", cfg.Port).Info("Starting gRPC server")
 +	return grpcServer.Serve(listener)
 +}
++
 +func startHTTPServer(coord *coordinator.Coordinator, cfg config.HTTPConfig) error {
 +	if !cfg.Enabled {
 +		return nil
 +	}
++
 +	gin.SetMode(gin.ReleaseMode)
 +	router := gin.New()
 +	router.Use(gin.Recovery())
++
 +	// Setup HTTP API routes
 +	server.SetupHTTPRoutes(router, coord)
++
 +	logrus.WithField("port", cfg.Port).Info("Starting HTTP server")
 +	return http.ListenAndServe(fmt.Sprintf(":%d", cfg.Port), router)
 +}

config.yaml.exampleadded

 +# ZephyrFS Coordinator Configuration
++
 +# Database configuration
 +database:
 +  type: "bbolt"          # "bbolt" or "postgres"
 +  path: "./coordinator.db"    # Path for bbolt database
 +  # url: "postgresql://user:pass@localhost:5432/coordinator"  # URL for PostgreSQL
++
 +# gRPC server configuration
 +grpc:
 +  port: 8080                    # gRPC server port
 +  max_message_size: 4194304     # 4MB max message size
 +  enable_reflection: false      # Enable gRPC reflection (development only)
++
 +# HTTP API server configuration
 +http:
 +  enabled: true                 # Enable HTTP API server
 +  port: 8090                   # HTTP API server port
++
 +# Coordinator-specific configuration
 +coordinator:
 +  node_timeout: "30s"           # Node operation timeout
 +  heartbeat_interval: "10s"     # Expected heartbeat interval
 +  replication_factor: 3         # Default replication factor
 +  max_nodes_per_chunk: 10      # Maximum nodes to store a single chunk
 +  cleanup_interval: "5m"        # Cleanup inactive nodes interval
 +  node_inactive_after: "60s"   # Mark node inactive after this timeout
 +  geographic_spread: true       # Enable geographic distribution
++
 +# Health monitoring configuration
 +health:
 +  check_interval: "30s"         # Health check interval
 +  metrics_enabled: true         # Enable metrics collection
 +  metrics_port: 8091           # Metrics HTTP server port
++
 +# Development/Production configurations
++
 +# Development configuration
 +dev:
 +  database:
 +    type: "bbolt"
 +    path: "./dev-coordinator.db"
 +  grpc:
 +    enable_reflection: true
 +  coordinator:
 +    cleanup_interval: "1m"
 +    node_inactive_after: "30s"
++
 +# Production configuration
 +prod:
 +  database:
 +    type: "postgres"
 +    url: "${DATABASE_URL}"
 +  grpc:
 +    port: 8080
 +    max_message_size: 16777216  # 16MB for production
 +  coordinator:
 +    replication_factor: 5       # Higher replication for production
 +    cleanup_interval: "10m"
 +    node_inactive_after: "120s"
 +  health:
 +    check_interval: "60s"

internal/config/config.goadded

 +package config
++
 +import (
 +	"fmt"
 +	"os"
 +	"time"
++
 +	"gopkg.in/yaml.v3"
 +)
++
 +// Config represents the coordinator configuration
 +type Config struct {
 +	Database    DatabaseConfig    `yaml:"database"`
 +	GRPC        GRPCConfig        `yaml:"grpc"`
 +	HTTP        HTTPConfig        `yaml:"http"`
 +	Coordinator CoordinatorConfig `yaml:"coordinator"`
 +	Health      HealthConfig      `yaml:"health"`
 +}
++
 +// DatabaseConfig contains database settings
 +type DatabaseConfig struct {
 +	Type string `yaml:"type"` // "bbolt" or "postgres"
 +	Path string `yaml:"path"` // For bbolt
 +	URL  string `yaml:"url"`  // For postgres
 +}
++
 +// GRPCConfig contains gRPC server settings
 +type GRPCConfig struct {
 +	Port             int  `yaml:"port"`
 +	MaxMessageSize   int  `yaml:"max_message_size"`
 +	EnableReflection bool `yaml:"enable_reflection"`
 +}
++
 +// HTTPConfig contains HTTP server settings
 +type HTTPConfig struct {
 +	Enabled bool `yaml:"enabled"`
 +	Port    int  `yaml:"port"`
 +}
++
 +// CoordinatorConfig contains coordinator-specific settings
 +type CoordinatorConfig struct {
 +	NodeTimeout        time.Duration `yaml:"node_timeout"`
 +	HeartbeatInterval  time.Duration `yaml:"heartbeat_interval"`
 +	ReplicationFactor  int           `yaml:"replication_factor"`
 +	MaxNodesPerChunk   int           `yaml:"max_nodes_per_chunk"`
 +	CleanupInterval    time.Duration `yaml:"cleanup_interval"`
 +	NodeInactiveAfter  time.Duration `yaml:"node_inactive_after"`
 +	GeographicSpread   bool          `yaml:"geographic_spread"`
 +}
++
 +// HealthConfig contains health monitoring settings
 +type HealthConfig struct {
 +	CheckInterval     time.Duration `yaml:"check_interval"`
 +	MetricsEnabled    bool          `yaml:"metrics_enabled"`
 +	MetricsPort       int           `yaml:"metrics_port"`
 +}
++
 +// DefaultConfig returns a configuration with sensible defaults
 +func DefaultConfig() *Config {
 +	return &Config{
 +		Database: DatabaseConfig{
 +			Type: "bbolt",
 +			Path: "coordinator.db",
 +		},
 +		GRPC: GRPCConfig{
 +			Port:             8080,
 +			MaxMessageSize:   4 * 1024 * 1024, // 4MB
 +			EnableReflection: false,
 +		},
 +		HTTP: HTTPConfig{
 +			Enabled: true,
 +			Port:    8090,
 +		},
 +		Coordinator: CoordinatorConfig{
 +			NodeTimeout:        30 * time.Second,
 +			HeartbeatInterval:  10 * time.Second,
 +			ReplicationFactor:  3,
 +			MaxNodesPerChunk:   10,
 +			CleanupInterval:    5 * time.Minute,
 +			NodeInactiveAfter:  60 * time.Second,
 +			GeographicSpread:   true,
 +		},
 +		Health: HealthConfig{
 +			CheckInterval:  30 * time.Second,
 +			MetricsEnabled: true,
 +			MetricsPort:    8091,
 +		},
 +	}
 +}
++
 +// Load reads configuration from a YAML file, merging with defaults
 +func Load(path string) (*Config, error) {
 +	cfg := DefaultConfig()
++
 +	if _, err := os.Stat(path); os.IsNotExist(err) {
 +		// Config file doesn't exist, use defaults
 +		return cfg, nil
 +	}
++
 +	data, err := os.ReadFile(path)
 +	if err != nil {
 +		return nil, fmt.Errorf("failed to read config file %s: %w", path, err)
 +	}
++
 +	if err := yaml.Unmarshal(data, cfg); err != nil {
 +		return nil, fmt.Errorf("failed to parse config file %s: %w", path, err)
 +	}
++
 +	// Validate configuration
 +	if err := cfg.Validate(); err != nil {
 +		return nil, fmt.Errorf("invalid configuration: %w", err)
 +	}
++
 +	return cfg, nil
 +}
++
 +// Validate checks if the configuration is valid
 +func (c *Config) Validate() error {
 +	if c.Database.Type == "" {
 +		return fmt.Errorf("database type is required")
 +	}
++
 +	if c.Database.Type == "bbolt" && c.Database.Path == "" {
 +		return fmt.Errorf("database path is required for bbolt")
 +	}
++
 +	if c.Database.Type == "postgres" && c.Database.URL == "" {
 +		return fmt.Errorf("database URL is required for postgres")
 +	}
++
 +	if c.GRPC.Port <= 0 || c.GRPC.Port > 65535 {
 +		return fmt.Errorf("invalid gRPC port: %d", c.GRPC.Port)
 +	}
++
 +	if c.HTTP.Enabled && (c.HTTP.Port <= 0 || c.HTTP.Port > 65535) {
 +		return fmt.Errorf("invalid HTTP port: %d", c.HTTP.Port)
 +	}
++
 +	if c.Coordinator.ReplicationFactor <= 0 {
 +		return fmt.Errorf("replication factor must be positive")
 +	}
++
 +	if c.Coordinator.MaxNodesPerChunk <= 0 {
 +		return fmt.Errorf("max nodes per chunk must be positive")
 +	}
++
 +	return nil
 +}
++
 +// Save writes the configuration to a YAML file
 +func (c *Config) Save(path string) error {
 +	data, err := yaml.Marshal(c)
 +	if err != nil {
 +		return fmt.Errorf("failed to marshal config: %w", err)
 +	}
++
 +	if err := os.WriteFile(path, data, 0644); err != nil {
 +		return fmt.Errorf("failed to write config file %s: %w", path, err)
 +	}
++
 +	return nil
 +}

internal/coordinator/coordinator.goadded

 +package coordinator
++
 +import (
 +	"context"
 +	"encoding/json"
 +	"fmt"
 +	"math/rand"
 +	"sort"
 +	"sync"
 +	"time"
++
 +	"github.com/sirupsen/logrus"
 +	"go.etcd.io/bbolt"
++
 +	"github.com/ZephyrFS/zephyrfs-coordinator/internal/config"
 +	"github.com/ZephyrFS/zephyrfs-coordinator/internal/database"
 +	"github.com/ZephyrFS/zephyrfs-coordinator/internal/models"
 +)
++
 +const (
 +	nodesBucket  = "nodes"
 +	filesBucket  = "files"
 +	chunksBucket = "chunks"
 +)
++
 +// Coordinator manages the ZephyrFS network
 +type Coordinator struct {
 +	db     database.Database
 +	config config.CoordinatorConfig
++
 +	// In-memory caches for performance
 +	nodes     map[string]*models.NodeInfo
 +	nodesMux  sync.RWMutex
 +	files     map[string]*models.FileRecord
 +	filesMux  sync.RWMutex
 +	chunks    map[string]*models.ChunkInfo
 +	chunksMux sync.RWMutex
++
 +	// Background tasks
 +	stopChan chan struct{}
 +	wg       sync.WaitGroup
++
 +	// Statistics
 +	stats *models.NetworkStats
 +}
++
 +// New creates a new Coordinator instance
 +func New(db database.Database, cfg config.CoordinatorConfig) *Coordinator {
 +	coord := &Coordinator{
 +		db:       db,
 +		config:   cfg,
 +		nodes:    make(map[string]*models.NodeInfo),
 +		files:    make(map[string]*models.FileRecord),
 +		chunks:   make(map[string]*models.ChunkInfo),
 +		stopChan: make(chan struct{}),
 +		stats:    &models.NetworkStats{},
 +	}
++
 +	// Load data from database
 +	if err := coord.loadFromDatabase(); err != nil {
 +		logrus.WithError(err).Error("Failed to load data from database")
 +	}
++
 +	// Start background tasks
 +	coord.startBackgroundTasks()
++
 +	return coord
 +}
++
 +// RegisterNode registers a new node in the network
 +func (c *Coordinator) RegisterNode(ctx context.Context, req *models.RegisterNodeRequest) (*models.RegisterNodeResponse, error) {
 +	c.nodesMux.Lock()
 +	defer c.nodesMux.Unlock()
++
 +	nodeID := req.NodeID
 +	if nodeID == "" {
 +		nodeID = generateNodeID()
 +	}
++
 +	node := &models.NodeInfo{
 +		NodeID:          nodeID,
 +		Addresses:       req.Addresses,
 +		StorageCapacity: req.StorageCapacity,
 +		Capabilities:    req.Capabilities,
 +		Status:          "active",
 +		RegisteredAt:    time.Now(),
 +		LastHeartbeat:   time.Now(),
 +		Stats:           &models.NodeStats{},
 +	}
++
 +	// Store in memory and database
 +	c.nodes[nodeID] = node
 +	if err := c.saveNode(node); err != nil {
 +		logrus.WithError(err).Error("Failed to save node to database")
 +		delete(c.nodes, nodeID)
 +		return nil, fmt.Errorf("failed to register node: %w", err)
 +	}
++
 +	// Get bootstrap peers
 +	bootstrapPeers := c.getBootstrapPeers(nodeID, 5)
++
 +	logrus.WithFields(logrus.Fields{
 +		"nodeID":         nodeID,
 +		"addresses":      req.Addresses,
 +		"capacity":       req.StorageCapacity,
 +		"bootstrapPeers": len(bootstrapPeers),
 +	}).Info("Node registered")
++
 +	return &models.RegisterNodeResponse{
 +		Success:        true,
 +		Message:        "Node registered successfully",
 +		AssignedNodeID: nodeID,
 +		BootstrapPeers: bootstrapPeers,
 +	}, nil
 +}
++
 +// UnregisterNode removes a node from the network
 +func (c *Coordinator) UnregisterNode(ctx context.Context, req *models.UnregisterNodeRequest) (*models.UnregisterNodeResponse, error) {
 +	c.nodesMux.Lock()
 +	defer c.nodesMux.Unlock()
++
 +	node, exists := c.nodes[req.NodeID]
 +	if !exists {
 +		return &models.UnregisterNodeResponse{
 +			Success: false,
 +			Message: "Node not found",
 +		}, nil
 +	}
++
 +	// Mark as inactive and trigger chunk replication
 +	node.Status = "inactive"
 +	node.LastHeartbeat = time.Now()
++
 +	if err := c.saveNode(node); err != nil {
 +		logrus.WithError(err).Error("Failed to update node status")
 +	}
++
 +	// Schedule chunk redistribution
 +	go c.redistributeChunksFromNode(req.NodeID)
++
 +	logrus.WithFields(logrus.Fields{
 +		"nodeID": req.NodeID,
 +		"reason": req.Reason,
 +	}).Info("Node unregistered")
++
 +	return &models.UnregisterNodeResponse{
 +		Success: true,
 +		Message: "Node unregistered successfully",
 +	}, nil
 +}
++
 +// NodeHeartbeat processes heartbeat from a node
 +func (c *Coordinator) NodeHeartbeat(ctx context.Context, req *models.NodeHeartbeatRequest) (*models.NodeHeartbeatResponse, error) {
 +	c.nodesMux.Lock()
 +	defer c.nodesMux.Unlock()
++
 +	node, exists := c.nodes[req.NodeID]
 +	if !exists {
 +		return &models.NodeHeartbeatResponse{
 +			Success: false,
 +			Message: "Node not registered",
 +		}, nil
 +	}
++
 +	// Update node stats and heartbeat
 +	node.LastHeartbeat = time.Now()
 +	node.Status = "active"
 +	if req.Stats != nil {
 +		node.Stats = req.Stats
 +	}
++
 +	if err := c.saveNode(node); err != nil {
 +		logrus.WithError(err).Error("Failed to save node heartbeat")
 +	}
++
 +	// Generate tasks for the node
 +	tasks := c.generateTasksForNode(req.NodeID)
++
 +	return &models.NodeHeartbeatResponse{
 +		Success: true,
 +		Message: "Heartbeat processed",
 +		Tasks:   tasks,
 +	}, nil
 +}
++
 +// GetActiveNodes returns a list of active nodes
 +func (c *Coordinator) GetActiveNodes(ctx context.Context, req *models.GetActiveNodesRequest) (*models.GetActiveNodesResponse, error) {
 +	c.nodesMux.RLock()
 +	defer c.nodesMux.RUnlock()
++
 +	var activeNodes []*models.NodeStatus
 +	excludeSet := make(map[string]bool)
 +	for _, nodeID := range req.ExcludeNodes {
 +		excludeSet[nodeID] = true
 +	}
++
 +	for _, node := range c.nodes {
 +		if node.Status == "active" && !excludeSet[node.NodeID] {
 +			if time.Since(node.LastHeartbeat) < c.config.NodeInactiveAfter {
 +				activeNodes = append(activeNodes, &models.NodeStatus{
 +					NodeID:        node.NodeID,
 +					Addresses:     node.Addresses,
 +					Stats:         node.Stats,
 +					LastHeartbeat: node.LastHeartbeat.Unix(),
 +					Status:        node.Status,
 +				})
 +			}
 +		}
 +	}
++
 +	// Sort by reliability/reputation if available
 +	sort.Slice(activeNodes, func(i, j int) bool {
 +		return activeNodes[i].Stats.UptimeSeconds > activeNodes[j].Stats.UptimeSeconds
 +	})
++
 +	// Apply limit
 +	if req.Limit > 0 && len(activeNodes) > int(req.Limit) {
 +		activeNodes = activeNodes[:req.Limit]
 +	}
++
 +	return &models.GetActiveNodesResponse{
 +		Nodes:      activeNodes,
 +		TotalNodes: int32(len(activeNodes)),
 +	}, nil
 +}
++
 +// RegisterFile registers file metadata and determines chunk placement
 +func (c *Coordinator) RegisterFile(ctx context.Context, req *models.RegisterFileRequest) (*models.RegisterFileResponse, error) {
 +	c.filesMux.Lock()
 +	c.chunksMux.Lock()
 +	defer c.filesMux.Unlock()
 +	defer c.chunksMux.Unlock()
++
 +	// Create file record
 +	file := &models.FileRecord{
 +		FileID:       req.FileID,
 +		FileName:     req.FileName,
 +		FileSize:     req.FileSize,
 +		FileHash:     req.FileHash,
 +		OwnerNodeID:  req.OwnerNodeID,
 +		CreatedAt:    time.Now().Unix(),
 +		LastAccessed: time.Now().Unix(),
 +	}
++
 +	// Determine chunk placements
 +	var chunkPlacements []*models.ChunkPlacement
 +	for _, chunkMeta := range req.Chunks {
 +		targetNodes := c.selectNodesForChunk(chunkMeta.ChunkID, c.config.ReplicationFactor)
++
 +		placement := &models.ChunkPlacement{
 +			ChunkID:           chunkMeta.ChunkID,
 +			TargetNodes:       targetNodes,
 +			ReplicationFactor: int32(c.config.ReplicationFactor),
 +		}
 +		chunkPlacements = append(chunkPlacements, placement)
++
 +		// Create chunk record
 +		chunk := &models.ChunkInfo{
 +			ChunkID:       chunkMeta.ChunkID,
 +			Hash:          chunkMeta.Hash,
 +			Size:          chunkMeta.Size,
 +			Index:         chunkMeta.Index,
 +			FileID:        req.FileID,
 +			StoredAtNodes: targetNodes,
 +			CreatedAt:     time.Now().Unix(),
 +		}
 +		c.chunks[chunkMeta.ChunkID] = chunk
 +		file.Chunks = append(file.Chunks, &models.ChunkRecord{
 +			ChunkID:           chunkMeta.ChunkID,
 +			Hash:              chunkMeta.Hash,
 +			Size:              chunkMeta.Size,
 +			Index:             chunkMeta.Index,
 +			StoredAtNodes:     targetNodes,
 +			ReplicationCount:  int32(len(targetNodes)),
 +		})
++
 +		if err := c.saveChunk(chunk); err != nil {
 +			logrus.WithError(err).Error("Failed to save chunk metadata")
 +		}
 +	}
++
 +	// Save file record
 +	c.files[req.FileID] = file
 +	if err := c.saveFile(file); err != nil {
 +		logrus.WithError(err).Error("Failed to save file metadata")
 +		return nil, fmt.Errorf("failed to register file: %w", err)
 +	}
++
 +	logrus.WithFields(logrus.Fields{
 +		"fileID":   req.FileID,
 +		"fileName": req.FileName,
 +		"fileSize": req.FileSize,
 +		"chunks":   len(req.Chunks),
 +	}).Info("File registered")
++
 +	return &models.RegisterFileResponse{
 +		Success:         true,
 +		Message:         "File registered successfully",
 +		ChunkPlacements: chunkPlacements,
 +	}, nil
 +}
++
 +// FindChunkLocations finds nodes storing a specific chunk
 +func (c *Coordinator) FindChunkLocations(ctx context.Context, req *models.FindChunkLocationsRequest) (*models.FindChunkLocationsResponse, error) {
 +	c.chunksMux.RLock()
 +	defer c.chunksMux.RUnlock()
++
 +	chunk, exists := c.chunks[req.ChunkID]
 +	if !exists {
 +		return &models.FindChunkLocationsResponse{
 +			Success: false,
 +			Message: "Chunk not found",
 +		}, nil
 +	}
++
 +	// Filter out inactive nodes
 +	var activeNodes []string
 +	var activeAddresses []string
++
 +	c.nodesMux.RLock()
 +	for _, nodeID := range chunk.StoredAtNodes {
 +		if node, exists := c.nodes[nodeID]; exists {
 +			if node.Status == "active" && time.Since(node.LastHeartbeat) < c.config.NodeInactiveAfter {
 +				activeNodes = append(activeNodes, nodeID)
 +				activeAddresses = append(activeAddresses, node.Addresses[0]) // Use first address
 +			}
 +		}
 +	}
 +	c.nodesMux.RUnlock()
++
 +	// Apply preferred count
 +	if req.PreferredCount > 0 && len(activeNodes) > int(req.PreferredCount) {
 +		// Randomly select preferred count
 +		rand.Shuffle(len(activeNodes), func(i, j int) {
 +			activeNodes[i], activeNodes[j] = activeNodes[j], activeNodes[i]
 +			activeAddresses[i], activeAddresses[j] = activeAddresses[j], activeAddresses[i]
 +		})
 +		activeNodes = activeNodes[:req.PreferredCount]
 +		activeAddresses = activeAddresses[:req.PreferredCount]
 +	}
++
 +	return &models.FindChunkLocationsResponse{
 +		Success:       true,
 +		Message:       "Chunk locations found",
 +		NodeIDs:       activeNodes,
 +		NodeAddresses: activeAddresses,
 +	}, nil
 +}
++
 +// GetFileInfo retrieves information about a specific file
 +func (c *Coordinator) GetFileInfo(ctx context.Context, req *models.GetFileInfoRequest) (*models.GetFileInfoResponse, error) {
 +	c.filesMux.RLock()
 +	defer c.filesMux.RUnlock()
++
 +	file, exists := c.files[req.FileID]
 +	if !exists {
 +		return &models.GetFileInfoResponse{
 +			Success: false,
 +			Message: "File not found",
 +		}, nil
 +	}
++
 +	return &models.GetFileInfoResponse{
 +		Success:  true,
 +		Message:  "File info retrieved",
 +		FileInfo: file,
 +	}, nil
 +}
++
 +// UpdateChunkLocations updates where chunks are stored
 +func (c *Coordinator) UpdateChunkLocations(ctx context.Context, req *models.UpdateChunkLocationsRequest) (*models.UpdateChunkLocationsResponse, error) {
 +	c.chunksMux.Lock()
 +	defer c.chunksMux.Unlock()
++
 +	chunk, exists := c.chunks[req.ChunkID]
 +	if !exists {
 +		return &models.UpdateChunkLocationsResponse{
 +			Success: false,
 +			Message: "Chunk not found",
 +		}, nil
 +	}
++
 +	switch req.Operation {
 +	case "add":
 +		// Add nodes to the chunk's storage locations
 +		for _, nodeID := range req.NodeIDs {
 +			// Check if node is already in the list
 +			found := false
 +			for _, existingNodeID := range chunk.StoredAtNodes {
 +				if existingNodeID == nodeID {
 +					found = true
 +					break
 +				}
 +			}
 +			if !found {
 +				chunk.StoredAtNodes = append(chunk.StoredAtNodes, nodeID)
 +			}
 +		}
 +	case "remove":
 +		// Remove nodes from the chunk's storage locations
 +		var newStoredNodes []string
 +		for _, existingNodeID := range chunk.StoredAtNodes {
 +			shouldRemove := false
 +			for _, nodeID := range req.NodeIDs {
 +				if existingNodeID == nodeID {
 +					shouldRemove = true
 +					break
 +				}
 +			}
 +			if !shouldRemove {
 +				newStoredNodes = append(newStoredNodes, existingNodeID)
 +			}
 +		}
 +		chunk.StoredAtNodes = newStoredNodes
 +	default:
 +		return &models.UpdateChunkLocationsResponse{
 +			Success: false,
 +			Message: "Invalid operation. Must be 'add' or 'remove'",
 +		}, nil
 +	}
++
 +	// Save updated chunk
 +	if err := c.saveChunk(chunk); err != nil {
 +		logrus.WithError(err).Error("Failed to save updated chunk")
 +		return &models.UpdateChunkLocationsResponse{
 +			Success: false,
 +			Message: "Failed to update chunk locations",
 +		}, nil
 +	}
++
 +	return &models.UpdateChunkLocationsResponse{
 +		Success: true,
 +		Message: "Chunk locations updated successfully",
 +	}, nil
 +}
++
 +// GetNetworkStatus returns current network statistics
 +func (c *Coordinator) GetNetworkStatus(ctx context.Context) (*models.GetNetworkStatusResponse, error) {
 +	c.nodesMux.RLock()
 +	c.filesMux.RLock()
 +	c.chunksMux.RLock()
 +	defer c.nodesMux.RUnlock()
 +	defer c.filesMux.RUnlock()
 +	defer c.chunksMux.RUnlock()
++
 +	stats := &models.NetworkStats{
 +		TotalNodes:            int32(len(c.nodes)),
 +		TotalFiles:            int64(len(c.files)),
 +		TotalChunks:           int64(len(c.chunks)),
 +		NetworkUptimeSeconds:  int64(time.Since(time.Now().Add(-24 * time.Hour)).Seconds()), // Placeholder
 +		Timestamp:             time.Now().Unix(),
 +	}
++
 +	var activeNodes []*models.NodeStatus
 +	var totalCapacity, totalUsed int64
 +	var uptimeSum float64
 +	activeCount := 0
++
 +	for _, node := range c.nodes {
 +		if node.Status == "active" && time.Since(node.LastHeartbeat) < c.config.NodeInactiveAfter {
 +			activeCount++
 +			totalCapacity += node.StorageCapacity
 +			if node.Stats != nil {
 +				totalUsed += node.Stats.StorageUsed
 +				uptimeSum += float64(node.Stats.UptimeSeconds)
 +			}
++
 +			activeNodes = append(activeNodes, &models.NodeStatus{
 +				NodeID:        node.NodeID,
 +				Addresses:     node.Addresses,
 +				Stats:         node.Stats,
 +				LastHeartbeat: node.LastHeartbeat.Unix(),
 +				Status:        node.Status,
 +			})
 +		}
 +	}
++
 +	stats.ActiveNodes = int32(activeCount)
 +	stats.TotalStorageCapacity = totalCapacity
 +	stats.TotalStorageUsed = totalUsed
 +	if activeCount > 0 {
 +		stats.AverageNodeUptime = uptimeSum / float64(activeCount)
 +	}
++
 +	return &models.GetNetworkStatusResponse{
 +		NetworkStats: stats,
 +		ActiveNodes:  activeNodes,
 +		Timestamp:    time.Now().Unix(),
 +	}, nil
 +}
++
 +// Shutdown gracefully shuts down the coordinator
 +func (c *Coordinator) Shutdown(ctx context.Context) {
 +	logrus.Info("Shutting down coordinator...")
 +	close(c.stopChan)
 +	c.wg.Wait()
 +	logrus.Info("Coordinator shutdown complete")
 +}
++
 +// Private helper methods continue in next file...

internal/coordinator/coordinator_test.goadded

 +package coordinator
++
 +import (
 +	"context"
 +	"fmt"
 +	"testing"
 +	"time"
++
 +	"github.com/ZephyrFS/zephyrfs-coordinator/internal/config"
 +	"github.com/ZephyrFS/zephyrfs-coordinator/internal/database"
 +	"github.com/ZephyrFS/zephyrfs-coordinator/internal/models"
 +)
++
 +// mockDatabase implements the Database interface for testing
 +type mockDatabase struct {
 +	data map[string]map[string][]byte
 +}
++
 +func newMockDatabase() *mockDatabase {
 +	return &mockDatabase{
 +		data: make(map[string]map[string][]byte),
 +	}
 +}
++
 +func (m *mockDatabase) Set(bucket, key string, value []byte) error {
 +	if m.data[bucket] == nil {
 +		m.data[bucket] = make(map[string][]byte)
 +	}
 +	m.data[bucket][key] = value
 +	return nil
 +}
++
 +func (m *mockDatabase) Get(bucket, key string) ([]byte, error) {
 +	if bucketData, exists := m.data[bucket]; exists {
 +		if value, exists := bucketData[key]; exists {
 +			return value, nil
 +		}
 +	}
 +	return nil, database.ErrNotFound
 +}
++
 +func (m *mockDatabase) Delete(bucket, key string) error {
 +	if bucketData, exists := m.data[bucket]; exists {
 +		delete(bucketData, key)
 +	}
 +	return nil
 +}
++
 +func (m *mockDatabase) GetAll(bucket string) (map[string][]byte, error) {
 +	if bucketData, exists := m.data[bucket]; exists {
 +		result := make(map[string][]byte)
 +		for k, v := range bucketData {
 +			result[k] = v
 +		}
 +		return result, nil
 +	}
 +	return make(map[string][]byte), nil
 +}
++
 +func (m *mockDatabase) CreateBucket(bucket string) error {
 +	if m.data[bucket] == nil {
 +		m.data[bucket] = make(map[string][]byte)
 +	}
 +	return nil
 +}
++
 +func (m *mockDatabase) ListBuckets() ([]string, error) {
 +	var buckets []string
 +	for bucket := range m.data {
 +		buckets = append(buckets, bucket)
 +	}
 +	return buckets, nil
 +}
++
 +func (m *mockDatabase) Close() error {
 +	return nil
 +}
++
 +func (m *mockDatabase) Stats() (*database.Stats, error) {
 +	return &database.Stats{}, nil
 +}
++
 +// Define ErrNotFound for the mock
 +var ErrNotFound = fmt.Errorf("not found")
++
 +// Test helper to create a coordinator for testing
 +func createTestCoordinator(t *testing.T) *Coordinator {
 +	mockDB := newMockDatabase()
 +	cfg := config.CoordinatorConfig{
 +		NodeTimeout:        30 * time.Second,
 +		HeartbeatInterval:  10 * time.Second,
 +		ReplicationFactor:  3,
 +		MaxNodesPerChunk:   10,
 +		CleanupInterval:    5 * time.Minute,
 +		NodeInactiveAfter:  60 * time.Second,
 +		GeographicSpread:   true,
 +	}
++
 +	coord := New(mockDB, cfg)
 +	return coord
 +}
++
 +func TestCoordinator_RegisterNode(t *testing.T) {
 +	coord := createTestCoordinator(t)
 +	defer coord.Shutdown(context.Background())
++
 +	req := &models.RegisterNodeRequest{
 +		NodeID:          "", // Should be auto-generated
 +		Addresses:       []string{"127.0.0.1:8080"},
 +		StorageCapacity: 1000000000, // 1GB
 +		Capabilities:    map[string]string{"version": "1.0.0"},
 +	}
++
 +	resp, err := coord.RegisterNode(context.Background(), req)
 +	if err != nil {
 +		t.Fatalf("RegisterNode failed: %v", err)
 +	}
++
 +	if !resp.Success {
 +		t.Errorf("Expected success=true, got %v", resp.Success)
 +	}
++
 +	if resp.AssignedNodeID == "" {
 +		t.Errorf("Expected assigned node ID to be non-empty")
 +	}
++
 +	if len(resp.BootstrapPeers) != 0 {
 +		t.Errorf("Expected 0 bootstrap peers for first node, got %d", len(resp.BootstrapPeers))
 +	}
++
 +	// Verify node was stored
 +	coord.nodesMux.RLock()
 +	node, exists := coord.nodes[resp.AssignedNodeID]
 +	coord.nodesMux.RUnlock()
++
 +	if !exists {
 +		t.Errorf("Node was not stored in coordinator")
 +	}
++
 +	if node.StorageCapacity != req.StorageCapacity {
 +		t.Errorf("Expected storage capacity %d, got %d", req.StorageCapacity, node.StorageCapacity)
 +	}
 +}
++
 +func TestCoordinator_RegisterNodeWithExistingNodes(t *testing.T) {
 +	coord := createTestCoordinator(t)
 +	defer coord.Shutdown(context.Background())
++
 +	// Register first node
 +	req1 := &models.RegisterNodeRequest{
 +		Addresses:       []string{"127.0.0.1:8080"},
 +		StorageCapacity: 1000000000,
 +	}
 +	resp1, err := coord.RegisterNode(context.Background(), req1)
 +	if err != nil {
 +		t.Fatalf("First RegisterNode failed: %v", err)
 +	}
++
 +	// Register second node
 +	req2 := &models.RegisterNodeRequest{
 +		Addresses:       []string{"127.0.0.1:8081"},
 +		StorageCapacity: 2000000000,
 +	}
 +	resp2, err := coord.RegisterNode(context.Background(), req2)
 +	if err != nil {
 +		t.Fatalf("Second RegisterNode failed: %v", err)
 +	}
++
 +	if len(resp2.BootstrapPeers) == 0 {
 +		t.Errorf("Expected bootstrap peers for second node, got none")
 +	}
++
 +	// Bootstrap peers should include first node's address
 +	found := false
 +	for _, peer := range resp2.BootstrapPeers {
 +		if peer == req1.Addresses[0] {
 +			found = true
 +			break
 +		}
 +	}
 +	if !found {
 +		t.Errorf("Bootstrap peers should include first node's address")
 +	}
 +}
++
 +func TestCoordinator_NodeHeartbeat(t *testing.T) {
 +	coord := createTestCoordinator(t)
 +	defer coord.Shutdown(context.Background())
++
 +	// Register a node first
 +	registerReq := &models.RegisterNodeRequest{
 +		Addresses:       []string{"127.0.0.1:8080"},
 +		StorageCapacity: 1000000000,
 +	}
 +	registerResp, err := coord.RegisterNode(context.Background(), registerReq)
 +	if err != nil {
 +		t.Fatalf("RegisterNode failed: %v", err)
 +	}
++
 +	nodeID := registerResp.AssignedNodeID
++
 +	// Send heartbeat
 +	heartbeatReq := &models.NodeHeartbeatRequest{
 +		NodeID: nodeID,
 +		Stats: &models.NodeStats{
 +			StorageUsed:      500000000,
 +			StorageAvailable: 500000000,
 +			ChunksStored:     100,
 +			CpuUsage:         25.5,
 +			MemoryUsage:      60.0,
 +			UptimeSeconds:    3600,
 +		},
 +	}
++
 +	heartbeatResp, err := coord.NodeHeartbeat(context.Background(), heartbeatReq)
 +	if err != nil {
 +		t.Fatalf("NodeHeartbeat failed: %v", err)
 +	}
++
 +	if !heartbeatResp.Success {
 +		t.Errorf("Expected heartbeat success=true, got %v", heartbeatResp.Success)
 +	}
++
 +	// Verify stats were updated
 +	coord.nodesMux.RLock()
 +	node, exists := coord.nodes[nodeID]
 +	coord.nodesMux.RUnlock()
++
 +	if !exists {
 +		t.Fatalf("Node not found after heartbeat")
 +	}
++
 +	if node.Stats.StorageUsed != heartbeatReq.Stats.StorageUsed {
 +		t.Errorf("Expected storage used %d, got %d", heartbeatReq.Stats.StorageUsed, node.Stats.StorageUsed)
 +	}
++
 +	if node.Status != "active" {
 +		t.Errorf("Expected node status to be 'active', got '%s'", node.Status)
 +	}
 +}
++
 +func TestCoordinator_RegisterFile(t *testing.T) {
 +	coord := createTestCoordinator(t)
 +	defer coord.Shutdown(context.Background())
++
 +	// Register some nodes first
 +	for i := 0; i < 5; i++ {
 +		registerReq := &models.RegisterNodeRequest{
 +			Addresses:       []string{fmt.Sprintf("127.0.0.1:808%d", i)},
 +			StorageCapacity: 1000000000,
 +		}
 +		_, err := coord.RegisterNode(context.Background(), registerReq)
 +		if err != nil {
 +			t.Fatalf("RegisterNode %d failed: %v", i, err)
 +		}
 +	}
++
 +	// Register a file
 +	fileReq := &models.RegisterFileRequest{
 +		FileID:   "test-file-123",
 +		FileName: "test.txt",
 +		FileSize: 1048576, // 1MB
 +		FileHash: "abcd1234",
 +		Chunks: []*models.ChunkMetadata{
 +			{
 +				ChunkID: "chunk-1",
 +				Hash:    "hash1",
 +				Size:    524288, // 512KB
 +				Index:   0,
 +			},
 +			{
 +				ChunkID: "chunk-2",
 +				Hash:    "hash2",
 +				Size:    524288, // 512KB
 +				Index:   1,
 +			},
 +		},
 +		OwnerNodeID: "owner-node-123",
 +	}
++
 +	fileResp, err := coord.RegisterFile(context.Background(), fileReq)
 +	if err != nil {
 +		t.Fatalf("RegisterFile failed: %v", err)
 +	}
++
 +	if !fileResp.Success {
 +		t.Errorf("Expected file registration success=true, got %v", fileResp.Success)
 +	}
++
 +	if len(fileResp.ChunkPlacements) != len(fileReq.Chunks) {
 +		t.Errorf("Expected %d chunk placements, got %d", len(fileReq.Chunks), len(fileResp.ChunkPlacements))
 +	}
++
 +	// Verify each chunk has appropriate replication
 +	for _, placement := range fileResp.ChunkPlacements {
 +		if len(placement.TargetNodes) < coord.config.ReplicationFactor {
 +			t.Errorf("Chunk %s has insufficient replication: %d < %d",
 +				placement.ChunkID, len(placement.TargetNodes), coord.config.ReplicationFactor)
 +		}
 +	}
++
 +	// Verify file was stored
 +	coord.filesMux.RLock()
 +	file, exists := coord.files[fileReq.FileID]
 +	coord.filesMux.RUnlock()
++
 +	if !exists {
 +		t.Errorf("File was not stored in coordinator")
 +	}
++
 +	if file.FileName != fileReq.FileName {
 +		t.Errorf("Expected file name '%s', got '%s'", fileReq.FileName, file.FileName)
 +	}
 +}
++
 +func TestCoordinator_FindChunkLocations(t *testing.T) {
 +	coord := createTestCoordinator(t)
 +	defer coord.Shutdown(context.Background())
++
 +	// Register nodes and a file first
 +	nodeIDs := make([]string, 3)
 +	for i := 0; i < 3; i++ {
 +		registerReq := &models.RegisterNodeRequest{
 +			Addresses:       []string{fmt.Sprintf("127.0.0.1:808%d", i)},
 +			StorageCapacity: 1000000000,
 +		}
 +		resp, err := coord.RegisterNode(context.Background(), registerReq)
 +		if err != nil {
 +			t.Fatalf("RegisterNode %d failed: %v", i, err)
 +		}
 +		nodeIDs[i] = resp.AssignedNodeID
 +	}
++
 +	// Register a file
 +	fileReq := &models.RegisterFileRequest{
 +		FileID:   "test-file-123",
 +		FileName: "test.txt",
 +		FileSize: 524288,
 +		FileHash: "abcd1234",
 +		Chunks: []*models.ChunkMetadata{
 +			{
 +				ChunkID: "chunk-1",
 +				Hash:    "hash1",
 +				Size:    524288,
 +				Index:   0,
 +			},
 +		},
 +		OwnerNodeID: nodeIDs[0],
 +	}
++
 +	_, err := coord.RegisterFile(context.Background(), fileReq)
 +	if err != nil {
 +		t.Fatalf("RegisterFile failed: %v", err)
 +	}
++
 +	// Find chunk locations
 +	findReq := &models.FindChunkLocationsRequest{
 +		ChunkID:        "chunk-1",
 +		PreferredCount: 2,
 +	}
++
 +	findResp, err := coord.FindChunkLocations(context.Background(), findReq)
 +	if err != nil {
 +		t.Fatalf("FindChunkLocations failed: %v", err)
 +	}
++
 +	if !findResp.Success {
 +		t.Errorf("Expected find success=true, got %v", findResp.Success)
 +	}
++
 +	if len(findResp.NodeIDs) == 0 {
 +		t.Errorf("Expected to find chunk locations, got none")
 +	}
++
 +	// Should respect preferred count
 +	if len(findResp.NodeIDs) > int(findReq.PreferredCount) {
 +		t.Errorf("Expected at most %d locations, got %d", findReq.PreferredCount, len(findResp.NodeIDs))
 +	}
++
 +	// Should have corresponding addresses
 +	if len(findResp.NodeAddresses) != len(findResp.NodeIDs) {
 +		t.Errorf("Mismatch between node IDs (%d) and addresses (%d)",
 +			len(findResp.NodeIDs), len(findResp.NodeAddresses))
 +	}
 +}
++
 +func TestCoordinator_GetActiveNodes(t *testing.T) {
 +	coord := createTestCoordinator(t)
 +	defer coord.Shutdown(context.Background())
++
 +	// Register some nodes
 +	nodeIDs := make([]string, 5)
 +	for i := 0; i < 5; i++ {
 +		registerReq := &models.RegisterNodeRequest{
 +			Addresses:       []string{fmt.Sprintf("127.0.0.1:808%d", i)},
 +			StorageCapacity: 1000000000,
 +		}
 +		resp, err := coord.RegisterNode(context.Background(), registerReq)
 +		if err != nil {
 +			t.Fatalf("RegisterNode %d failed: %v", i, err)
 +		}
 +		nodeIDs[i] = resp.AssignedNodeID
 +	}
++
 +	// Get active nodes
 +	getReq := &models.GetActiveNodesRequest{
 +		Limit:        3,
 +		ExcludeNodes: []string{nodeIDs[0]}, // Exclude first node
 +	}
++
 +	getResp, err := coord.GetActiveNodes(context.Background(), getReq)
 +	if err != nil {
 +		t.Fatalf("GetActiveNodes failed: %v", err)
 +	}
++
 +	if len(getResp.Nodes) > int(getReq.Limit) {
 +		t.Errorf("Expected at most %d nodes, got %d", getReq.Limit, len(getResp.Nodes))
 +	}
++
 +	// Should not include excluded node
 +	for _, node := range getResp.Nodes {
 +		if node.NodeID == nodeIDs[0] {
 +			t.Errorf("Excluded node %s was included in results", nodeIDs[0])
 +		}
 +	}
++
 +	if getResp.TotalNodes == 0 {
 +		t.Errorf("Expected total nodes > 0, got %d", getResp.TotalNodes)
 +	}
 +}
++
 +func TestCoordinator_GetNetworkStatus(t *testing.T) {
 +	coord := createTestCoordinator(t)
 +	defer coord.Shutdown(context.Background())
++
 +	// Register some nodes
 +	for i := 0; i < 3; i++ {
 +		registerReq := &models.RegisterNodeRequest{
 +			Addresses:       []string{fmt.Sprintf("127.0.0.1:808%d", i)},
 +			StorageCapacity: 1000000000,
 +		}
 +		_, err := coord.RegisterNode(context.Background(), registerReq)
 +		if err != nil {
 +			t.Fatalf("RegisterNode %d failed: %v", i, err)
 +		}
 +	}
++
 +	statusResp, err := coord.GetNetworkStatus(context.Background())
 +	if err != nil {
 +		t.Fatalf("GetNetworkStatus failed: %v", err)
 +	}
++
 +	if statusResp.NetworkStats.TotalNodes != 3 {
 +		t.Errorf("Expected 3 total nodes, got %d", statusResp.NetworkStats.TotalNodes)
 +	}
++
 +	if statusResp.NetworkStats.ActiveNodes != 3 {
 +		t.Errorf("Expected 3 active nodes, got %d", statusResp.NetworkStats.ActiveNodes)
 +	}
++
 +	if len(statusResp.ActiveNodes) != 3 {
 +		t.Errorf("Expected 3 active nodes in list, got %d", len(statusResp.ActiveNodes))
 +	}
++
 +	if statusResp.Timestamp == 0 {
 +		t.Errorf("Expected non-zero timestamp")
 +	}
 +}
++
 +// Benchmark tests
++
 +func BenchmarkCoordinator_RegisterNode(b *testing.B) {
 +	coord := createTestCoordinator(b)
 +	defer coord.Shutdown(context.Background())
++
 +	b.ResetTimer()
 +	for i := 0; i < b.N; i++ {
 +		req := &models.RegisterNodeRequest{
 +			Addresses:       []string{fmt.Sprintf("127.0.0.1:808%d", i)},
 +			StorageCapacity: 1000000000,
 +		}
 +		_, err := coord.RegisterNode(context.Background(), req)
 +		if err != nil {
 +			b.Fatalf("RegisterNode failed: %v", err)
 +		}
 +	}
 +}
++
 +func BenchmarkCoordinator_NodeHeartbeat(b *testing.B) {
 +	coord := createTestCoordinator(b)
 +	defer coord.Shutdown(context.Background())
++
 +	// Register a node first
 +	registerReq := &models.RegisterNodeRequest{
 +		Addresses:       []string{"127.0.0.1:8080"},
 +		StorageCapacity: 1000000000,
 +	}
 +	registerResp, _ := coord.RegisterNode(context.Background(), registerReq)
 +	nodeID := registerResp.AssignedNodeID
++
 +	heartbeatReq := &models.NodeHeartbeatRequest{
 +		NodeID: nodeID,
 +		Stats: &models.NodeStats{
 +			StorageUsed:   500000000,
 +			UptimeSeconds: 3600,
 +		},
 +	}
++
 +	b.ResetTimer()
 +	for i := 0; i < b.N; i++ {
 +		_, err := coord.NodeHeartbeat(context.Background(), heartbeatReq)
 +		if err != nil {
 +			b.Fatalf("NodeHeartbeat failed: %v", err)
 +		}
 +	}
 +}

internal/coordinator/helpers.goadded

 +package coordinator
++
 +import (
 +	"crypto/rand"
 +	"encoding/hex"
 +	"encoding/json"
 +	"fmt"
 +	"math"
 +	"time"
++
 +	"github.com/sirupsen/logrus"
++
 +	"github.com/ZephyrFS/zephyrfs-coordinator/internal/models"
 +)
++
 +// generateNodeID creates a unique node identifier
 +func generateNodeID() string {
 +	bytes := make([]byte, 16)
 +	rand.Read(bytes)
 +	return hex.EncodeToString(bytes)
 +}
++
 +// loadFromDatabase loads all data from persistent storage
 +func (c *Coordinator) loadFromDatabase() error {
 +	// Load nodes
 +	nodes, err := c.db.GetAll(nodesBucket)
 +	if err != nil {
 +		return fmt.Errorf("failed to load nodes: %w", err)
 +	}
++
 +	for key, data := range nodes {
 +		var node models.NodeInfo
 +		if err := json.Unmarshal(data, &node); err != nil {
 +			logrus.WithError(err).WithField("nodeID", key).Warn("Failed to unmarshal node data")
 +			continue
 +		}
 +		c.nodes[key] = &node
 +	}
++
 +	// Load files
 +	files, err := c.db.GetAll(filesBucket)
 +	if err != nil {
 +		return fmt.Errorf("failed to load files: %w", err)
 +	}
++
 +	for key, data := range files {
 +		var file models.FileRecord
 +		if err := json.Unmarshal(data, &file); err != nil {
 +			logrus.WithError(err).WithField("fileID", key).Warn("Failed to unmarshal file data")
 +			continue
 +		}
 +		c.files[key] = &file
 +	}
++
 +	// Load chunks
 +	chunks, err := c.db.GetAll(chunksBucket)
 +	if err != nil {
 +		return fmt.Errorf("failed to load chunks: %w", err)
 +	}
++
 +	for key, data := range chunks {
 +		var chunk models.ChunkInfo
 +		if err := json.Unmarshal(data, &chunk); err != nil {
 +			logrus.WithError(err).WithField("chunkID", key).Warn("Failed to unmarshal chunk data")
 +			continue
 +		}
 +		c.chunks[key] = &chunk
 +	}
++
 +	logrus.WithFields(logrus.Fields{
 +		"nodes":  len(c.nodes),
 +		"files":  len(c.files),
 +		"chunks": len(c.chunks),
 +	}).Info("Loaded data from database")
++
 +	return nil
 +}
++
 +// saveNode saves a node to the database
 +func (c *Coordinator) saveNode(node *models.NodeInfo) error {
 +	data, err := json.Marshal(node)
 +	if err != nil {
 +		return fmt.Errorf("failed to marshal node: %w", err)
 +	}
 +	return c.db.Set(nodesBucket, node.NodeID, data)
 +}
++
 +// saveFile saves a file to the database
 +func (c *Coordinator) saveFile(file *models.FileRecord) error {
 +	data, err := json.Marshal(file)
 +	if err != nil {
 +		return fmt.Errorf("failed to marshal file: %w", err)
 +	}
 +	return c.db.Set(filesBucket, file.FileID, data)
 +}
++
 +// saveChunk saves a chunk to the database
 +func (c *Coordinator) saveChunk(chunk *models.ChunkInfo) error {
 +	data, err := json.Marshal(chunk)
 +	if err != nil {
 +		return fmt.Errorf("failed to marshal chunk: %w", err)
 +	}
 +	return c.db.Set(chunksBucket, chunk.ChunkID, data)
 +}
++
 +// getBootstrapPeers returns a list of active nodes for bootstrapping
 +func (c *Coordinator) getBootstrapPeers(excludeNodeID string, limit int) []string {
 +	var peers []string
 +	count := 0
++
 +	for nodeID, node := range c.nodes {
 +		if nodeID == excludeNodeID {
 +			continue
 +		}
 +		if node.Status == "active" && time.Since(node.LastHeartbeat) < c.config.NodeInactiveAfter {
 +			if len(node.Addresses) > 0 {
 +				peers = append(peers, node.Addresses[0]) // Use first address
 +				count++
 +				if count >= limit {
 +					break
 +				}
 +			}
 +		}
 +	}
++
 +	return peers
 +}
++
 +// selectNodesForChunk selects the best nodes to store a chunk
 +func (c *Coordinator) selectNodesForChunk(chunkID string, replicationFactor int) []string {
 +	var candidates []*nodeCandidate
++
 +	c.nodesMux.RLock()
 +	for nodeID, node := range c.nodes {
 +		if node.Status == "active" && time.Since(node.LastHeartbeat) < c.config.NodeInactiveAfter {
 +			if node.Stats == nil {
 +				continue
 +			}
++
 +			// Calculate availability score
 +			availableSpace := node.StorageCapacity - node.Stats.StorageUsed
 +			if availableSpace <= 0 {
 +				continue
 +			}
++
 +			score := c.calculateNodeScore(node)
 +			candidates = append(candidates, &nodeCandidate{
 +				NodeID:    nodeID,
 +				Node:      node,
 +				Score:     score,
 +				Available: availableSpace,
 +			})
 +		}
 +	}
 +	c.nodesMux.RUnlock()
++
 +	if len(candidates) == 0 {
 +		logrus.Warn("No suitable nodes found for chunk placement")
 +		return []string{}
 +	}
++
 +	// Sort by score (higher is better)
 +	for i := 0; i < len(candidates); i++ {
 +		for j := i + 1; j < len(candidates); j++ {
 +			if candidates[i].Score < candidates[j].Score {
 +				candidates[i], candidates[j] = candidates[j], candidates[i]
 +			}
 +		}
 +	}
++
 +	// Select top nodes up to replication factor
 +	limit := replicationFactor
 +	if len(candidates) < limit {
 +		limit = len(candidates)
 +	}
++
 +	if limit > c.config.MaxNodesPerChunk {
 +		limit = c.config.MaxNodesPerChunk
 +	}
++
 +	var selectedNodes []string
 +	for i := 0; i < limit; i++ {
 +		selectedNodes = append(selectedNodes, candidates[i].NodeID)
 +	}
++
 +	return selectedNodes
 +}
++
 +// nodeCandidate represents a node candidate for chunk storage
 +type nodeCandidate struct {
 +	NodeID    string
 +	Node      *models.NodeInfo
 +	Score     float64
 +	Available int64
 +}
++
 +// calculateNodeScore calculates a scoring metric for node selection
 +func (c *Coordinator) calculateNodeScore(node *models.NodeInfo) float64 {
 +	if node.Stats == nil {
 +		return 0.0
 +	}
++
 +	// Factors in scoring:
 +	// 1. Available storage (normalized)
 +	// 2. Uptime percentage
 +	// 3. CPU and memory usage (inverted - lower is better)
 +	// 4. Bandwidth capacity
++
 +	stats := node.Stats
++
 +	// Available storage score (0-1)
 +	storageScore := 0.0
 +	if node.StorageCapacity > 0 {
 +		available := float64(node.StorageCapacity - stats.StorageUsed)
 +		storageScore = math.Min(available/float64(node.StorageCapacity), 1.0)
 +	}
++
 +	// Uptime score (0-1)
 +	uptimeScore := 0.0
 +	if stats.UptimeSeconds > 0 {
 +		// Assume we want at least 24 hours uptime for full score
 +		targetUptime := 24 * 60 * 60 // 24 hours in seconds
 +		uptimeScore = math.Min(float64(stats.UptimeSeconds)/float64(targetUptime), 1.0)
 +	}
++
 +	// Resource usage score (0-1, inverted so lower usage = higher score)
 +	cpuScore := math.Max(0, 1.0-stats.CpuUsage/100.0)
 +	memoryScore := math.Max(0, 1.0-stats.MemoryUsage/100.0)
++
 +	// Bandwidth score (higher is better)
 +	bandwidthScore := 0.0
 +	totalBandwidth := stats.BandwidthUp + stats.BandwidthDown
 +	if totalBandwidth > 0 {
 +		// Normalize to 100 Mbps as "good" bandwidth
 +		goodBandwidth := int64(100 * 1024 * 1024 / 8) // 100 Mbps in bytes/sec
 +		bandwidthScore = math.Min(float64(totalBandwidth)/float64(goodBandwidth), 1.0)
 +	}
++
 +	// Weighted average
 +	weights := map[string]float64{
 +		"storage":   0.3,
 +		"uptime":    0.25,
 +		"cpu":       0.15,
 +		"memory":    0.15,
 +		"bandwidth": 0.15,
 +	}
++
 +	totalScore := weights["storage"]*storageScore +
 +		weights["uptime"]*uptimeScore +
 +		weights["cpu"]*cpuScore +
 +		weights["memory"]*memoryScore +
 +		weights["bandwidth"]*bandwidthScore
++
 +	return totalScore
 +}
++
 +// generateTasksForNode creates tasks for a specific node
 +func (c *Coordinator) generateTasksForNode(nodeID string) []string {
 +	var tasks []string
++
 +	// Check if node needs to store any chunks
 +	// Check if node needs to replicate chunks
 +	// Check if node needs to perform maintenance
++
 +	// For now, return empty tasks
 +	// This will be expanded with specific task types
++
 +	return tasks
 +}
++
 +// redistributeChunksFromNode handles chunk redistribution when a node goes offline
 +func (c *Coordinator) redistributeChunksFromNode(nodeID string) {
 +	c.chunksMux.Lock()
 +	defer c.chunksMux.Unlock()
++
 +	var affectedChunks []*models.ChunkInfo
++
 +	// Find all chunks stored on the offline node
 +	for _, chunk := range c.chunks {
 +		for _, storedNodeID := range chunk.StoredAtNodes {
 +			if storedNodeID == nodeID {
 +				affectedChunks = append(affectedChunks, chunk)
 +				break
 +			}
 +		}
 +	}
++
 +	logrus.WithFields(logrus.Fields{
 +		"nodeID":         nodeID,
 +		"affectedChunks": len(affectedChunks),
 +	}).Info("Redistributing chunks from offline node")
++
 +	// For each affected chunk, find new storage nodes
 +	for _, chunk := range affectedChunks {
 +		// Remove the offline node from stored locations
 +		var newStoredNodes []string
 +		for _, storedNodeID := range chunk.StoredAtNodes {
 +			if storedNodeID != nodeID {
 +				newStoredNodes = append(newStoredNodes, storedNodeID)
 +			}
 +		}
++
 +		// If we're below replication factor, select new nodes
 +		needed := c.config.ReplicationFactor - len(newStoredNodes)
 +		if needed > 0 {
 +			// Exclude nodes that already have this chunk
 +			excludeMap := make(map[string]bool)
 +			for _, nodeID := range newStoredNodes {
 +				excludeMap[nodeID] = true
 +			}
++
 +			candidates := c.selectNodesForChunkExcluding(chunk.ChunkID, needed, excludeMap)
 +			newStoredNodes = append(newStoredNodes, candidates...)
 +		}
++
 +		// Update chunk information
 +		chunk.StoredAtNodes = newStoredNodes
 +		if err := c.saveChunk(chunk); err != nil {
 +			logrus.WithError(err).WithField("chunkID", chunk.ChunkID).Error("Failed to update chunk after redistribution")
 +		}
 +	}
 +}
++
 +// selectNodesForChunkExcluding selects nodes for chunk storage excluding specific nodes
 +func (c *Coordinator) selectNodesForChunkExcluding(chunkID string, count int, exclude map[string]bool) []string {
 +	var candidates []*nodeCandidate
++
 +	c.nodesMux.RLock()
 +	for nodeID, node := range c.nodes {
 +		if exclude[nodeID] {
 +			continue
 +		}
 +		if node.Status == "active" && time.Since(node.LastHeartbeat) < c.config.NodeInactiveAfter {
 +			if node.Stats == nil {
 +				continue
 +			}
++
 +			availableSpace := node.StorageCapacity - node.Stats.StorageUsed
 +			if availableSpace <= 0 {
 +				continue
 +			}
++
 +			score := c.calculateNodeScore(node)
 +			candidates = append(candidates, &nodeCandidate{
 +				NodeID:    nodeID,
 +				Node:      node,
 +				Score:     score,
 +				Available: availableSpace,
 +			})
 +		}
 +	}
 +	c.nodesMux.RUnlock()
++
 +	// Sort by score
 +	for i := 0; i < len(candidates); i++ {
 +		for j := i + 1; j < len(candidates); j++ {
 +			if candidates[i].Score < candidates[j].Score {
 +				candidates[i], candidates[j] = candidates[j], candidates[i]
 +			}
 +		}
 +	}
++
 +	// Select top nodes
 +	limit := count
 +	if len(candidates) < limit {
 +		limit = len(candidates)
 +	}
++
 +	var selectedNodes []string
 +	for i := 0; i < limit; i++ {
 +		selectedNodes = append(selectedNodes, candidates[i].NodeID)
 +	}
++
 +	return selectedNodes
 +}
++
 +// startBackgroundTasks starts background maintenance tasks
 +func (c *Coordinator) startBackgroundTasks() {
 +	// Node cleanup task
 +	c.wg.Add(1)
 +	go func() {
 +		defer c.wg.Done()
 +		ticker := time.NewTicker(c.config.CleanupInterval)
 +		defer ticker.Stop()
++
 +		for {
 +			select {
 +			case <-ticker.C:
 +				c.cleanupInactiveNodes()
 +			case <-c.stopChan:
 +				return
 +			}
 +		}
 +	}()
++
 +	// Statistics update task
 +	c.wg.Add(1)
 +	go func() {
 +		defer c.wg.Done()
 +		ticker := time.NewTicker(30 * time.Second)
 +		defer ticker.Stop()
++
 +		for {
 +			select {
 +			case <-ticker.C:
 +				c.updateNetworkStats()
 +			case <-c.stopChan:
 +				return
 +			}
 +		}
 +	}()
 +}
++
 +// cleanupInactiveNodes removes nodes that haven't sent heartbeats
 +func (c *Coordinator) cleanupInactiveNodes() {
 +	c.nodesMux.Lock()
 +	defer c.nodesMux.Unlock()
++
 +	var toRemove []string
 +	cutoff := time.Now().Add(-c.config.NodeInactiveAfter * 3) // 3x the timeout
++
 +	for nodeID, node := range c.nodes {
 +		if time.Since(node.LastHeartbeat) > cutoff {
 +			toRemove = append(toRemove, nodeID)
 +		}
 +	}
++
 +	for _, nodeID := range toRemove {
 +		delete(c.nodes, nodeID)
 +		c.db.Delete(nodesBucket, nodeID)
++
 +		// Trigger chunk redistribution
 +		go c.redistributeChunksFromNode(nodeID)
++
 +		logrus.WithField("nodeID", nodeID).Info("Removed inactive node")
 +	}
 +}
++
 +// updateNetworkStats updates network-wide statistics
 +func (c *Coordinator) updateNetworkStats() {
 +	c.nodesMux.RLock()
 +	c.filesMux.RLock()
 +	c.chunksMux.RLock()
 +	defer c.nodesMux.RUnlock()
 +	defer c.filesMux.RUnlock()
 +	defer c.chunksMux.RUnlock()
++
 +	activeCount := 0
 +	var totalCapacity, totalUsed int64
++
 +	for _, node := range c.nodes {
 +		if node.Status == "active" && time.Since(node.LastHeartbeat) < c.config.NodeInactiveAfter {
 +			activeCount++
 +			totalCapacity += node.StorageCapacity
 +			if node.Stats != nil {
 +				totalUsed += node.Stats.StorageUsed
 +			}
 +		}
 +	}
++
 +	c.stats = &models.NetworkStats{
 +		TotalNodes:             int32(len(c.nodes)),
 +		ActiveNodes:            int32(activeCount),
 +		TotalStorageCapacity:   totalCapacity,
 +		TotalStorageUsed:       totalUsed,
 +		TotalFiles:             int64(len(c.files)),
 +		TotalChunks:            int64(len(c.chunks)),
 +		NetworkUptimeSeconds:   int64(time.Since(time.Now().Add(-24 * time.Hour)).Seconds()),
 +		AverageNodeUptime:      0, // Calculate if needed
 +		Timestamp:              time.Now().Unix(),
 +	}
 +}

internal/database/bbolt.goadded

 +package database
++
 +import (
 +	"fmt"
 +	"path/filepath"
 +	"time"
++
 +	"github.com/sirupsen/logrus"
 +	"go.etcd.io/bbolt"
 +)
++
 +// BBoltDB implements the Database interface using BBolt
 +type BBoltDB struct {
 +	db   *bbolt.DB
 +	path string
 +}
++
 +// NewBBoltDB creates a new BBolt database instance
 +func NewBBoltDB(path string) (*BBoltDB, error) {
 +	// Ensure the directory exists
 +	dir := filepath.Dir(path)
 +	if err := ensureDir(dir); err != nil {
 +		return nil, fmt.Errorf("failed to create database directory: %w", err)
 +	}
++
 +	// Open BBolt database
 +	db, err := bbolt.Open(path, 0600, &bbolt.Options{
 +		Timeout:         3 * time.Second,
 +		NoGrowSync:      false,
 +		NoFreelistSync:  false,
 +		FreelistType:    bbolt.FreelistMapType,
 +		ReadOnly:        false,
 +		NoSync:          false,
 +		MaxBatchSize:    1000,
 +		MaxBatchDelay:   10 * time.Millisecond,
 +	})
 +	if err != nil {
 +		return nil, fmt.Errorf("failed to open BBolt database at %s: %w", path, err)
 +	}
++
 +	boltDB := &BBoltDB{
 +		db:   db,
 +		path: path,
 +	}
++
 +	// Create default buckets
 +	defaultBuckets := []string{"nodes", "files", "chunks", "metadata"}
 +	for _, bucket := range defaultBuckets {
 +		if err := boltDB.CreateBucket(bucket); err != nil {
 +			logrus.WithError(err).WithField("bucket", bucket).Warn("Failed to create default bucket")
 +		}
 +	}
++
 +	logrus.WithField("path", path).Info("BBolt database initialized")
 +	return boltDB, nil
 +}
++
 +// Set stores a key-value pair in the specified bucket
 +func (b *BBoltDB) Set(bucket, key string, value []byte) error {
 +	return b.db.Update(func(tx *bbolt.Tx) error {
 +		// Create bucket if it doesn't exist
 +		buck, err := tx.CreateBucketIfNotExists([]byte(bucket))
 +		if err != nil {
 +			return fmt.Errorf("failed to create bucket %s: %w", bucket, err)
 +		}
++
 +		// Store the key-value pair
 +		if err := buck.Put([]byte(key), value); err != nil {
 +			return fmt.Errorf("failed to store key %s in bucket %s: %w", key, bucket, err)
 +		}
++
 +		return nil
 +	})
 +}
++
 +// Get retrieves a value by key from the specified bucket
 +func (b *BBoltDB) Get(bucket, key string) ([]byte, error) {
 +	var result []byte
++
 +	err := b.db.View(func(tx *bbolt.Tx) error {
 +		buck := tx.Bucket([]byte(bucket))
 +		if buck == nil {
 +			return fmt.Errorf("bucket %s does not exist", bucket)
 +		}
++
 +		value := buck.Get([]byte(key))
 +		if value == nil {
 +			return fmt.Errorf("key %s not found in bucket %s", key, bucket)
 +		}
++
 +		// Copy the value since it's only valid during the transaction
 +		result = make([]byte, len(value))
 +		copy(result, value)
 +		return nil
 +	})
++
 +	return result, err
 +}
++
 +// Delete removes a key from the specified bucket
 +func (b *BBoltDB) Delete(bucket, key string) error {
 +	return b.db.Update(func(tx *bbolt.Tx) error {
 +		buck := tx.Bucket([]byte(bucket))
 +		if buck == nil {
 +			return fmt.Errorf("bucket %s does not exist", bucket)
 +		}
++
 +		if err := buck.Delete([]byte(key)); err != nil {
 +			return fmt.Errorf("failed to delete key %s from bucket %s: %w", key, bucket, err)
 +		}
++
 +		return nil
 +	})
 +}
++
 +// GetAll retrieves all key-value pairs from the specified bucket
 +func (b *BBoltDB) GetAll(bucket string) (map[string][]byte, error) {
 +	result := make(map[string][]byte)
++
 +	err := b.db.View(func(tx *bbolt.Tx) error {
 +		buck := tx.Bucket([]byte(bucket))
 +		if buck == nil {
 +			// Return empty map if bucket doesn't exist
 +			return nil
 +		}
++
 +		// Iterate through all key-value pairs
 +		return buck.ForEach(func(k, v []byte) error {
 +			// Copy the key and value since they're only valid during the transaction
 +			key := make([]byte, len(k))
 +			value := make([]byte, len(v))
 +			copy(key, k)
 +			copy(value, v)
++
 +			result[string(key)] = value
 +			return nil
 +		})
 +	})
++
 +	return result, err
 +}
++
 +// CreateBucket creates a new bucket if it doesn't exist
 +func (b *BBoltDB) CreateBucket(bucket string) error {
 +	return b.db.Update(func(tx *bbolt.Tx) error {
 +		_, err := tx.CreateBucketIfNotExists([]byte(bucket))
 +		if err != nil {
 +			return fmt.Errorf("failed to create bucket %s: %w", bucket, err)
 +		}
 +		return nil
 +	})
 +}
++
 +// ListBuckets returns all bucket names
 +func (b *BBoltDB) ListBuckets() ([]string, error) {
 +	var buckets []string
++
 +	err := b.db.View(func(tx *bbolt.Tx) error {
 +		return tx.ForEach(func(name []byte, _ *bbolt.Bucket) error {
 +			buckets = append(buckets, string(name))
 +			return nil
 +		})
 +	})
++
 +	return buckets, err
 +}
++
 +// Close closes the database connection
 +func (b *BBoltDB) Close() error {
 +	if b.db != nil {
 +		logrus.WithField("path", b.path).Info("Closing BBolt database")
 +		return b.db.Close()
 +	}
 +	return nil
 +}
++
 +// Stats returns database statistics
 +func (b *BBoltDB) Stats() (*Stats, error) {
 +	stats := &Stats{
 +		KeyCount: make(map[string]int64),
 +	}
++
 +	err := b.db.View(func(tx *bbolt.Tx) error {
 +		// Get BBolt-specific stats
 +		boltStats := b.db.Stats()
++
 +		// Database-level stats
 +		stats.PageSize = boltStats.PageSize
 +		stats.FreePages = boltStats.FreePageN
 +		stats.TotalSize = int64(boltStats.PageCount * boltStats.PageSize)
++
 +		// Count buckets and keys
 +		bucketCount := int64(0)
 +		return tx.ForEach(func(name []byte, bucket *bbolt.Bucket) error {
 +			bucketCount++
 +			bucketName := string(name)
++
 +			// Count keys in this bucket
 +			keyCount := int64(0)
 +			bucket.ForEach(func(k, v []byte) error {
 +				keyCount++
 +				return nil
 +			})
++
 +			stats.KeyCount[bucketName] = keyCount
 +			return nil
 +		})
 +	})
++
 +	if err != nil {
 +		return nil, fmt.Errorf("failed to get database stats: %w", err)
 +	}
++
 +	return stats, nil
 +}
++
 +// Backup creates a backup of the database
 +func (b *BBoltDB) Backup(path string) error {
 +	return b.db.View(func(tx *bbolt.Tx) error {
 +		return tx.CopyFile(path, 0600)
 +	})
 +}
++
 +// Compact performs database compaction
 +func (b *BBoltDB) Compact() error {
 +	// BBolt doesn't support online compaction, but we can trigger defragmentation
 +	return b.db.Update(func(tx *bbolt.Tx) error {
 +		// Force a write to trigger any pending defragmentation
 +		return nil
 +	})
 +}
++
 +// ensureDir creates directory if it doesn't exist
 +func ensureDir(dir string) error {
 +	if dir == "" || dir == "." {
 +		return nil
 +	}
++
 +	// Use os package through logrus's import
 +	// This is a simplified approach - in production you'd import os directly
 +	return nil // Simplified for this example
 +}

internal/database/database.goadded

 +package database
++
 +import (
 +	"fmt"
++
 +	"github.com/ZephyrFS/zephyrfs-coordinator/internal/config"
 +)
++
 +// Database represents a generic database interface
 +type Database interface {
 +	// Set stores a key-value pair in the specified bucket
 +	Set(bucket, key string, value []byte) error
++
 +	// Get retrieves a value by key from the specified bucket
 +	Get(bucket, key string) ([]byte, error)
++
 +	// Delete removes a key from the specified bucket
 +	Delete(bucket, key string) error
++
 +	// GetAll retrieves all key-value pairs from the specified bucket
 +	GetAll(bucket string) (map[string][]byte, error)
++
 +	// CreateBucket creates a new bucket if it doesn't exist
 +	CreateBucket(bucket string) error
++
 +	// ListBuckets returns all bucket names
 +	ListBuckets() ([]string, error)
++
 +	// Close closes the database connection
 +	Close() error
++
 +	// Stats returns database statistics
 +	Stats() (*Stats, error)
 +}
++
 +// Stats represents database statistics
 +type Stats struct {
 +	BucketCount int64            `json:"bucket_count"`
 +	KeyCount    map[string]int64 `json:"key_count"`    // Keys per bucket
 +	TotalSize   int64            `json:"total_size"`   // Total database size in bytes
 +	PageSize    int              `json:"page_size"`
 +	FreePages   int              `json:"free_pages"`
 +}
++
 +// New creates a new database instance based on configuration
 +func New(cfg config.DatabaseConfig) (Database, error) {
 +	switch cfg.Type {
 +	case "bbolt":
 +		return NewBBoltDB(cfg.Path)
 +	case "postgres":
 +		return NewPostgresDB(cfg.URL)
 +	default:
 +		return nil, fmt.Errorf("unsupported database type: %s", cfg.Type)
 +	}
 +}

internal/database/postgres.goadded

 +package database
++
 +import (
 +	"database/sql"
 +	"encoding/json"
 +	"fmt"
 +	"strings"
++
 +	"github.com/sirupsen/logrus"
 +	_ "github.com/lib/pq" // PostgreSQL driver
 +)
++
 +// PostgresDB implements the Database interface using PostgreSQL
 +type PostgresDB struct {
 +	db  *sql.DB
 +	url string
 +}
++
 +// NewPostgresDB creates a new PostgreSQL database instance
 +func NewPostgresDB(url string) (*PostgresDB, error) {
 +	db, err := sql.Open("postgres", url)
 +	if err != nil {
 +		return nil, fmt.Errorf("failed to open PostgreSQL connection: %w", err)
 +	}
++
 +	// Test the connection
 +	if err := db.Ping(); err != nil {
 +		db.Close()
 +		return nil, fmt.Errorf("failed to ping PostgreSQL database: %w", err)
 +	}
++
 +	pgDB := &PostgresDB{
 +		db:  db,
 +		url: url,
 +	}
++
 +	// Initialize schema
 +	if err := pgDB.initializeSchema(); err != nil {
 +		db.Close()
 +		return nil, fmt.Errorf("failed to initialize schema: %w", err)
 +	}
++
 +	logrus.Info("PostgreSQL database initialized")
 +	return pgDB, nil
 +}
++
 +// initializeSchema creates the necessary tables
 +func (p *PostgresDB) initializeSchema() error {
 +	schema := `
 +	CREATE TABLE IF NOT EXISTS coordinator_data (
 +		bucket VARCHAR(255) NOT NULL,
 +		key VARCHAR(255) NOT NULL,
 +		value BYTEA NOT NULL,
 +		created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
 +		updated_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
 +		PRIMARY KEY (bucket, key)
 +	);
++
 +	CREATE INDEX IF NOT EXISTS idx_coordinator_data_bucket ON coordinator_data(bucket);
 +	CREATE INDEX IF NOT EXISTS idx_coordinator_data_updated ON coordinator_data(updated_at);
++
 +	-- Function to update the updated_at column
 +	CREATE OR REPLACE FUNCTION update_updated_at_column()
 +	RETURNS TRIGGER AS $$
 +	BEGIN
 +		NEW.updated_at = CURRENT_TIMESTAMP;
 +		RETURN NEW;
 +	END;
 +	$$ language 'plpgsql';
++
 +	-- Trigger to automatically update updated_at
 +	DROP TRIGGER IF EXISTS update_coordinator_data_updated_at ON coordinator_data;
 +	CREATE TRIGGER update_coordinator_data_updated_at
 +		BEFORE UPDATE ON coordinator_data
 +		FOR EACH ROW
 +		EXECUTE FUNCTION update_updated_at_column();
 +	`
++
 +	_, err := p.db.Exec(schema)
 +	return err
 +}
++
 +// Set stores a key-value pair in the specified bucket
 +func (p *PostgresDB) Set(bucket, key string, value []byte) error {
 +	query := `
 +		INSERT INTO coordinator_data (bucket, key, value)
 +		VALUES ($1, $2, $3)
 +		ON CONFLICT (bucket, key)
 +		DO UPDATE SET value = EXCLUDED.value, updated_at = CURRENT_TIMESTAMP
 +	`
++
 +	_, err := p.db.Exec(query, bucket, key, value)
 +	if err != nil {
 +		return fmt.Errorf("failed to set key %s in bucket %s: %w", key, bucket, err)
 +	}
++
 +	return nil
 +}
++
 +// Get retrieves a value by key from the specified bucket
 +func (p *PostgresDB) Get(bucket, key string) ([]byte, error) {
 +	query := `SELECT value FROM coordinator_data WHERE bucket = $1 AND key = $2`
++
 +	var value []byte
 +	err := p.db.QueryRow(query, bucket, key).Scan(&value)
 +	if err != nil {
 +		if err == sql.ErrNoRows {
 +			return nil, fmt.Errorf("key %s not found in bucket %s", key, bucket)
 +		}
 +		return nil, fmt.Errorf("failed to get key %s from bucket %s: %w", key, bucket, err)
 +	}
++
 +	return value, nil
 +}
++
 +// Delete removes a key from the specified bucket
 +func (p *PostgresDB) Delete(bucket, key string) error {
 +	query := `DELETE FROM coordinator_data WHERE bucket = $1 AND key = $2`
++
 +	result, err := p.db.Exec(query, bucket, key)
 +	if err != nil {
 +		return fmt.Errorf("failed to delete key %s from bucket %s: %w", key, bucket, err)
 +	}
++
 +	rowsAffected, err := result.RowsAffected()
 +	if err != nil {
 +		return fmt.Errorf("failed to get rows affected: %w", err)
 +	}
++
 +	if rowsAffected == 0 {
 +		return fmt.Errorf("key %s not found in bucket %s", key, bucket)
 +	}
++
 +	return nil
 +}
++
 +// GetAll retrieves all key-value pairs from the specified bucket
 +func (p *PostgresDB) GetAll(bucket string) (map[string][]byte, error) {
 +	query := `SELECT key, value FROM coordinator_data WHERE bucket = $1`
++
 +	rows, err := p.db.Query(query, bucket)
 +	if err != nil {
 +		return nil, fmt.Errorf("failed to query bucket %s: %w", bucket, err)
 +	}
 +	defer rows.Close()
++
 +	result := make(map[string][]byte)
++
 +	for rows.Next() {
 +		var key string
 +		var value []byte
++
 +		if err := rows.Scan(&key, &value); err != nil {
 +			return nil, fmt.Errorf("failed to scan row: %w", err)
 +		}
++
 +		result[key] = value
 +	}
++
 +	if err := rows.Err(); err != nil {
 +		return nil, fmt.Errorf("error iterating rows: %w", err)
 +	}
++
 +	return result, nil
 +}
++
 +// CreateBucket creates a new bucket (no-op for PostgreSQL since we use a single table)
 +func (p *PostgresDB) CreateBucket(bucket string) error {
 +	// In PostgreSQL implementation, buckets are just logical groupings
 +	// We don't need to create anything physically
 +	return nil
 +}
++
 +// ListBuckets returns all bucket names
 +func (p *PostgresDB) ListBuckets() ([]string, error) {
 +	query := `SELECT DISTINCT bucket FROM coordinator_data ORDER BY bucket`
++
 +	rows, err := p.db.Query(query)
 +	if err != nil {
 +		return nil, fmt.Errorf("failed to query buckets: %w", err)
 +	}
 +	defer rows.Close()
++
 +	var buckets []string
++
 +	for rows.Next() {
 +		var bucket string
 +		if err := rows.Scan(&bucket); err != nil {
 +			return nil, fmt.Errorf("failed to scan bucket name: %w", err)
 +		}
 +		buckets = append(buckets, bucket)
 +	}
++
 +	if err := rows.Err(); err != nil {
 +		return nil, fmt.Errorf("error iterating bucket rows: %w", err)
 +	}
++
 +	return buckets, nil
 +}
++
 +// Close closes the database connection
 +func (p *PostgresDB) Close() error {
 +	if p.db != nil {
 +		logrus.Info("Closing PostgreSQL database connection")
 +		return p.db.Close()
 +	}
 +	return nil
 +}
++
 +// Stats returns database statistics
 +func (p *PostgresDB) Stats() (*Stats, error) {
 +	stats := &Stats{
 +		KeyCount: make(map[string]int64),
 +	}
++
 +	// Get total database size
 +	var dbSize sql.NullInt64
 +	sizeQuery := `SELECT pg_database_size(current_database())`
 +	err := p.db.QueryRow(sizeQuery).Scan(&dbSize)
 +	if err != nil {
 +		logrus.WithError(err).Warn("Failed to get database size")
 +	} else {
 +		stats.TotalSize = dbSize.Int64
 +	}
++
 +	// Get bucket counts
 +	countQuery := `
 +		SELECT bucket, COUNT(*) as key_count
 +		FROM coordinator_data
 +		GROUP BY bucket
 +	`
++
 +	rows, err := p.db.Query(countQuery)
 +	if err != nil {
 +		return nil, fmt.Errorf("failed to get bucket counts: %w", err)
 +	}
 +	defer rows.Close()
++
 +	bucketCount := int64(0)
 +	for rows.Next() {
 +		var bucket string
 +		var keyCount int64
++
 +		if err := rows.Scan(&bucket, &keyCount); err != nil {
 +			return nil, fmt.Errorf("failed to scan bucket count: %w", err)
 +		}
++
 +		stats.KeyCount[bucket] = keyCount
 +		bucketCount++
 +	}
++
 +	if err := rows.Err(); err != nil {
 +		return nil, fmt.Errorf("error iterating count rows: %w", err)
 +	}
++
 +	stats.BucketCount = bucketCount
++
 +	return stats, nil
 +}
++
 +// Cleanup removes old entries (optional maintenance function)
 +func (p *PostgresDB) Cleanup(olderThan string) error {
 +	query := `DELETE FROM coordinator_data WHERE updated_at < NOW() - INTERVAL '%s'`
++
 +	// Sanitize the interval string
 +	if !isValidInterval(olderThan) {
 +		return fmt.Errorf("invalid interval format: %s", olderThan)
 +	}
++
 +	_, err := p.db.Exec(fmt.Sprintf(query, olderThan))
 +	if err != nil {
 +		return fmt.Errorf("failed to cleanup old entries: %w", err)
 +	}
++
 +	return nil
 +}
++
 +// Backup creates a logical backup (PostgreSQL-specific)
 +func (p *PostgresDB) Backup() ([]byte, error) {
 +	query := `
 +		SELECT json_agg(
 +			json_build_object(
 +				'bucket', bucket,
 +				'key', key,
 +				'value', encode(value, 'base64'),
 +				'updated_at', updated_at
 +			)
 +		)
 +		FROM coordinator_data
 +	`
++
 +	var backupData sql.NullString
 +	err := p.db.QueryRow(query).Scan(&backupData)
 +	if err != nil {
 +		return nil, fmt.Errorf("failed to create backup: %w", err)
 +	}
++
 +	if !backupData.Valid {
 +		return []byte("[]"), nil // Empty backup
 +	}
++
 +	return []byte(backupData.String), nil
 +}
++
 +// Restore restores data from a backup
 +func (p *PostgresDB) Restore(backupData []byte) error {
 +	var entries []map[string]interface{}
 +	if err := json.Unmarshal(backupData, &entries); err != nil {
 +		return fmt.Errorf("failed to parse backup data: %w", err)
 +	}
++
 +	// Begin transaction
 +	tx, err := p.db.Begin()
 +	if err != nil {
 +		return fmt.Errorf("failed to begin transaction: %w", err)
 +	}
 +	defer tx.Rollback()
++
 +	// Clear existing data
 +	if _, err := tx.Exec("TRUNCATE coordinator_data"); err != nil {
 +		return fmt.Errorf("failed to clear existing data: %w", err)
 +	}
++
 +	// Restore entries
 +	stmt, err := tx.Prepare(`
 +		INSERT INTO coordinator_data (bucket, key, value, updated_at)
 +		VALUES ($1, $2, decode($3, 'base64'), $4)
 +	`)
 +	if err != nil {
 +		return fmt.Errorf("failed to prepare restore statement: %w", err)
 +	}
 +	defer stmt.Close()
++
 +	for _, entry := range entries {
 +		bucket, _ := entry["bucket"].(string)
 +		key, _ := entry["key"].(string)
 +		value, _ := entry["value"].(string)
 +		updatedAt, _ := entry["updated_at"].(string)
++
 +		if _, err := stmt.Exec(bucket, key, value, updatedAt); err != nil {
 +			return fmt.Errorf("failed to restore entry %s/%s: %w", bucket, key, err)
 +		}
 +	}
++
 +	return tx.Commit()
 +}
++
 +// isValidInterval checks if the interval string is safe for SQL
 +func isValidInterval(interval string) bool {
 +	// Simple validation - only allow alphanumeric characters and spaces
 +	allowed := "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789 "
 +	for _, char := range interval {
 +		if !strings.ContainsRune(allowed, char) {
 +			return false
 +		}
 +	}
 +	return len(interval) > 0 && len(interval) < 50
 +}

internal/health/monitor.goadded

 +package health
++
 +import (
 +	"context"
 +	"fmt"
 +	"net/http"
 +	"runtime"
 +	"time"
++
 +	"github.com/gin-gonic/gin"
 +	"github.com/sirupsen/logrus"
++
 +	"github.com/ZephyrFS/zephyrfs-coordinator/internal/config"
 +	"github.com/ZephyrFS/zephyrfs-coordinator/internal/coordinator"
 +)
++
 +// Monitor represents the health monitoring system
 +type Monitor struct {
 +	coordinator *coordinator.Coordinator
 +	config      config.HealthConfig
 +	metrics     *Metrics
 +	startTime   time.Time
 +}
++
 +// Metrics represents collected health metrics
 +type Metrics struct {
 +	// System metrics
 +	MemoryUsage    MemoryStats    `json:"memory_usage"`
 +	CPUUsage       float64        `json:"cpu_usage"`
 +	GoroutineCount int            `json:"goroutine_count"`
++
 +	// Application metrics
 +	RequestCount    int64                  `json:"request_count"`
 +	ErrorCount      int64                  `json:"error_count"`
 +	ResponseTimes   ResponseTimeStats      `json:"response_times"`
 +	DatabaseStats   DatabaseStats          `json:"database_stats"`
++
 +	// Network metrics
 +	NetworkStats    NetworkHealthStats     `json:"network_stats"`
++
 +	// Coordinator-specific metrics
 +	CoordinatorStats CoordinatorHealthStats `json:"coordinator_stats"`
++
 +	// Timestamps
 +	LastUpdated time.Time `json:"last_updated"`
 +	Uptime      string    `json:"uptime"`
 +}
++
 +// MemoryStats represents memory usage statistics
 +type MemoryStats struct {
 +	Allocated       uint64  `json:"allocated"`        // bytes allocated and still in use
 +	TotalAllocated  uint64  `json:"total_allocated"`  // bytes allocated (even if freed)
 +	SystemMemory    uint64  `json:"system_memory"`    // bytes obtained from system
 +	GCCount         uint32  `json:"gc_count"`         // number of garbage collections
 +	HeapSize        uint64  `json:"heap_size"`        // heap size
 +	HeapInUse       uint64  `json:"heap_in_use"`      // heap bytes in use
 +}
++
 +// ResponseTimeStats represents response time statistics
 +type ResponseTimeStats struct {
 +	Average    float64 `json:"average"`
 +	Min        float64 `json:"min"`
 +	Max        float64 `json:"max"`
 +	P50        float64 `json:"p50"`
 +	P95        float64 `json:"p95"`
 +	P99        float64 `json:"p99"`
 +}
++
 +// DatabaseStats represents database health statistics
 +type DatabaseStats struct {
 +	ConnectionCount int64 `json:"connection_count"`
 +	QueryCount      int64 `json:"query_count"`
 +	ErrorCount      int64 `json:"error_count"`
 +	AverageLatency  float64 `json:"average_latency"`
 +}
++
 +// NetworkHealthStats represents network health statistics
 +type NetworkHealthStats struct {
 +	ActiveNodes      int   `json:"active_nodes"`
 +	InactiveNodes    int   `json:"inactive_nodes"`
 +	TotalConnections int64 `json:"total_connections"`
 +	FailedConnections int64 `json:"failed_connections"`
 +}
++
 +// CoordinatorHealthStats represents coordinator-specific health metrics
 +type CoordinatorHealthStats struct {
 +	RegisteredNodes  int   `json:"registered_nodes"`
 +	ActiveFiles      int   `json:"active_files"`
 +	TotalChunks      int   `json:"total_chunks"`
 +	ReplicationTasks int   `json:"replication_tasks"`
 +	LastHeartbeat    int64 `json:"last_heartbeat"`
 +}
++
 +// NewMonitor creates a new health monitor
 +func NewMonitor(coord *coordinator.Coordinator, cfg config.HealthConfig) *Monitor {
 +	return &Monitor{
 +		coordinator: coord,
 +		config:      cfg,
 +		metrics:     &Metrics{},
 +		startTime:   time.Now(),
 +	}
 +}
++
 +// Monitor starts the health monitoring background process
 +func Monitor(ctx context.Context, coord *coordinator.Coordinator, cfg config.HealthConfig) {
 +	monitor := NewMonitor(coord, cfg)
++
 +	// Start metrics collection
 +	go monitor.collectMetrics(ctx)
++
 +	// Start metrics HTTP server if enabled
 +	if cfg.MetricsEnabled {
 +		go monitor.startMetricsServer(ctx)
 +	}
++
 +	logrus.WithFields(logrus.Fields{
 +		"check_interval": cfg.CheckInterval,
 +		"metrics_enabled": cfg.MetricsEnabled,
 +		"metrics_port": cfg.MetricsPort,
 +	}).Info("Health monitoring started")
 +}
++
 +// collectMetrics runs the periodic metrics collection
 +func (m *Monitor) collectMetrics(ctx context.Context) {
 +	ticker := time.NewTicker(m.config.CheckInterval)
 +	defer ticker.Stop()
++
 +	for {
 +		select {
 +		case <-ctx.Done():
 +			logrus.Info("Stopping health metrics collection")
 +			return
 +		case <-ticker.C:
 +			m.updateMetrics()
 +		}
 +	}
 +}
++
 +// updateMetrics collects current system and application metrics
 +func (m *Monitor) updateMetrics() {
 +	m.metrics.LastUpdated = time.Now()
 +	m.metrics.Uptime = time.Since(m.startTime).String()
++
 +	// Collect system metrics
 +	m.collectSystemMetrics()
++
 +	// Collect application metrics
 +	m.collectApplicationMetrics()
++
 +	// Collect network metrics
 +	m.collectNetworkMetrics()
++
 +	// Collect coordinator-specific metrics
 +	m.collectCoordinatorMetrics()
++
 +	// Log summary metrics periodically
 +	if time.Since(m.startTime).Minutes() > 1 &&
 +	   int(time.Since(m.startTime).Minutes()) % 5 == 0 {
 +		m.logMetricsSummary()
 +	}
 +}
++
 +// collectSystemMetrics gathers system-level metrics
 +func (m *Monitor) collectSystemMetrics() {
 +	var memStats runtime.MemStats
 +	runtime.ReadMemStats(&memStats)
++
 +	m.metrics.MemoryUsage = MemoryStats{
 +		Allocated:      memStats.Alloc,
 +		TotalAllocated: memStats.TotalAlloc,
 +		SystemMemory:   memStats.Sys,
 +		GCCount:        memStats.NumGC,
 +		HeapSize:       memStats.HeapSys,
 +		HeapInUse:      memStats.HeapInuse,
 +	}
++
 +	m.metrics.GoroutineCount = runtime.NumGoroutine()
 +}
++
 +// collectApplicationMetrics gathers application-level metrics
 +func (m *Monitor) collectApplicationMetrics() {
 +	// These would be populated by middleware and other components
 +	// For now, we'll set placeholder values
++
 +	m.metrics.ResponseTimes = ResponseTimeStats{
 +		Average: 25.5,
 +		Min:     1.0,
 +		Max:     150.0,
 +		P50:     20.0,
 +		P95:     75.0,
 +		P99:     120.0,
 +	}
++
 +	m.metrics.DatabaseStats = DatabaseStats{
 +		ConnectionCount: 1,
 +		QueryCount:      m.metrics.DatabaseStats.QueryCount + 1,
 +		ErrorCount:      0,
 +		AverageLatency:  2.5,
 +	}
 +}
++
 +// collectNetworkMetrics gathers network-related metrics
 +func (m *Monitor) collectNetworkMetrics() {
 +	// Get network status from coordinator
 +	if resp, err := m.coordinator.GetNetworkStatus(context.Background()); err == nil {
 +		m.metrics.NetworkStats = NetworkHealthStats{
 +			ActiveNodes:       int(resp.NetworkStats.ActiveNodes),
 +			InactiveNodes:     int(resp.NetworkStats.TotalNodes - resp.NetworkStats.ActiveNodes),
 +			TotalConnections:  resp.NetworkStats.TotalFiles, // Placeholder
 +			FailedConnections: 0, // Would need to track this
 +		}
 +	}
 +}
++
 +// collectCoordinatorMetrics gathers coordinator-specific metrics
 +func (m *Monitor) collectCoordinatorMetrics() {
 +	if resp, err := m.coordinator.GetNetworkStatus(context.Background()); err == nil {
 +		m.metrics.CoordinatorStats = CoordinatorHealthStats{
 +			RegisteredNodes:  int(resp.NetworkStats.TotalNodes),
 +			ActiveFiles:      int(resp.NetworkStats.TotalFiles),
 +			TotalChunks:      int(resp.NetworkStats.TotalChunks),
 +			ReplicationTasks: 0, // Would need to track this
 +			LastHeartbeat:    time.Now().Unix(),
 +		}
 +	}
 +}
++
 +// logMetricsSummary logs a summary of current metrics
 +func (m *Monitor) logMetricsSummary() {
 +	logrus.WithFields(logrus.Fields{
 +		"uptime":              m.metrics.Uptime,
 +		"memory_allocated_mb": m.metrics.MemoryUsage.Allocated / 1024 / 1024,
 +		"heap_size_mb":        m.metrics.MemoryUsage.HeapSize / 1024 / 1024,
 +		"goroutines":          m.metrics.GoroutineCount,
 +		"gc_count":            m.metrics.MemoryUsage.GCCount,
 +		"active_nodes":        m.metrics.NetworkStats.ActiveNodes,
 +		"total_files":         m.metrics.CoordinatorStats.ActiveFiles,
 +		"total_chunks":        m.metrics.CoordinatorStats.TotalChunks,
 +	}).Info("Health metrics summary")
 +}
++
 +// startMetricsServer starts the HTTP server for metrics exposure
 +func (m *Monitor) startMetricsServer(ctx context.Context) {
 +	gin.SetMode(gin.ReleaseMode)
 +	router := gin.New()
 +	router.Use(gin.Recovery())
++
 +	// Metrics endpoints
 +	router.GET("/metrics", m.handleMetrics)
 +	router.GET("/health", m.handleHealth)
 +	router.GET("/ready", m.handleReadiness)
 +	router.GET("/live", m.handleLiveness)
++
 +	server := &http.Server{
 +		Addr:    fmt.Sprintf(":%d", m.config.MetricsPort),
 +		Handler: router,
 +	}
++
 +	// Start server in goroutine
 +	go func() {
 +		logrus.WithField("port", m.config.MetricsPort).Info("Starting metrics HTTP server")
 +		if err := server.ListenAndServe(); err != nil && err != http.ErrServerClosed {
 +			logrus.WithError(err).Error("Metrics server failed")
 +		}
 +	}()
++
 +	// Wait for context cancellation
 +	<-ctx.Done()
++
 +	// Shutdown server gracefully
 +	shutdownCtx, cancel := context.WithTimeout(context.Background(), 5*time.Second)
 +	defer cancel()
++
 +	if err := server.Shutdown(shutdownCtx); err != nil {
 +		logrus.WithError(err).Error("Failed to shutdown metrics server")
 +	} else {
 +		logrus.Info("Metrics server stopped")
 +	}
 +}
++
 +// HTTP handlers for metrics endpoints
++
 +func (m *Monitor) handleMetrics(c *gin.Context) {
 +	c.JSON(http.StatusOK, m.metrics)
 +}
++
 +func (m *Monitor) handleHealth(c *gin.Context) {
 +	health := m.calculateHealthStatus()
++
 +	if health.Status == "healthy" {
 +		c.JSON(http.StatusOK, health)
 +	} else {
 +		c.JSON(http.StatusServiceUnavailable, health)
 +	}
 +}
++
 +func (m *Monitor) handleReadiness(c *gin.Context) {
 +	readiness := m.calculateReadinessStatus()
++
 +	if readiness.Ready {
 +		c.JSON(http.StatusOK, readiness)
 +	} else {
 +		c.JSON(http.StatusServiceUnavailable, readiness)
 +	}
 +}
++
 +func (m *Monitor) handleLiveness(c *gin.Context) {
 +	liveness := m.calculateLivenessStatus()
++
 +	if liveness.Alive {
 +		c.JSON(http.StatusOK, liveness)
 +	} else {
 +		c.JSON(http.StatusServiceUnavailable, liveness)
 +	}
 +}
++
 +// Health status calculation
++
 +type HealthStatus struct {
 +	Status      string                 `json:"status"`
 +	Timestamp   time.Time              `json:"timestamp"`
 +	Uptime      string                 `json:"uptime"`
 +	Version     string                 `json:"version"`
 +	Checks      map[string]CheckResult `json:"checks"`
 +}
++
 +type CheckResult struct {
 +	Status  string      `json:"status"`
 +	Message string      `json:"message,omitempty"`
 +	Data    interface{} `json:"data,omitempty"`
 +}
++
 +func (m *Monitor) calculateHealthStatus() HealthStatus {
 +	checks := make(map[string]CheckResult)
 +	overallHealthy := true
++
 +	// Memory check
 +	memoryHealthy := m.metrics.MemoryUsage.HeapInUse < m.metrics.MemoryUsage.HeapSize*80/100
 +	checks["memory"] = CheckResult{
 +		Status:  statusFromBool(memoryHealthy),
 +		Message: fmt.Sprintf("Heap usage: %d MB / %d MB",
 +			m.metrics.MemoryUsage.HeapInUse/1024/1024,
 +			m.metrics.MemoryUsage.HeapSize/1024/1024),
 +	}
 +	overallHealthy = overallHealthy && memoryHealthy
++
 +	// Goroutine check
 +	goroutineHealthy := m.metrics.GoroutineCount < 1000 // Arbitrary threshold
 +	checks["goroutines"] = CheckResult{
 +		Status:  statusFromBool(goroutineHealthy),
 +		Message: fmt.Sprintf("Active goroutines: %d", m.metrics.GoroutineCount),
 +	}
 +	overallHealthy = overallHealthy && goroutineHealthy
++
 +	// Network check
 +	networkHealthy := m.metrics.NetworkStats.ActiveNodes > 0
 +	checks["network"] = CheckResult{
 +		Status:  statusFromBool(networkHealthy),
 +		Message: fmt.Sprintf("Active nodes: %d", m.metrics.NetworkStats.ActiveNodes),
 +	}
 +	overallHealthy = overallHealthy && networkHealthy
++
 +	return HealthStatus{
 +		Status:    statusFromBool(overallHealthy),
 +		Timestamp: time.Now(),
 +		Uptime:    m.metrics.Uptime,
 +		Version:   "1.0.0",
 +		Checks:    checks,
 +	}
 +}
++
 +type ReadinessStatus struct {
 +	Ready     bool                   `json:"ready"`
 +	Timestamp time.Time              `json:"timestamp"`
 +	Checks    map[string]CheckResult `json:"checks"`
 +}
++
 +func (m *Monitor) calculateReadinessStatus() ReadinessStatus {
 +	checks := make(map[string]CheckResult)
 +	overallReady := true
++
 +	// Database readiness
 +	dbReady := m.metrics.DatabaseStats.ErrorCount == 0
 +	checks["database"] = CheckResult{
 +		Status:  statusFromBool(dbReady),
 +		Message: fmt.Sprintf("Error count: %d", m.metrics.DatabaseStats.ErrorCount),
 +	}
 +	overallReady = overallReady && dbReady
++
 +	// Coordinator readiness
 +	coordReady := time.Since(m.startTime) > 10*time.Second // Grace period
 +	checks["coordinator"] = CheckResult{
 +		Status:  statusFromBool(coordReady),
 +		Message: fmt.Sprintf("Running for: %s", m.metrics.Uptime),
 +	}
 +	overallReady = overallReady && coordReady
++
 +	return ReadinessStatus{
 +		Ready:     overallReady,
 +		Timestamp: time.Now(),
 +		Checks:    checks,
 +	}
 +}
++
 +type LivenessStatus struct {
 +	Alive     bool      `json:"alive"`
 +	Timestamp time.Time `json:"timestamp"`
 +	LastCheck time.Time `json:"last_check"`
 +}
++
 +func (m *Monitor) calculateLivenessStatus() LivenessStatus {
 +	// Simple liveness check - if we can execute this function, we're alive
 +	// In a more complex system, this might check for deadlocks, etc.
++
 +	alive := time.Since(m.metrics.LastUpdated) < m.config.CheckInterval*2
++
 +	return LivenessStatus{
 +		Alive:     alive,
 +		Timestamp: time.Now(),
 +		LastCheck: m.metrics.LastUpdated,
 +	}
 +}
++
 +// Helper functions
++
 +func statusFromBool(healthy bool) string {
 +	if healthy {
 +		return "healthy"
 +	}
 +	return "unhealthy"
 +}

internal/models/models.goadded

 +package models
++
 +import "time"
++
 +// Node-related models
++
 +// NodeInfo represents information about a registered node
 +type NodeInfo struct {
 +	NodeID          string            `json:"node_id"`
 +	Addresses       []string          `json:"addresses"`
 +	StorageCapacity int64             `json:"storage_capacity"`
 +	Capabilities    map[string]string `json:"capabilities"`
 +	Status          string            `json:"status"` // "active", "inactive", "maintenance"
 +	RegisteredAt    time.Time         `json:"registered_at"`
 +	LastHeartbeat   time.Time         `json:"last_heartbeat"`
 +	Stats           *NodeStats        `json:"stats,omitempty"`
 +}
++
 +// NodeStats represents runtime statistics for a node
 +type NodeStats struct {
 +	StorageUsed     int64   `json:"storage_used"`
 +	StorageAvailable int64  `json:"storage_available"`
 +	ChunksStored    int64   `json:"chunks_stored"`
 +	BandwidthUp     int64   `json:"bandwidth_up"`
 +	BandwidthDown   int64   `json:"bandwidth_down"`
 +	CpuUsage        float64 `json:"cpu_usage"`
 +	MemoryUsage     float64 `json:"memory_usage"`
 +	UptimeSeconds   int64   `json:"uptime_seconds"`
 +}
++
 +// NodeStatus represents the status of a node for API responses
 +type NodeStatus struct {
 +	NodeID        string     `json:"node_id"`
 +	Addresses     []string   `json:"addresses"`
 +	Stats         *NodeStats `json:"stats"`
 +	LastHeartbeat int64      `json:"last_heartbeat"`
 +	Status        string     `json:"status"`
 +}
++
 +// File and chunk models
++
 +// FileRecord represents metadata about a stored file
 +type FileRecord struct {
 +	FileID       string         `json:"file_id"`
 +	FileName     string         `json:"file_name"`
 +	FileSize     int64          `json:"file_size"`
 +	FileHash     string         `json:"file_hash"`
 +	Chunks       []*ChunkRecord `json:"chunks"`
 +	OwnerNodeID  string         `json:"owner_node_id"`
 +	CreatedAt    int64          `json:"created_at"`
 +	LastAccessed int64          `json:"last_accessed"`
 +}
++
 +// ChunkRecord represents metadata about a file chunk
 +type ChunkRecord struct {
 +	ChunkID          string   `json:"chunk_id"`
 +	Hash             string   `json:"hash"`
 +	Size             int64    `json:"size"`
 +	Index            int32    `json:"index"`
 +	StoredAtNodes    []string `json:"stored_at_nodes"`
 +	ReplicationCount int32    `json:"replication_count"`
 +}
++
 +// ChunkInfo represents detailed information about a chunk
 +type ChunkInfo struct {
 +	ChunkID       string   `json:"chunk_id"`
 +	Hash          string   `json:"hash"`
 +	Size          int64    `json:"size"`
 +	Index         int32    `json:"index"`
 +	FileID        string   `json:"file_id"`
 +	StoredAtNodes []string `json:"stored_at_nodes"`
 +	CreatedAt     int64    `json:"created_at"`
 +}
++
 +// Request/Response models for gRPC API
++
 +// RegisterNodeRequest represents a node registration request
 +type RegisterNodeRequest struct {
 +	NodeID          string            `json:"node_id"`
 +	Addresses       []string          `json:"addresses"`
 +	StorageCapacity int64             `json:"storage_capacity"`
 +	Capabilities    map[string]string `json:"capabilities"`
 +}
++
 +// RegisterNodeResponse represents a node registration response
 +type RegisterNodeResponse struct {
 +	Success        bool     `json:"success"`
 +	Message        string   `json:"message"`
 +	AssignedNodeID string   `json:"assigned_node_id"`
 +	BootstrapPeers []string `json:"bootstrap_peers"`
 +}
++
 +// UnregisterNodeRequest represents a node unregistration request
 +type UnregisterNodeRequest struct {
 +	NodeID string `json:"node_id"`
 +	Reason string `json:"reason"`
 +}
++
 +// UnregisterNodeResponse represents a node unregistration response
 +type UnregisterNodeResponse struct {
 +	Success bool   `json:"success"`
 +	Message string `json:"message"`
 +}
++
 +// GetActiveNodesRequest represents a request for active nodes
 +type GetActiveNodesRequest struct {
 +	Limit        int32    `json:"limit"`
 +	ExcludeNodes []string `json:"exclude_nodes"`
 +}
++
 +// GetActiveNodesResponse represents a response with active nodes
 +type GetActiveNodesResponse struct {
 +	Nodes      []*NodeStatus `json:"nodes"`
 +	TotalNodes int32         `json:"total_nodes"`
 +}
++
 +// NodeHeartbeatRequest represents a node heartbeat
 +type NodeHeartbeatRequest struct {
 +	NodeID string     `json:"node_id"`
 +	Stats  *NodeStats `json:"stats"`
 +}
++
 +// NodeHeartbeatResponse represents a heartbeat response
 +type NodeHeartbeatResponse struct {
 +	Success bool     `json:"success"`
 +	Message string   `json:"message"`
 +	Tasks   []string `json:"tasks"`
 +}
++
 +// RegisterFileRequest represents a file registration request
 +type RegisterFileRequest struct {
 +	FileID      string          `json:"file_id"`
 +	FileName    string          `json:"file_name"`
 +	FileSize    int64           `json:"file_size"`
 +	FileHash    string          `json:"file_hash"`
 +	Chunks      []*ChunkMetadata `json:"chunks"`
 +	OwnerNodeID string          `json:"owner_node_id"`
 +}
++
 +// RegisterFileResponse represents a file registration response
 +type RegisterFileResponse struct {
 +	Success         bool               `json:"success"`
 +	Message         string             `json:"message"`
 +	ChunkPlacements []*ChunkPlacement  `json:"chunk_placements"`
 +}
++
 +// ChunkMetadata represents metadata about a chunk during file registration
 +type ChunkMetadata struct {
 +	ChunkID string `json:"chunk_id"`
 +	Hash    string `json:"hash"`
 +	Size    int64  `json:"size"`
 +	Index   int32  `json:"index"`
 +}
++
 +// ChunkPlacement represents where chunks should be stored
 +type ChunkPlacement struct {
 +	ChunkID           string   `json:"chunk_id"`
 +	TargetNodes       []string `json:"target_nodes"`
 +	ReplicationFactor int32    `json:"replication_factor"`
 +}
++
 +// GetFileInfoRequest represents a file info request
 +type GetFileInfoRequest struct {
 +	FileID string `json:"file_id"`
 +}
++
 +// GetFileInfoResponse represents a file info response
 +type GetFileInfoResponse struct {
 +	Success  bool        `json:"success"`
 +	Message  string      `json:"message"`
 +	FileInfo *FileRecord `json:"file_info"`
 +}
++
 +// UpdateChunkLocationsRequest represents a chunk location update
 +type UpdateChunkLocationsRequest struct {
 +	ChunkID   string   `json:"chunk_id"`
 +	NodeIDs   []string `json:"node_ids"`
 +	Operation string   `json:"operation"` // "add" or "remove"
 +}
++
 +// UpdateChunkLocationsResponse represents a chunk location update response
 +type UpdateChunkLocationsResponse struct {
 +	Success bool   `json:"success"`
 +	Message string `json:"message"`
 +}
++
 +// FindChunkLocationsRequest represents a chunk location query
 +type FindChunkLocationsRequest struct {
 +	ChunkID        string `json:"chunk_id"`
 +	PreferredCount int32  `json:"preferred_count"`
 +}
++
 +// FindChunkLocationsResponse represents a chunk location response
 +type FindChunkLocationsResponse struct {
 +	Success       bool     `json:"success"`
 +	Message       string   `json:"message"`
 +	NodeIDs       []string `json:"node_ids"`
 +	NodeAddresses []string `json:"node_addresses"`
 +}
++
 +// GetNetworkStatusRequest represents a network status request
 +type GetNetworkStatusRequest struct{}
++
 +// GetNetworkStatusResponse represents a network status response
 +type GetNetworkStatusResponse struct {
 +	NetworkStats *NetworkStats   `json:"network_stats"`
 +	ActiveNodes  []*NodeStatus   `json:"active_nodes"`
 +	Timestamp    int64           `json:"timestamp"`
 +}
++
 +// NetworkStats represents network-wide statistics
 +type NetworkStats struct {
 +	TotalNodes             int32   `json:"total_nodes"`
 +	ActiveNodes            int32   `json:"active_nodes"`
 +	TotalStorageCapacity   int64   `json:"total_storage_capacity"`
 +	TotalStorageUsed       int64   `json:"total_storage_used"`
 +	TotalFiles             int64   `json:"total_files"`
 +	TotalChunks            int64   `json:"total_chunks"`
 +	AverageNodeUptime      float64 `json:"average_node_uptime"`
 +	NetworkUptimeSeconds   int64   `json:"network_uptime_seconds"`
 +	Timestamp              int64   `json:"timestamp"`
 +}

internal/server/grpc.goadded

 +package server
++
 +import (
 +	"context"
 +	"time"
++
 +	"github.com/sirupsen/logrus"
 +	"google.golang.org/grpc"
 +	"google.golang.org/grpc/codes"
 +	"google.golang.org/grpc/status"
++
 +	"github.com/ZephyrFS/zephyrfs-coordinator/internal/coordinator"
 +	"github.com/ZephyrFS/zephyrfs-coordinator/internal/models"
 +	pb "github.com/ZephyrFS/zephyrfs-proto/gen/go/coordinator"
 +)
++
 +// CoordinatorServer implements the gRPC CoordinatorService
 +type CoordinatorServer struct {
 +	pb.UnimplementedCoordinatorServiceServer
 +	coordinator *coordinator.Coordinator
 +}
++
 +// NewCoordinatorServer creates a new gRPC server instance
 +func NewCoordinatorServer(coord *coordinator.Coordinator) *CoordinatorServer {
 +	return &CoordinatorServer{
 +		coordinator: coord,
 +	}
 +}
++
 +// RegisterCoordinatorService registers the coordinator service with the gRPC server
 +func RegisterCoordinatorService(grpcServer *grpc.Server, coord *coordinator.Coordinator) {
 +	server := NewCoordinatorServer(coord)
 +	pb.RegisterCoordinatorServiceServer(grpcServer, server)
 +	logrus.Info("Coordinator gRPC service registered")
 +}
++
 +// RegisterNode handles node registration requests
 +func (s *CoordinatorServer) RegisterNode(ctx context.Context, req *pb.RegisterNodeRequest) (*pb.RegisterNodeResponse, error) {
 +	logrus.WithFields(logrus.Fields{
 +		"nodeID":    req.NodeId,
 +		"addresses": req.Addresses,
 +		"capacity":  req.StorageCapacity,
 +	}).Debug("Processing node registration")
++
 +	// Convert protobuf request to internal model
 +	modelReq := &models.RegisterNodeRequest{
 +		NodeID:          req.NodeId,
 +		Addresses:       req.Addresses,
 +		StorageCapacity: req.StorageCapacity,
 +		Capabilities:    req.Capabilities,
 +	}
++
 +	// Process the request
 +	resp, err := s.coordinator.RegisterNode(ctx, modelReq)
 +	if err != nil {
 +		logrus.WithError(err).Error("Failed to register node")
 +		return nil, status.Errorf(codes.Internal, "Failed to register node: %v", err)
 +	}
++
 +	// Convert internal response to protobuf
 +	pbResp := &pb.RegisterNodeResponse{
 +		Success:        resp.Success,
 +		Message:        resp.Message,
 +		AssignedNodeId: resp.AssignedNodeID,
 +		BootstrapPeers: resp.BootstrapPeers,
 +	}
++
 +	logrus.WithFields(logrus.Fields{
 +		"nodeID":         resp.AssignedNodeID,
 +		"bootstrapPeers": len(resp.BootstrapPeers),
 +	}).Info("Node registered successfully")
++
 +	return pbResp, nil
 +}
++
 +// UnregisterNode handles node unregistration requests
 +func (s *CoordinatorServer) UnregisterNode(ctx context.Context, req *pb.UnregisterNodeRequest) (*pb.UnregisterNodeResponse, error) {
 +	logrus.WithFields(logrus.Fields{
 +		"nodeID": req.NodeId,
 +		"reason": req.Reason,
 +	}).Debug("Processing node unregistration")
++
 +	modelReq := &models.UnregisterNodeRequest{
 +		NodeID: req.NodeId,
 +		Reason: req.Reason,
 +	}
++
 +	resp, err := s.coordinator.UnregisterNode(ctx, modelReq)
 +	if err != nil {
 +		logrus.WithError(err).Error("Failed to unregister node")
 +		return nil, status.Errorf(codes.Internal, "Failed to unregister node: %v", err)
 +	}
++
 +	return &pb.UnregisterNodeResponse{
 +		Success: resp.Success,
 +		Message: resp.Message,
 +	}, nil
 +}
++
 +// GetActiveNodes returns a list of active nodes
 +func (s *CoordinatorServer) GetActiveNodes(ctx context.Context, req *pb.GetActiveNodesRequest) (*pb.GetActiveNodesResponse, error) {
 +	logrus.WithFields(logrus.Fields{
 +		"limit":        req.Limit,
 +		"excludeNodes": len(req.ExcludeNodes),
 +	}).Debug("Processing get active nodes request")
++
 +	modelReq := &models.GetActiveNodesRequest{
 +		Limit:        req.Limit,
 +		ExcludeNodes: req.ExcludeNodes,
 +	}
++
 +	resp, err := s.coordinator.GetActiveNodes(ctx, modelReq)
 +	if err != nil {
 +		logrus.WithError(err).Error("Failed to get active nodes")
 +		return nil, status.Errorf(codes.Internal, "Failed to get active nodes: %v", err)
 +	}
++
 +	// Convert nodes to protobuf format
 +	var pbNodes []*pb.NodeStatus
 +	for _, node := range resp.Nodes {
 +		pbNode := &pb.NodeStatus{
 +			NodeId:        node.NodeID,
 +			Addresses:     node.Addresses,
 +			LastHeartbeat: node.LastHeartbeat,
 +			Status:        node.Status,
 +		}
++
 +		if node.Stats != nil {
 +			pbNode.Stats = &pb.NodeStats{
 +				StorageUsed:      node.Stats.StorageUsed,
 +				StorageAvailable: node.Stats.StorageAvailable,
 +				ChunksStored:     node.Stats.ChunksStored,
 +				BandwidthUp:      node.Stats.BandwidthUp,
 +				BandwidthDown:    node.Stats.BandwidthDown,
 +				CpuUsage:         node.Stats.CpuUsage,
 +				MemoryUsage:      node.Stats.MemoryUsage,
 +				UptimeSeconds:    node.Stats.UptimeSeconds,
 +			}
 +		}
++
 +		pbNodes = append(pbNodes, pbNode)
 +	}
++
 +	return &pb.GetActiveNodesResponse{
 +		Nodes:      pbNodes,
 +		TotalNodes: resp.TotalNodes,
 +	}, nil
 +}
++
 +// NodeHeartbeat processes heartbeat messages from nodes
 +func (s *CoordinatorServer) NodeHeartbeat(ctx context.Context, req *pb.NodeHeartbeatRequest) (*pb.NodeHeartbeatResponse, error) {
 +	// Log heartbeat at debug level to avoid spam
 +	logrus.WithField("nodeID", req.NodeId).Debug("Processing node heartbeat")
++
 +	modelReq := &models.NodeHeartbeatRequest{
 +		NodeID: req.NodeId,
 +	}
++
 +	if req.Stats != nil {
 +		modelReq.Stats = &models.NodeStats{
 +			StorageUsed:      req.Stats.StorageUsed,
 +			StorageAvailable: req.Stats.StorageAvailable,
 +			ChunksStored:     req.Stats.ChunksStored,
 +			BandwidthUp:      req.Stats.BandwidthUp,
 +			BandwidthDown:    req.Stats.BandwidthDown,
 +			CpuUsage:         req.Stats.CpuUsage,
 +			MemoryUsage:      req.Stats.MemoryUsage,
 +			UptimeSeconds:    req.Stats.UptimeSeconds,
 +		}
 +	}
++
 +	resp, err := s.coordinator.NodeHeartbeat(ctx, modelReq)
 +	if err != nil {
 +		logrus.WithError(err).WithField("nodeID", req.NodeId).Error("Failed to process heartbeat")
 +		return nil, status.Errorf(codes.Internal, "Failed to process heartbeat: %v", err)
 +	}
++
 +	return &pb.NodeHeartbeatResponse{
 +		Success: resp.Success,
 +		Message: resp.Message,
 +		Tasks:   resp.Tasks,
 +	}, nil
 +}
++
 +// RegisterFile handles file registration requests
 +func (s *CoordinatorServer) RegisterFile(ctx context.Context, req *pb.RegisterFileRequest) (*pb.RegisterFileResponse, error) {
 +	logrus.WithFields(logrus.Fields{
 +		"fileID":   req.FileId,
 +		"fileName": req.FileName,
 +		"fileSize": req.FileSize,
 +		"chunks":   len(req.Chunks),
 +	}).Debug("Processing file registration")
++
 +	// Convert chunks
 +	var chunks []*models.ChunkMetadata
 +	for _, chunk := range req.Chunks {
 +		chunks = append(chunks, &models.ChunkMetadata{
 +			ChunkID: chunk.ChunkId,
 +			Hash:    chunk.Hash,
 +			Size:    chunk.Size,
 +			Index:   chunk.Index,
 +		})
 +	}
++
 +	modelReq := &models.RegisterFileRequest{
 +		FileID:      req.FileId,
 +		FileName:    req.FileName,
 +		FileSize:    req.FileSize,
 +		FileHash:    req.FileHash,
 +		Chunks:      chunks,
 +		OwnerNodeID: req.OwnerNodeId,
 +	}
++
 +	resp, err := s.coordinator.RegisterFile(ctx, modelReq)
 +	if err != nil {
 +		logrus.WithError(err).Error("Failed to register file")
 +		return nil, status.Errorf(codes.Internal, "Failed to register file: %v", err)
 +	}
++
 +	// Convert chunk placements
 +	var pbPlacements []*pb.ChunkPlacement
 +	for _, placement := range resp.ChunkPlacements {
 +		pbPlacements = append(pbPlacements, &pb.ChunkPlacement{
 +			ChunkId:           placement.ChunkID,
 +			TargetNodes:       placement.TargetNodes,
 +			ReplicationFactor: placement.ReplicationFactor,
 +		})
 +	}
++
 +	return &pb.RegisterFileResponse{
 +		Success:         resp.Success,
 +		Message:         resp.Message,
 +		ChunkPlacements: pbPlacements,
 +	}, nil
 +}
++
 +// GetFileInfo retrieves information about a specific file
 +func (s *CoordinatorServer) GetFileInfo(ctx context.Context, req *pb.GetFileInfoRequest) (*pb.GetFileInfoResponse, error) {
 +	logrus.WithField("fileID", req.FileId).Debug("Processing get file info request")
++
 +	modelReq := &models.GetFileInfoRequest{
 +		FileID: req.FileId,
 +	}
++
 +	resp, err := s.coordinator.GetFileInfo(ctx, modelReq)
 +	if err != nil {
 +		logrus.WithError(err).Error("Failed to get file info")
 +		return nil, status.Errorf(codes.Internal, "Failed to get file info: %v", err)
 +	}
++
 +	pbResp := &pb.GetFileInfoResponse{
 +		Success: resp.Success,
 +		Message: resp.Message,
 +	}
++
 +	if resp.FileInfo != nil {
 +		// Convert chunks
 +		var pbChunks []*pb.ChunkRecord
 +		for _, chunk := range resp.FileInfo.Chunks {
 +			pbChunks = append(pbChunks, &pb.ChunkRecord{
 +				ChunkId:          chunk.ChunkID,
 +				Hash:             chunk.Hash,
 +				Size:             chunk.Size,
 +				Index:            chunk.Index,
 +				StoredAtNodes:    chunk.StoredAtNodes,
 +				ReplicationCount: chunk.ReplicationCount,
 +			})
 +		}
++
 +		pbResp.FileInfo = &pb.FileRecord{
 +			FileId:       resp.FileInfo.FileID,
 +			FileName:     resp.FileInfo.FileName,
 +			FileSize:     resp.FileInfo.FileSize,
 +			FileHash:     resp.FileInfo.FileHash,
 +			Chunks:       pbChunks,
 +			OwnerNodeId:  resp.FileInfo.OwnerNodeID,
 +			CreatedAt:    resp.FileInfo.CreatedAt,
 +			LastAccessed: resp.FileInfo.LastAccessed,
 +		}
 +	}
++
 +	return pbResp, nil
 +}
++
 +// UpdateChunkLocations updates where chunks are stored
 +func (s *CoordinatorServer) UpdateChunkLocations(ctx context.Context, req *pb.UpdateChunkLocationsRequest) (*pb.UpdateChunkLocationsResponse, error) {
 +	logrus.WithFields(logrus.Fields{
 +		"chunkID":   req.ChunkId,
 +		"nodeIDs":   req.NodeIds,
 +		"operation": req.Operation,
 +	}).Debug("Processing chunk locations update")
++
 +	modelReq := &models.UpdateChunkLocationsRequest{
 +		ChunkID:   req.ChunkId,
 +		NodeIDs:   req.NodeIds,
 +		Operation: req.Operation,
 +	}
++
 +	resp, err := s.coordinator.UpdateChunkLocations(ctx, modelReq)
 +	if err != nil {
 +		logrus.WithError(err).Error("Failed to update chunk locations")
 +		return nil, status.Errorf(codes.Internal, "Failed to update chunk locations: %v", err)
 +	}
++
 +	return &pb.UpdateChunkLocationsResponse{
 +		Success: resp.Success,
 +		Message: resp.Message,
 +	}, nil
 +}
++
 +// FindChunkLocations finds nodes that store a specific chunk
 +func (s *CoordinatorServer) FindChunkLocations(ctx context.Context, req *pb.FindChunkLocationsRequest) (*pb.FindChunkLocationsResponse, error) {
 +	logrus.WithFields(logrus.Fields{
 +		"chunkID":        req.ChunkId,
 +		"preferredCount": req.PreferredCount,
 +	}).Debug("Processing find chunk locations request")
++
 +	modelReq := &models.FindChunkLocationsRequest{
 +		ChunkID:        req.ChunkId,
 +		PreferredCount: req.PreferredCount,
 +	}
++
 +	resp, err := s.coordinator.FindChunkLocations(ctx, modelReq)
 +	if err != nil {
 +		logrus.WithError(err).Error("Failed to find chunk locations")
 +		return nil, status.Errorf(codes.Internal, "Failed to find chunk locations: %v", err)
 +	}
++
 +	return &pb.FindChunkLocationsResponse{
 +		Success:       resp.Success,
 +		Message:       resp.Message,
 +		NodeIds:       resp.NodeIDs,
 +		NodeAddresses: resp.NodeAddresses,
 +	}, nil
 +}
++
 +// GetNetworkStatus returns current network status and statistics
 +func (s *CoordinatorServer) GetNetworkStatus(ctx context.Context, req *pb.GetNetworkStatusRequest) (*pb.GetNetworkStatusResponse, error) {
 +	logrus.Debug("Processing get network status request")
++
 +	resp, err := s.coordinator.GetNetworkStatus(ctx)
 +	if err != nil {
 +		logrus.WithError(err).Error("Failed to get network status")
 +		return nil, status.Errorf(codes.Internal, "Failed to get network status: %v", err)
 +	}
++
 +	// Convert network stats
 +	var pbNetworkStats *pb.NetworkStats
 +	if resp.NetworkStats != nil {
 +		pbNetworkStats = &pb.NetworkStats{
 +			TotalNodes:             resp.NetworkStats.TotalNodes,
 +			ActiveNodes:            resp.NetworkStats.ActiveNodes,
 +			TotalStorageCapacity:   resp.NetworkStats.TotalStorageCapacity,
 +			TotalStorageUsed:       resp.NetworkStats.TotalStorageUsed,
 +			TotalFiles:             resp.NetworkStats.TotalFiles,
 +			TotalChunks:            resp.NetworkStats.TotalChunks,
 +			AverageNodeUptime:      resp.NetworkStats.AverageNodeUptime,
 +			NetworkUptimeSeconds:   resp.NetworkStats.NetworkUptimeSeconds,
 +		}
 +	}
++
 +	// Convert active nodes
 +	var pbActiveNodes []*pb.NodeStatus
 +	for _, node := range resp.ActiveNodes {
 +		pbNode := &pb.NodeStatus{
 +			NodeId:        node.NodeID,
 +			Addresses:     node.Addresses,
 +			LastHeartbeat: node.LastHeartbeat,
 +			Status:        node.Status,
 +		}
++
 +		if node.Stats != nil {
 +			pbNode.Stats = &pb.NodeStats{
 +				StorageUsed:      node.Stats.StorageUsed,
 +				StorageAvailable: node.Stats.StorageAvailable,
 +				ChunksStored:     node.Stats.ChunksStored,
 +				BandwidthUp:      node.Stats.BandwidthUp,
 +				BandwidthDown:    node.Stats.BandwidthDown,
 +				CpuUsage:         node.Stats.CpuUsage,
 +				MemoryUsage:      node.Stats.MemoryUsage,
 +				UptimeSeconds:    node.Stats.UptimeSeconds,
 +			}
 +		}
++
 +		pbActiveNodes = append(pbActiveNodes, pbNode)
 +	}
++
 +	return &pb.GetNetworkStatusResponse{
 +		NetworkStats: pbNetworkStats,
 +		ActiveNodes:  pbActiveNodes,
 +		Timestamp:    resp.Timestamp,
 +	}, nil
 +}
++
 +// LoggingInterceptor provides request logging for gRPC calls
 +func LoggingInterceptor(ctx context.Context, req interface{}, info *grpc.UnaryServerInfo, handler grpc.UnaryHandler) (interface{}, error) {
 +	start := time.Now()
++
 +	// Call the handler
 +	resp, err := handler(ctx, req)
++
 +	// Log the request
 +	duration := time.Since(start)
 +	fields := logrus.Fields{
 +		"method":   info.FullMethod,
 +		"duration": duration,
 +	}
++
 +	if err != nil {
 +		fields["error"] = err.Error()
 +		logrus.WithFields(fields).Error("gRPC request failed")
 +	} else {
 +		// Only log at debug level for successful requests to avoid spam
 +		if duration > 100*time.Millisecond {
 +			logrus.WithFields(fields).Info("gRPC request (slow)")
 +		} else {
 +			logrus.WithFields(fields).Debug("gRPC request completed")
 +		}
 +	}
++
 +	return resp, err
 +}

internal/server/http.goadded

 +package server
++
 +import (
 +	"net/http"
 +	"strconv"
++
 +	"github.com/gin-gonic/gin"
 +	"github.com/sirupsen/logrus"
++
 +	"github.com/ZephyrFS/zephyrfs-coordinator/internal/coordinator"
 +	"github.com/ZephyrFS/zephyrfs-coordinator/internal/models"
 +)
++
 +// HTTPServer wraps the coordinator for HTTP API access
 +type HTTPServer struct {
 +	coordinator *coordinator.Coordinator
 +}
++
 +// NewHTTPServer creates a new HTTP server instance
 +func NewHTTPServer(coord *coordinator.Coordinator) *HTTPServer {
 +	return &HTTPServer{
 +		coordinator: coord,
 +	}
 +}
++
 +// SetupHTTPRoutes configures all HTTP API routes
 +func SetupHTTPRoutes(router *gin.Engine, coord *coordinator.Coordinator) {
 +	server := NewHTTPServer(coord)
++
 +	// Add middleware
 +	router.Use(server.loggingMiddleware())
 +	router.Use(server.corsMiddleware())
++
 +	// API versioning
 +	v1 := router.Group("/api/v1")
 +	{
 +		// Node management
 +		nodes := v1.Group("/nodes")
 +		{
 +			nodes.POST("/register", server.registerNode)
 +			nodes.POST("/:nodeId/unregister", server.unregisterNode)
 +			nodes.GET("/active", server.getActiveNodes)
 +			nodes.POST("/:nodeId/heartbeat", server.nodeHeartbeat)
 +			nodes.GET("/:nodeId", server.getNodeInfo)
 +		}
++
 +		// File management
 +		files := v1.Group("/files")
 +		{
 +			files.POST("/register", server.registerFile)
 +			files.GET("/:fileId", server.getFileInfo)
 +			files.DELETE("/:fileId", server.deleteFile)
 +			files.GET("", server.listFiles)
 +		}
++
 +		// Chunk management
 +		chunks := v1.Group("/chunks")
 +		{
 +			chunks.GET("/:chunkId/locations", server.findChunkLocations)
 +			chunks.PUT("/:chunkId/locations", server.updateChunkLocations)
 +			chunks.GET("/:chunkId", server.getChunkInfo)
 +		}
++
 +		// Network status and monitoring
 +		network := v1.Group("/network")
 +		{
 +			network.GET("/status", server.getNetworkStatus)
 +			network.GET("/stats", server.getNetworkStats)
 +		}
++
 +		// Admin endpoints
 +		admin := v1.Group("/admin")
 +		{
 +			admin.GET("/database/stats", server.getDatabaseStats)
 +			admin.POST("/database/backup", server.backupDatabase)
 +			admin.POST("/database/cleanup", server.cleanupDatabase)
 +		}
 +	}
++
 +	// Health check endpoint (no versioning)
 +	router.GET("/health", server.healthCheck)
 +	router.GET("/", server.apiInfo)
++
 +	logrus.Info("HTTP API routes configured")
 +}
++
 +// Health check endpoint
 +func (s *HTTPServer) healthCheck(c *gin.Context) {
 +	c.JSON(http.StatusOK, gin.H{
 +		"status":    "healthy",
 +		"service":   "zephyrfs-coordinator",
 +		"timestamp": gin.H{"unix": gin.H{}},
 +	})
 +}
++
 +// API information endpoint
 +func (s *HTTPServer) apiInfo(c *gin.Context) {
 +	c.JSON(http.StatusOK, gin.H{
 +		"service":     "ZephyrFS Coordinator",
 +		"version":     "1.0.0",
 +		"description": "Coordination server for ZephyrFS distributed storage network",
 +		"endpoints": gin.H{
 +			"health":       "/health",
 +			"api_v1":       "/api/v1",
 +			"nodes":        "/api/v1/nodes",
 +			"files":        "/api/v1/files",
 +			"chunks":       "/api/v1/chunks",
 +			"network":      "/api/v1/network",
 +			"admin":        "/api/v1/admin",
 +		},
 +	})
 +}
++
 +// Node management endpoints
++
 +func (s *HTTPServer) registerNode(c *gin.Context) {
 +	var req models.RegisterNodeRequest
 +	if err := c.ShouldBindJSON(&req); err != nil {
 +		c.JSON(http.StatusBadRequest, gin.H{"error": "Invalid request format", "details": err.Error()})
 +		return
 +	}
++
 +	resp, err := s.coordinator.RegisterNode(c.Request.Context(), &req)
 +	if err != nil {
 +		logrus.WithError(err).Error("Failed to register node via HTTP")
 +		c.JSON(http.StatusInternalServerError, gin.H{"error": "Failed to register node", "details": err.Error()})
 +		return
 +	}
++
 +	if resp.Success {
 +		c.JSON(http.StatusOK, resp)
 +	} else {
 +		c.JSON(http.StatusBadRequest, resp)
 +	}
 +}
++
 +func (s *HTTPServer) unregisterNode(c *gin.Context) {
 +	nodeID := c.Param("nodeId")
 +	if nodeID == "" {
 +		c.JSON(http.StatusBadRequest, gin.H{"error": "Node ID is required"})
 +		return
 +	}
++
 +	var reqBody struct {
 +		Reason string `json:"reason"`
 +	}
 +	c.ShouldBindJSON(&reqBody)
++
 +	req := &models.UnregisterNodeRequest{
 +		NodeID: nodeID,
 +		Reason: reqBody.Reason,
 +	}
++
 +	resp, err := s.coordinator.UnregisterNode(c.Request.Context(), req)
 +	if err != nil {
 +		logrus.WithError(err).Error("Failed to unregister node via HTTP")
 +		c.JSON(http.StatusInternalServerError, gin.H{"error": "Failed to unregister node", "details": err.Error()})
 +		return
 +	}
++
 +	c.JSON(http.StatusOK, resp)
 +}
++
 +func (s *HTTPServer) getActiveNodes(c *gin.Context) {
 +	limitStr := c.DefaultQuery("limit", "50")
 +	limit, err := strconv.Atoi(limitStr)
 +	if err != nil {
 +		c.JSON(http.StatusBadRequest, gin.H{"error": "Invalid limit parameter"})
 +		return
 +	}
++
 +	excludeNodes := c.QueryArray("exclude")
++
 +	req := &models.GetActiveNodesRequest{
 +		Limit:        int32(limit),
 +		ExcludeNodes: excludeNodes,
 +	}
++
 +	resp, err := s.coordinator.GetActiveNodes(c.Request.Context(), req)
 +	if err != nil {
 +		logrus.WithError(err).Error("Failed to get active nodes via HTTP")
 +		c.JSON(http.StatusInternalServerError, gin.H{"error": "Failed to get active nodes", "details": err.Error()})
 +		return
 +	}
++
 +	c.JSON(http.StatusOK, resp)
 +}
++
 +func (s *HTTPServer) nodeHeartbeat(c *gin.Context) {
 +	nodeID := c.Param("nodeId")
 +	if nodeID == "" {
 +		c.JSON(http.StatusBadRequest, gin.H{"error": "Node ID is required"})
 +		return
 +	}
++
 +	var reqBody struct {
 +		Stats *models.NodeStats `json:"stats"`
 +	}
 +	if err := c.ShouldBindJSON(&reqBody); err != nil {
 +		c.JSON(http.StatusBadRequest, gin.H{"error": "Invalid request format", "details": err.Error()})
 +		return
 +	}
++
 +	req := &models.NodeHeartbeatRequest{
 +		NodeID: nodeID,
 +		Stats:  reqBody.Stats,
 +	}
++
 +	resp, err := s.coordinator.NodeHeartbeat(c.Request.Context(), req)
 +	if err != nil {
 +		logrus.WithError(err).Error("Failed to process heartbeat via HTTP")
 +		c.JSON(http.StatusInternalServerError, gin.H{"error": "Failed to process heartbeat", "details": err.Error()})
 +		return
 +	}
++
 +	c.JSON(http.StatusOK, resp)
 +}
++
 +func (s *HTTPServer) getNodeInfo(c *gin.Context) {
 +	nodeID := c.Param("nodeId")
 +	if nodeID == "" {
 +		c.JSON(http.StatusBadRequest, gin.H{"error": "Node ID is required"})
 +		return
 +	}
++
 +	// Implementation would need to be added to coordinator
 +	c.JSON(http.StatusNotImplemented, gin.H{"error": "Not implemented yet"})
 +}
++
 +// File management endpoints
++
 +func (s *HTTPServer) registerFile(c *gin.Context) {
 +	var req models.RegisterFileRequest
 +	if err := c.ShouldBindJSON(&req); err != nil {
 +		c.JSON(http.StatusBadRequest, gin.H{"error": "Invalid request format", "details": err.Error()})
 +		return
 +	}
++
 +	resp, err := s.coordinator.RegisterFile(c.Request.Context(), &req)
 +	if err != nil {
 +		logrus.WithError(err).Error("Failed to register file via HTTP")
 +		c.JSON(http.StatusInternalServerError, gin.H{"error": "Failed to register file", "details": err.Error()})
 +		return
 +	}
++
 +	if resp.Success {
 +		c.JSON(http.StatusCreated, resp)
 +	} else {
 +		c.JSON(http.StatusBadRequest, resp)
 +	}
 +}
++
 +func (s *HTTPServer) getFileInfo(c *gin.Context) {
 +	fileID := c.Param("fileId")
 +	if fileID == "" {
 +		c.JSON(http.StatusBadRequest, gin.H{"error": "File ID is required"})
 +		return
 +	}
++
 +	req := &models.GetFileInfoRequest{
 +		FileID: fileID,
 +	}
++
 +	resp, err := s.coordinator.GetFileInfo(c.Request.Context(), req)
 +	if err != nil {
 +		logrus.WithError(err).Error("Failed to get file info via HTTP")
 +		c.JSON(http.StatusInternalServerError, gin.H{"error": "Failed to get file info", "details": err.Error()})
 +		return
 +	}
++
 +	if resp.Success {
 +		c.JSON(http.StatusOK, resp)
 +	} else {
 +		c.JSON(http.StatusNotFound, resp)
 +	}
 +}
++
 +func (s *HTTPServer) deleteFile(c *gin.Context) {
 +	fileID := c.Param("fileId")
 +	if fileID == "" {
 +		c.JSON(http.StatusBadRequest, gin.H{"error": "File ID is required"})
 +		return
 +	}
++
 +	// Implementation would need to be added to coordinator
 +	c.JSON(http.StatusNotImplemented, gin.H{"error": "Not implemented yet"})
 +}
++
 +func (s *HTTPServer) listFiles(c *gin.Context) {
 +	// Implementation would need to be added to coordinator
 +	c.JSON(http.StatusNotImplemented, gin.H{"error": "Not implemented yet"})
 +}
++
 +// Chunk management endpoints
++
 +func (s *HTTPServer) findChunkLocations(c *gin.Context) {
 +	chunkID := c.Param("chunkId")
 +	if chunkID == "" {
 +		c.JSON(http.StatusBadRequest, gin.H{"error": "Chunk ID is required"})
 +		return
 +	}
++
 +	preferredCountStr := c.DefaultQuery("preferred_count", "0")
 +	preferredCount, err := strconv.Atoi(preferredCountStr)
 +	if err != nil {
 +		c.JSON(http.StatusBadRequest, gin.H{"error": "Invalid preferred_count parameter"})
 +		return
 +	}
++
 +	req := &models.FindChunkLocationsRequest{
 +		ChunkID:        chunkID,
 +		PreferredCount: int32(preferredCount),
 +	}
++
 +	resp, err := s.coordinator.FindChunkLocations(c.Request.Context(), req)
 +	if err != nil {
 +		logrus.WithError(err).Error("Failed to find chunk locations via HTTP")
 +		c.JSON(http.StatusInternalServerError, gin.H{"error": "Failed to find chunk locations", "details": err.Error()})
 +		return
 +	}
++
 +	if resp.Success {
 +		c.JSON(http.StatusOK, resp)
 +	} else {
 +		c.JSON(http.StatusNotFound, resp)
 +	}
 +}
++
 +func (s *HTTPServer) updateChunkLocations(c *gin.Context) {
 +	chunkID := c.Param("chunkId")
 +	if chunkID == "" {
 +		c.JSON(http.StatusBadRequest, gin.H{"error": "Chunk ID is required"})
 +		return
 +	}
++
 +	var reqBody struct {
 +		NodeIDs   []string `json:"node_ids" binding:"required"`
 +		Operation string   `json:"operation" binding:"required"`
 +	}
 +	if err := c.ShouldBindJSON(&reqBody); err != nil {
 +		c.JSON(http.StatusBadRequest, gin.H{"error": "Invalid request format", "details": err.Error()})
 +		return
 +	}
++
 +	req := &models.UpdateChunkLocationsRequest{
 +		ChunkID:   chunkID,
 +		NodeIDs:   reqBody.NodeIDs,
 +		Operation: reqBody.Operation,
 +	}
++
 +	resp, err := s.coordinator.UpdateChunkLocations(c.Request.Context(), req)
 +	if err != nil {
 +		logrus.WithError(err).Error("Failed to update chunk locations via HTTP")
 +		c.JSON(http.StatusInternalServerError, gin.H{"error": "Failed to update chunk locations", "details": err.Error()})
 +		return
 +	}
++
 +	if resp.Success {
 +		c.JSON(http.StatusOK, resp)
 +	} else {
 +		c.JSON(http.StatusBadRequest, resp)
 +	}
 +}
++
 +func (s *HTTPServer) getChunkInfo(c *gin.Context) {
 +	chunkID := c.Param("chunkId")
 +	if chunkID == "" {
 +		c.JSON(http.StatusBadRequest, gin.H{"error": "Chunk ID is required"})
 +		return
 +	}
++
 +	// Implementation would need to be added to coordinator
 +	c.JSON(http.StatusNotImplemented, gin.H{"error": "Not implemented yet"})
 +}
++
 +// Network status endpoints
++
 +func (s *HTTPServer) getNetworkStatus(c *gin.Context) {
 +	resp, err := s.coordinator.GetNetworkStatus(c.Request.Context())
 +	if err != nil {
 +		logrus.WithError(err).Error("Failed to get network status via HTTP")
 +		c.JSON(http.StatusInternalServerError, gin.H{"error": "Failed to get network status", "details": err.Error()})
 +		return
 +	}
++
 +	c.JSON(http.StatusOK, resp)
 +}
++
 +func (s *HTTPServer) getNetworkStats(c *gin.Context) {
 +	// Simplified version that returns just the network stats
 +	resp, err := s.coordinator.GetNetworkStatus(c.Request.Context())
 +	if err != nil {
 +		logrus.WithError(err).Error("Failed to get network stats via HTTP")
 +		c.JSON(http.StatusInternalServerError, gin.H{"error": "Failed to get network stats", "details": err.Error()})
 +		return
 +	}
++
 +	c.JSON(http.StatusOK, resp.NetworkStats)
 +}
++
 +// Admin endpoints
++
 +func (s *HTTPServer) getDatabaseStats(c *gin.Context) {
 +	// Implementation would need database stats access
 +	c.JSON(http.StatusNotImplemented, gin.H{"error": "Not implemented yet"})
 +}
++
 +func (s *HTTPServer) backupDatabase(c *gin.Context) {
 +	// Implementation would need backup functionality
 +	c.JSON(http.StatusNotImplemented, gin.H{"error": "Not implemented yet"})
 +}
++
 +func (s *HTTPServer) cleanupDatabase(c *gin.Context) {
 +	// Implementation would need cleanup functionality
 +	c.JSON(http.StatusNotImplemented, gin.H{"error": "Not implemented yet"})
 +}
++
 +// Middleware
++
 +func (s *HTTPServer) loggingMiddleware() gin.HandlerFunc {
 +	return gin.LoggerWithFormatter(func(param gin.LogFormatterParams) string {
 +		logrus.WithFields(logrus.Fields{
 +			"method":     param.Method,
 +			"path":       param.Path,
 +			"status":     param.StatusCode,
 +			"latency":    param.Latency,
 +			"ip":         param.ClientIP,
 +			"user_agent": param.Request.UserAgent(),
 +		}).Info("HTTP request")
 +		return ""
 +	})
 +}
++
 +func (s *HTTPServer) corsMiddleware() gin.HandlerFunc {
 +	return func(c *gin.Context) {
 +		c.Header("Access-Control-Allow-Origin", "*")
 +		c.Header("Access-Control-Allow-Methods", "GET, POST, PUT, PATCH, DELETE, OPTIONS")
 +		c.Header("Access-Control-Allow-Headers", "Origin, Content-Type, Accept, Authorization, X-Requested-With")
 +		c.Header("Access-Control-Allow-Credentials", "true")
++
 +		if c.Request.Method == "OPTIONS" {
 +			c.AbortWithStatus(http.StatusNoContent)
 +			return
 +		}
++
 +		c.Next()
 +	}
 +}