// usePolling.js
import { useEffect, useRef } from 'react';

export function usePolling(callback, intervalMs = 30_000) {
  const callbackRef = useRef(callback);

  useEffect(() => {
    callbackRef.current = callback;
  });

  useEffect(() => {
    callbackRef.current(); // 마운트 시 즉시 1회 실행

    const id = setInterval(() => callbackRef.current(), intervalMs);
    return () => clearInterval(id);
  }, [intervalMs]);
}

// App.jsx
const [vms, setVms] = useState([]);
const [loading, setLoading] = useState(true);

usePolling(async () => {
  const data = await fetch('/api/vms').then(r => r.json());
  setVms(data);
  setLoading(false);
}, 30_000);

// VmTable.jsx
const STATUS_BADGE = {
  ONLINE:  { label: 'ONLINE',  className: 'badge-green'  },
  OFFLINE: { label: 'OFFLINE', className: 'badge-red'    },
  UNKNOWN: { label: 'UNKNOWN', className: 'badge-gray'   },
};

export function VmTable({ vms, filter }) {
  const filtered = useMemo(() => {
    return vms.filter(vm => {
      if (filter.status && vm.status !== filter.status) return false;
      if (filter.team && vm.teamId !== filter.team) return false;
      if (filter.search) {
        const q = filter.search.toLowerCase();
        return (
          vm.hostname?.toLowerCase().includes(q) ||
          vm.currentIp?.includes(q)
        );
      }
      return true;
    });
  }, [vms, filter]);

  return (
    <table className="vm-table">
      <thead>
        <tr>
          <th>호스트명</th>
          <th>IP</th>
          <th>팀</th>
          <th>상태</th>
          <th>마지막 heartbeat</th>
          <th>에이전트 버전</th>
        </tr>
      </thead>
      <tbody>
        {filtered.map(vm => {
          const badge = STATUS_BADGE[vm.status] ?? STATUS_BADGE.UNKNOWN;
          return (
            <tr key={vm.id}>
              <td>{vm.hostname}</td>
              <td><code>{vm.currentIp}</code></td>
              <td>{vm.teamName ?? '-'}</td>
              <td><span className={`badge ${badge.className}`}>{badge.label}</span></td>
              <td>{formatRelative(vm.lastSeenAt)}</td>
              <td>{vm.agentVersion}</td>
            </tr>
          );
        })}
      </tbody>
    </table>
  );
}

// EventLogPanel.jsx
const SEVERITY_CLASS = {
  CRITICAL: 'event-critical',
  WARNING:  'event-warning',
  INFO:     'event-info',
};

const EVENT_ICON = {
  IP_CONFLICT:    '🔴',
  IP_CHANGED:     '🔄',
  IP_OUT_OF_RANGE:'⚠️',
  VM_OFFLINE:     '🔴',
  VM_ONLINE:      '🟢',
};

export function EventLogPanel({ events }) {
  return (
    <div className="event-log">
      {events.map(evt => (
        <div key={evt.id} className={`event-item ${SEVERITY_CLASS[evt.severity]}`}>
          <span className="event-icon">{EVENT_ICON[evt.eventType]}</span>
          <span className="event-time">{formatDate(evt.createdAt)}</span>
          <span className="event-msg">{evt.message}</span>
        </div>
      ))}
    </div>
  );
}

/* App.css */
:root {
  --bg: #ffffff;
  --surface: #f8f9fa;
  --text: #1a1a1a;
  --border: #e0e0e0;
  --badge-green: #22c55e;
  --badge-red: #ef4444;
  --badge-gray: #9ca3af;
}

[data-theme="dark"] {
  --bg: #0f172a;
  --surface: #1e293b;
  --text: #e2e8f0;
  --border: #334155;
}

// App.jsx
const [theme, setTheme] = useState(
  () => localStorage.getItem('ipam-theme') || 'light'
);

useEffect(() => {
  document.documentElement.setAttribute('data-theme', theme);
  localStorage.setItem('ipam-theme', theme);
}, [theme]);

server {
    listen 80;
    root /usr/share/nginx/html;
    index index.html;

    location /api/ {
        proxy_pass http://app:8080;
        proxy_set_header Host $host;
        proxy_set_header X-Real-IP $remote_addr;
    }

    location / {
        try_files $uri $uri/ /index.html;
    }
}

services:
  postgres:
    image: postgres:16-alpine
    container_name: ipam-postgres
    environment:
      POSTGRES_DB: ipam
      POSTGRES_USER: ipam
      POSTGRES_PASSWORD: ipam1234
    volumes:
      - ./data/postgres:/var/lib/postgresql/data
      - ./sql/init.sql:/docker-entrypoint-initdb.d/init.sql
    healthcheck:
      test: ["CMD-SHELL", "pg_isready -U ipam -d ipam"]
      interval: 5s
      timeout: 5s
      retries: 10

  redis:
    image: redis:7-alpine
    container_name: ipam-redis
    healthcheck:
      test: ["CMD", "redis-cli", "ping"]
      interval: 5s
      timeout: 3s
      retries: 5

  app:
    build: ./backend
    container_name: ipam-app
    ports:
      - "8080:8080"
    environment:
      DB_HOST: postgres
      DB_NAME: ipam
      DB_USER: ipam
      DB_PASS: ipam1234
      REDIS_HOST: redis
      SLACK_WEBHOOK_URL: ${SLACK_WEBHOOK_URL:-}
    depends_on:
      postgres:
        condition: service_healthy
      redis:
        condition: service_healthy
    healthcheck:
      test: ["CMD-SHELL", "curl -f http://localhost:8080/actuator/health || exit 1"]
      interval: 10s
      timeout: 5s
      retries: 12
    restart: unless-stopped

  frontend:
    build: ./frontend
    container_name: ipam-frontend
    ports:
      - "3000:80"
    depends_on:
      app:
        condition: service_healthy
    restart: unless-stopped

# 빌드 스테이지
FROM maven:3.9-eclipse-temurin-21 AS build
WORKDIR /app
COPY pom.xml .
RUN mvn dependency:go-offline -q
COPY src ./src
RUN mvn package -DskipTests -q

# 실행 스테이지
FROM eclipse-temurin:21-jre-alpine
WORKDIR /app
COPY --from=build /app/target/*.jar app.jar
EXPOSE 8080
ENTRYPOINT ["java", "-jar", "app.jar"]

FROM node:20-alpine AS build
WORKDIR /app
COPY package*.json ./
RUN npm ci --silent
COPY . .
RUN npm run build

FROM nginx:alpine
COPY --from=build /app/dist /usr/share/nginx/html
COPY nginx.conf /etc/nginx/conf.d/default.conf
EXPOSE 80
CMD ["nginx", "-g", "daemon off;"]

# 환경변수 파일 작성
cat > .env << EOF
SLACK_WEBHOOK_URL=https://hooks.slack.com/services/...
EOF

# 최초 배포
cd ipam-system
docker compose up -d --build

# 로그 확인
docker logs ipam-app -f
docker logs ipam-frontend -f

# 백엔드만 재배포
docker compose up -d --build app

# 프론트엔드만 재배포
docker compose up -d --build frontend

# 실패
test: ["CMD", "curl", "-f", "http://localhost:8080/actuator/health"]

# 해결: CMD-SHELL로 변경 (sh -c 경유)
test: ["CMD-SHELL", "curl -f http://localhost:8080/actuator/health || exit 1"]

# 볼륨 삭제 후 재시작 (데이터 초기화 주의)
docker compose down -v
docker compose up -d --build

@Service
@RequiredArgsConstructor
@Transactional
public class HeartbeatService {

    private final VmRepository vmRepo;
    private final AnomalyDetectorService anomalyDetector;

    public void process(HeartbeatRequest req) {
        Vm vm = vmRepo.findByMacAddress(req.getMacAddress())
            .orElseGet(() -> vmRepo.save(Vm.create(
                req.getMacAddress(),
                req.getHostname(),
                req.getAgentVersion()
            )));

        vm.heartbeat(req.getHostname(), req.getAgentVersion());
        anomalyDetector.detectAndUpdate(vm, req.getNetworkInterfaces());
    }
}

// Vm.java (Entity)
public void heartbeat(String hostname, String agentVersion) {
    this.hostname = hostname;
    this.agentVersion = agentVersion;
    this.lastSeenAt = Instant.now();
    
    if (this.status == VmStatus.OFFLINE) {
        this.status = VmStatus.ONLINE;
        // VM_ONLINE 이벤트는 AnomalyDetector에서 처리
    } else {
        this.status = VmStatus.ONLINE;
    }
}

@Service
@RequiredArgsConstructor
public class AnomalyDetectorService {

    private final NetworkInfoRepository nicRepo;
    private final EventLogRepository eventRepo;
    private final IpPoolRepository ipPoolRepo;
    private final VmRepository vmRepo;
    private final SlackNotifierService slack;

    @Transactional
    public void detectAndUpdate(Vm vm, List<NicInfo> incomingNics) {
        for (NicInfo nic : incomingNics) {
            String newIp = nic.getIpAddress();

            // 1. IP 변경 감지
            NetworkInfo existing = nicRepo.findByMacAddress(nic.getMacAddress()).orElse(null);
            if (existing != null && !existing.getIpAddress().equals(newIp)) {
                saveEvent(vm, EventType.IP_CHANGED, Severity.WARNING,
                    String.format("%s IP 변경: %s → %s", vm.getHostname(), existing.getIpAddress(), newIp),
                    Map.of("oldIp", existing.getIpAddress(), "newIp", newIp));
                slack.notify(EventType.IP_CHANGED, vm, Map.of("oldIp", existing.getIpAddress(), "newIp", newIp));
            }

            // 2. IP 충돌 감지
            List<Vm> conflictVms = vmRepo.findByCurrentIpAndIdNot(newIp, vm.getId());
            if (!conflictVms.isEmpty()) {
                String conflictNames = conflictVms.stream()
                    .map(Vm::getHostname).collect(Collectors.joining(", "));
                saveEvent(vm, EventType.IP_CONFLICT, Severity.CRITICAL,
                    String.format("IP 충돌: %s ← %s 외 %s", newIp, vm.getHostname(), conflictNames),
                    Map.of("conflictWith", conflictNames));
                slack.notify(EventType.IP_CONFLICT, vm, Map.of("ip", newIp, "conflictWith", conflictNames));
            }

            // 3. IP 대역 이탈 감지
            if (!isInAllowedRange(newIp, vm.getTeamId())) {
                saveEvent(vm, EventType.IP_OUT_OF_RANGE, Severity.WARNING,
                    String.format("%s IP 대역 이탈: %s", vm.getHostname(), newIp),
                    Map.of("ip", newIp));
                slack.notify(EventType.IP_OUT_OF_RANGE, vm, Map.of("ip", newIp));
            }

            // NIC 정보 갱신
            nicRepo.save(nic.toEntity(vm));
            vm.setCurrentIp(newIp);
        }
    }

    private boolean isInAllowedRange(String ip, Long teamId) {
        List<IpPool> pools = ipPoolRepo.findByTeamId(teamId);
        if (pools.isEmpty()) return true; // 대역 설정 없으면 허용
        return pools.stream().anyMatch(pool -> pool.contains(ip));
    }

    private void saveEvent(Vm vm, EventType type, Severity severity, String message, Map<String, Object> detail) {
        eventRepo.save(EventLog.builder()
            .vm(vm)
            .eventType(type)
            .severity(severity)
            .message(message)
            .detail(detail)
            .build());
    }
}

@Service
@RequiredArgsConstructor
public class OfflineSchedulerService {

    private final VmRepository vmRepo;
    private final EventLogRepository eventRepo;
    private final SlackNotifierService slack;

    @Value("${ipam.offline.threshold-minutes:10}")
    private int thresholdMinutes;

    @Scheduled(fixedDelayString = "${ipam.offline.check-interval-ms:120000}")
    @Transactional
    public void checkOfflineVms() {
        Instant threshold = Instant.now().minus(thresholdMinutes, ChronoUnit.MINUTES);

        List<Vm> candidates = vmRepo.findByStatusAndLastSeenAtBefore(VmStatus.ONLINE, threshold);
        for (Vm vm : candidates) {
            vm.setStatus(VmStatus.OFFLINE);
            eventRepo.save(EventLog.builder()
                .vm(vm)
                .eventType(EventType.VM_OFFLINE)
                .severity(Severity.WARNING)
                .message(String.format("%s 오프라인 — 마지막 heartbeat: %s", vm.getHostname(), vm.getLastSeenAt()))
                .build());
            slack.notify(EventType.VM_OFFLINE, vm, Map.of());
        }
    }
}

ipam:
  offline:
    threshold-minutes: 10
    check-interval-ms: 120000

@Service
@RequiredArgsConstructor
public class SlackNotifierService {

    private final StringRedisTemplate redis;
    private final WebClient webClient;

    @Value("${ipam.slack.webhook-url:}")
    private String webhookUrl;

    @Value("${ipam.slack.dedup-ttl:30}")
    private int dedupTtlMinutes;

    public void notify(EventType type, Vm vm, Map<String, Object> detail) {
        if (webhookUrl.isBlank()) return;

        String dedupKey = String.format("slack:dedup:%s:%d", type.name(), vm.getId());

        // 30분 내에 같은 이벤트가 발송됐으면 스킵
        Boolean isNew = redis.opsForValue().setIfAbsent(
            dedupKey, "1", Duration.ofMinutes(dedupTtlMinutes)
        );
        if (!Boolean.TRUE.equals(isNew)) return;

        String message = buildMessage(type, vm, detail);
        sendAsync(message);
    }

    private String buildMessage(EventType type, Vm vm, Map<String, Object> detail) {
        return switch (type) {
            case IP_CONFLICT  -> String.format(":rotating_light: *IP 충돌* — `%s` (%s)\n충돌 VM: %s",
                detail.get("ip"), vm.getHostname(), detail.get("conflictWith"));
            case IP_CHANGED   -> String.format(":arrows_counterclockwise: *IP 변경* — `%s`\n`%s` → `%s`",
                vm.getHostname(), detail.get("oldIp"), detail.get("newIp"));
            case IP_OUT_OF_RANGE -> String.format(":warning: *IP 대역 이탈* — `%s` (%s)",
                vm.getHostname(), detail.get("ip"));
            case VM_OFFLINE   -> String.format(":red_circle: *VM 오프라인* — `%s`\n마지막 heartbeat: %s",
                vm.getHostname(), vm.getLastSeenAt());
            case VM_ONLINE    -> String.format(":large_green_circle: *VM 복귀* — `%s`", vm.getHostname());
        };
    }

    private void sendAsync(String message) {
        webClient.post()
            .uri(webhookUrl)
            .bodyValue(Map.of("text", message))
            .retrieve()
            .toBodilessEntity()
            .subscribe(
                r -> {},
                e -> System.err.println("[Slack] 발송 실패: " + e.getMessage())
            );
    }
}

// HeartbeatService.java
public void process(HeartbeatRequest req) {
    Vm vm = vmRepo.findByMacAddress(req.getMacAddress())
        .orElseGet(() -> vmRepo.save(Vm.create(...)));

    boolean wasOffline = vm.getStatus() == VmStatus.OFFLINE;
    vm.heartbeat(req.getHostname(), req.getAgentVersion());

    if (wasOffline) {
        eventRepo.save(EventLog.builder()
            .vm(vm)
            .eventType(EventType.VM_ONLINE)
            .severity(Severity.INFO)
            .message(String.format("%s 복귀", vm.getHostname()))
            .build());
        slack.notify(EventType.VM_ONLINE, vm, Map.of());
    }

    anomalyDetector.detectAndUpdate(vm, req.getNetworkInterfaces());
}

spring:
  datasource:
    url: jdbc:postgresql://${DB_HOST:localhost}:5432/${DB_NAME:ipam}
    username: ${DB_USER:ipam}
    password: ${DB_PASS:ipam1234}
  jpa:
    hibernate:
      ddl-auto: validate
    show-sql: false
  data:
    redis:
      host: ${REDIS_HOST:localhost}
      port: 6379

ipam:
  offline:
    threshold-minutes: 10
    check-interval-ms: 120000
  slack:
    webhook-url: ${SLACK_WEBHOOK_URL:}
    dedup-ttl: 30

@GetMapping("/api/events")
public Page<EventLogDto> getEvents(
    @RequestParam(required = false) String eventType,
    @RequestParam(required = false) String severity,
    @RequestParam(defaultValue = "0") int page,
    @RequestParam(defaultValue = "50") int size
) {
    Pageable pageable = PageRequest.of(page, size, Sort.by("createdAt").descending());
    return eventRepo.findByFilters(eventType, severity, pageable)
        .map(EventLogDto::from);
}

// 버그: 자기 자신도 포함됨
List<Vm> conflictVms = vmRepo.findByCurrentIp(newIp);

// 수정: 자기 자신 제외
List<Vm> conflictVms = vmRepo.findByCurrentIpAndIdNot(newIp, vm.getId());

Boolean isNew;
try {
    isNew = redis.opsForValue().setIfAbsent(dedupKey, "1", Duration.ofMinutes(dedupTtlMinutes));
} catch (Exception e) {
    // Redis 장애 시 dedup 없이 발송
    isNew = true;
}
if (!Boolean.TRUE.equals(isNew)) return;

const axios = require('axios');
const os = require('os');

const SERVER_URL = process.env.IPAM_SERVER_URL;
const INTERVAL_MS = 30_000;

function getNics() {
  const interfaces = os.networkInterfaces();
  const result = [];

  for (const [name, addrs] of Object.entries(interfaces)) {
    for (const addr of addrs) {
      if (addr.family === 'IPv4' && !addr.internal) {
        result.push({
          interfaceName: name,
          macAddress: addr.mac,
          ipAddress: addr.address,
        });
      }
    }
  }
  return result;
}

async function sendHeartbeat() {
  try {
    await axios.post(`${SERVER_URL}/api/heartbeat`, {
      hostname: os.hostname(),
      networkInterfaces: getNics(),
    });
  } catch (e) {
    console.error('[heartbeat] 실패:', e.message);
  }
}

sendHeartbeat();
setInterval(sendHeartbeat, INTERVAL_MS);

{
  "scripts": {
    "build": "pkg src/index.js --target node18-win-x64 --output dist/ipam-agent.exe"
  }
}

package main

import (
    "bytes"
    "encoding/json"
    "fmt"
    "net"
    "net/http"
    "os"
    "time"
)

const (
    agentVersion = "1.0.0"
    intervalSec  = 30
)

type NicInfo struct {
    InterfaceName string `json:"interfaceName"`
    MacAddress    string `json:"macAddress"`
    IpAddress     string `json:"ipAddress"`
}

type HeartbeatPayload struct {
    MacAddress        string    `json:"macAddress"`
    Hostname          string    `json:"hostname"`
    AgentVersion      string    `json:"agentVersion"`
    NetworkInterfaces []NicInfo `json:"networkInterfaces"`
}

func getNics() []NicInfo {
    ifaces, _ := net.Interfaces()
    var result []NicInfo

    for _, iface := range ifaces {
        // 루프백 제외
        if iface.Flags&net.FlagLoopback != 0 {
            continue
        }
        addrs, _ := iface.Addrs()
        for _, addr := range addrs {
            var ip net.IP
            switch v := addr.(type) {
            case *net.IPNet:
                ip = v.IP
            case *net.IPAddr:
                ip = v.IP
            }
            // IPv4만, 링크로컬 제외
            if ip == nil || ip.IsLinkLocalUnicast() || ip.To4() == nil {
                continue
            }
            result = append(result, NicInfo{
                InterfaceName: iface.Name,
                MacAddress:    iface.HardwareAddr.String(),
                IpAddress:     ip.String(),
            })
        }
    }
    return result
}

func sendHeartbeat(serverURL string) {
    nics := getNics()
    if len(nics) == 0 {
        fmt.Println("[heartbeat] NIC 없음, 스킵")
        return
    }

    payload := HeartbeatPayload{
        MacAddress:        nics[0].MacAddress,
        Hostname:          getHostname(),
        AgentVersion:      agentVersion,
        NetworkInterfaces: nics,
    }

    body, _ := json.Marshal(payload)
    resp, err := http.Post(serverURL+"/api/heartbeat", "application/json", bytes.NewReader(body))
    if err != nil {
        fmt.Printf("[heartbeat] 실패: %v\n", err)
        return
    }
    defer resp.Body.Close()
    fmt.Printf("[heartbeat] %s → %d\n", time.Now().Format("15:04:05"), resp.StatusCode)
}

func getHostname() string {
    h, err := os.Hostname()
    if err != nil {
        return "unknown"
    }
    return h
}

func main() {
    serverURL := os.Getenv("IPAM_SERVER_URL")
    if serverURL == "" {
        fmt.Println("[에이전트] IPAM_SERVER_URL 환경변수가 설정되지 않았습니다.")
        os.Exit(1)
    }

    fmt.Printf("[에이전트] 시작 — 서버: %s\n", serverURL)
    sendHeartbeat(serverURL)

    ticker := time.NewTicker(intervalSec * time.Second)
    for range ticker.C {
        sendHeartbeat(serverURL)
    }
}

go build -ldflags="-s -w" -o ipam-agent.exe .

# Linux에서 Windows 64비트 빌드
GOOS=windows GOARCH=amd64 go build -ldflags="-s -w" -o ipam-agent.exe .

# Linux용 빌드
GOOS=linux GOARCH=amd64 go build -ldflags="-s -w" -o ipam-agent .

# ARM (Raspberry Pi 등)
GOOS=linux GOARCH=arm64 go build -ldflags="-s -w" -o ipam-agent-arm64 .

nssm install IpamAgent "C:\ipam-agent.exe"
nssm set IpamAgent AppEnvironmentExtra "IPAM_SERVER_URL=http://ipam-server:8080"
nssm start IpamAgent

# /etc/systemd/system/ipam-agent.service
[Unit]
Description=IPAM Agent
After=network.target

[Service]
ExecStart=/usr/local/bin/ipam-agent
Environment=IPAM_SERVER_URL=http://ipam-server:8080
Restart=always
RestartSec=5

[Install]
WantedBy=multi-user.target

sudo systemctl enable --now ipam-agent

module ipam-agent

go 1.22

CREATE TABLE team (
    id          SERIAL PRIMARY KEY,
    name        VARCHAR(100) NOT NULL,
    description TEXT,
    created_at  TIMESTAMPTZ DEFAULT NOW()
);

CREATE TABLE vm (
    id              SERIAL PRIMARY KEY,
    mac_address     VARCHAR(17) UNIQUE NOT NULL,
    hostname        VARCHAR(255),
    current_ip      VARCHAR(15),
    team_id         INTEGER REFERENCES team(id),
    status          VARCHAR(20) DEFAULT 'UNKNOWN',
    agent_version   VARCHAR(50),
    last_seen_at    TIMESTAMPTZ,
    created_at      TIMESTAMPTZ DEFAULT NOW(),
    updated_at      TIMESTAMPTZ DEFAULT NOW()
);

CREATE TABLE network_info (
    id              SERIAL PRIMARY KEY,
    vm_id           INTEGER REFERENCES vm(id),
    interface_name  VARCHAR(50),
    mac_address     VARCHAR(17),
    ip_address      VARCHAR(15),
    updated_at      TIMESTAMPTZ DEFAULT NOW()
);

CREATE TABLE ip_history (
    id          SERIAL PRIMARY KEY,
    vm_id       INTEGER REFERENCES vm(id),
    old_ip      VARCHAR(15),
    new_ip      VARCHAR(15),
    changed_at  TIMESTAMPTZ DEFAULT NOW()
);

CREATE TABLE event_log (
    id           SERIAL PRIMARY KEY,
    vm_id        INTEGER REFERENCES vm(id),
    event_type   VARCHAR(50) NOT NULL,
    severity     VARCHAR(20) NOT NULL,
    message      TEXT,
    detail       JSONB,
    created_at   TIMESTAMPTZ DEFAULT NOW()
);

CREATE TABLE ip_pool (
    id          SERIAL PRIMARY KEY,
    cidr        VARCHAR(18) NOT NULL,
    description TEXT,
    team_id     INTEGER REFERENCES team(id),
    created_at  TIMESTAMPTZ DEFAULT NOW()
);