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()
);