projekte/edgeguard-native
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

feat: Network/IP-Verwaltung + Mailguard-Design-Übernahme

Browse Source 
Backend:
* Migration 0009_networks: network_interfaces (ethernet|vlan|bond|
  bridge|wireguard, role wan|lan|dmz|mgmt|cluster, parent + vlan_id
  für VLANs) + ip_addresses (interface_id FK, address+prefix, is_vip
  + vip_priority für Cluster-Failover-VIPs).
* Repos services/networkifs + services/ipaddresses + Models +
  Handler /api/v1/network-interfaces (CRUD + /:id/ip-addresses)
  und /api/v1/ip-addresses (CRUD).
* /api/v1/system/interfaces refactored auf Go-natives net.Interfaces()
  statt `ip -j addr show` shell-out — die systemd-Sandbox blockt
  AF_NETLINK auch für Go's runtime, deswegen edgeguard-api.service
  RestrictAddressFamilies um AF_NETLINK ergänzt. Output-Shape
  bleibt identisch (ifindex, ifname, flags[], mtu, link_type,
  address, addr_info[]) — Frontend muss nicht angepasst werden.

Frontend:
* Networks-Page (/networks): "System-discovered Interfaces"
  read-only Tags-Card oben, deklarierte Interfaces unten als
  Tabelle mit Modal-CRUD; Type-Switch zeigt parent+vlan_id-Felder
  bei type=vlan; Role-Tags farbig (wan blau, lan grün, dmz orange,
  mgmt purple, cluster magenta).
* IPAddresses-Page (/ip-addresses): Tabelle pro Interface, VIP-
  Toggle blendet vip_priority-Eingabe ein. Goldenes VIP-Tag in der
  Liste.
* Sidebar erweitert um Networks + IP-Adressen + section-grouping.

Design 1:1 von mail-gateway/management-ui/ übernommen:
* enterprise.css verbatim (Inter-Font via Google CDN statt local
  woff2), Sidebar 240px dunkler Gradient #0B1426→#101D33→#0D1829,
  branding-accent #1677ff für Active-State, abgerundete Cards mit
  shadow-Token, Header weiß mit subtilem backdrop-filter.
* AntD-Theme-Tokens: colorPrimary #0EA5E9, fontSize 13, fontFamily
  'Inter', controlHeight 34, borderRadius 6.
* Layout-Komponenten neu strukturiert: AppLayout/Sidebar/Header
  matchen mailguard-Klassen-Naming (.app-layout, .main-content,
  .sidebar-section, .sidebar-menu-item.active, .header-left, …).
* Sidebar mit 4 Sektionen (Übersicht / Routing / Netzwerk / System)
  + Logo-Header + Versions-Footer.

Live-deployed auf 89.163.205.6: Networks-Endpoint listet eth0
(89.163.205.6/24, MAC bc:24:11:64:29:e8) + lo, frontend zeigt sie
als System-Tags in der Networks-Page.

Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com>
This commit is contained in:
Debian
2026-05-09 16:08:44 +02:00
parent f0589e5628
commit ca03e69637
21 changed files with 4115 additions and 87 deletions
Download Patch File Download Diff File Expand all files Collapse all files

72
internal/database/migrations/0009_networks.sql Normal file
View File

@@ -0,0 +1,72 @@
-- +goose Up
-- +goose StatementBegin
-- Network interfaces declared by the operator. The kernel-side
-- interfaces (eth0, eth1, ...) appear here via "discovery" — same
-- name as the OS device. VLAN/bond/bridge interfaces are operator-
-- created and the runtime renderer (Phase-3) will translate them
-- into /etc/systemd/network/*.network files.
--
-- role drives where the firewall/HAProxy generators expect this
-- interface to live: 'wan' = public-facing, 'lan' = internal,
-- 'dmz' = quarantined, 'mgmt' = admin-only, 'cluster' = peer-mTLS.
CREATE TABLE IF NOT EXISTS network_interfaces (
id BIGSERIAL PRIMARY KEY,
name TEXT NOT NULL,
type TEXT NOT NULL DEFAULT 'ethernet',
parent TEXT,
vlan_id INTEGER,
role TEXT NOT NULL DEFAULT 'lan',
mtu INTEGER,
active BOOLEAN NOT NULL DEFAULT TRUE,
description TEXT,
created_at TIMESTAMPTZ NOT NULL DEFAULT NOW(),
updated_at TIMESTAMPTZ NOT NULL DEFAULT NOW(),
CONSTRAINT network_interfaces_name_unique UNIQUE (name),
CONSTRAINT network_interfaces_type_check CHECK (type IN ('ethernet', 'vlan', 'bond', 'bridge', 'wireguard')),
CONSTRAINT network_interfaces_role_check CHECK (role IN ('wan', 'lan', 'dmz', 'mgmt', 'cluster')),
CONSTRAINT network_interfaces_vlan_check CHECK (
(type = 'vlan' AND vlan_id BETWEEN 1 AND 4094 AND parent IS NOT NULL)
OR (type <> 'vlan')
)
);
CREATE INDEX IF NOT EXISTS idx_network_interfaces_role ON network_interfaces (role);
CREATE INDEX IF NOT EXISTS idx_network_interfaces_active ON network_interfaces (active) WHERE active;
-- IP addresses bound to a declared interface.
--
-- is_vip flags addresses that should follow the cluster's active
-- node (Phase-3 floating-IP / VRRP-via-hoster-API logic). vip_priority
-- gives the failover preference (higher wins); ignored for non-VIP
-- rows.
--
-- The same address can live on the same interface only once
-- (UNIQUE), but the same address may legitimately appear on
-- different interfaces (e.g. as anycast endpoint).
CREATE TABLE IF NOT EXISTS ip_addresses (
id BIGSERIAL PRIMARY KEY,
interface_id BIGINT NOT NULL REFERENCES network_interfaces(id) ON DELETE CASCADE,
address TEXT NOT NULL,
prefix INTEGER NOT NULL,
is_vip BOOLEAN NOT NULL DEFAULT FALSE,
vip_priority INTEGER,
description TEXT,
active BOOLEAN NOT NULL DEFAULT TRUE,
created_at TIMESTAMPTZ NOT NULL DEFAULT NOW(),
updated_at TIMESTAMPTZ NOT NULL DEFAULT NOW(),
CONSTRAINT ip_addresses_iface_addr_unique UNIQUE (interface_id, address),
CONSTRAINT ip_addresses_prefix_check CHECK (prefix BETWEEN 0 AND 128)
);
CREATE INDEX IF NOT EXISTS idx_ip_addresses_iface ON ip_addresses (interface_id);
CREATE INDEX IF NOT EXISTS idx_ip_addresses_vip ON ip_addresses (is_vip) WHERE is_vip;
CREATE INDEX IF NOT EXISTS idx_ip_addresses_active ON ip_addresses (active) WHERE active;
-- +goose StatementEnd
-- +goose Down
-- +goose StatementBegin
DROP TABLE IF EXISTS ip_addresses;
DROP TABLE IF EXISTS network_interfaces;
-- +goose StatementEnd

116
internal/handlers/ipaddresses.go Normal file
View File

@@ -0,0 +1,116 @@
package handlers
import (
"errors"
"strconv"
"github.com/gin-gonic/gin"
"git.netcell-it.de/projekte/edgeguard-native/internal/handlers/response"
"git.netcell-it.de/projekte/edgeguard-native/internal/models"
"git.netcell-it.de/projekte/edgeguard-native/internal/services/audit"
"git.netcell-it.de/projekte/edgeguard-native/internal/services/ipaddresses"
)
type IPAddressesHandler struct {
Repo *ipaddresses.Repo
Audit *audit.Repo
NodeID string
}
func NewIPAddressesHandler(repo *ipaddresses.Repo, a *audit.Repo, nodeID string) *IPAddressesHandler {
return &IPAddressesHandler{Repo: repo, Audit: a, NodeID: nodeID}
}
func (h *IPAddressesHandler) Register(rg *gin.RouterGroup) {
g := rg.Group("/ip-addresses")
g.GET("", h.List)
g.POST("", h.Create)
g.GET("/:id", h.Get)
g.PUT("/:id", h.Update)
g.DELETE("/:id", h.Delete)
}
func (h *IPAddressesHandler) List(c *gin.Context) {
out, err := h.Repo.List(c.Request.Context())
if err != nil {
response.Internal(c, err)
return
}
response.OK(c, gin.H{"ip_addresses": out})
}
func (h *IPAddressesHandler) Get(c *gin.Context) {
id, ok := parseID(c)
if !ok {
return
}
x, err := h.Repo.Get(c.Request.Context(), id)
if err != nil {
if errors.Is(err, ipaddresses.ErrNotFound) {
response.NotFound(c, err)
return
}
response.Internal(c, err)
return
}
response.OK(c, x)
}
func (h *IPAddressesHandler) Create(c *gin.Context) {
var req models.IPAddress
if err := c.ShouldBindJSON(&req); err != nil {
response.BadRequest(c, err)
return
}
out, err := h.Repo.Create(c.Request.Context(), req)
if err != nil {
response.Internal(c, err)
return
}
_ = h.Audit.Log(c.Request.Context(), actorOf(c), "ip_address.create",
req.Address, out, h.NodeID)
response.Created(c, out)
}
func (h *IPAddressesHandler) Update(c *gin.Context) {
id, ok := parseID(c)
if !ok {
return
}
var req models.IPAddress
if err := c.ShouldBindJSON(&req); err != nil {
response.BadRequest(c, err)
return
}
out, err := h.Repo.Update(c.Request.Context(), id, req)
if err != nil {
if errors.Is(err, ipaddresses.ErrNotFound) {
response.NotFound(c, err)
return
}
response.Internal(c, err)
return
}
_ = h.Audit.Log(c.Request.Context(), actorOf(c), "ip_address.update",
out.Address, out, h.NodeID)
response.OK(c, out)
}
func (h *IPAddressesHandler) Delete(c *gin.Context) {
id, ok := parseID(c)
if !ok {
return
}
if err := h.Repo.Delete(c.Request.Context(), id); err != nil {
if errors.Is(err, ipaddresses.ErrNotFound) {
response.NotFound(c, err)
return
}
response.Internal(c, err)
return
}
_ = h.Audit.Log(c.Request.Context(), actorOf(c), "ip_address.delete",
strconv.FormatInt(id, 10), gin.H{"id": id}, h.NodeID)
response.NoContent(c)
}

132
internal/handlers/networks.go Normal file
View File

@@ -0,0 +1,132 @@
package handlers
import (
"errors"
"strconv"
"github.com/gin-gonic/gin"
"git.netcell-it.de/projekte/edgeguard-native/internal/handlers/response"
"git.netcell-it.de/projekte/edgeguard-native/internal/models"
"git.netcell-it.de/projekte/edgeguard-native/internal/services/audit"
"git.netcell-it.de/projekte/edgeguard-native/internal/services/ipaddresses"
"git.netcell-it.de/projekte/edgeguard-native/internal/services/networkifs"
)
type NetworksHandler struct {
Repo *networkifs.Repo
IPs *ipaddresses.Repo
Audit *audit.Repo
NodeID string
}
func NewNetworksHandler(repo *networkifs.Repo, ips *ipaddresses.Repo, a *audit.Repo, nodeID string) *NetworksHandler {
return &NetworksHandler{Repo: repo, IPs: ips, Audit: a, NodeID: nodeID}
}
func (h *NetworksHandler) Register(rg *gin.RouterGroup) {
g := rg.Group("/network-interfaces")
g.GET("", h.List)
g.POST("", h.Create)
g.GET("/:id", h.Get)
g.PUT("/:id", h.Update)
g.DELETE("/:id", h.Delete)
g.GET("/:id/ip-addresses", h.ListIPs)
}
func (h *NetworksHandler) List(c *gin.Context) {
out, err := h.Repo.List(c.Request.Context())
if err != nil {
response.Internal(c, err)
return
}
response.OK(c, gin.H{"interfaces": out})
}
func (h *NetworksHandler) Get(c *gin.Context) {
id, ok := parseID(c)
if !ok {
return
}
x, err := h.Repo.Get(c.Request.Context(), id)
if err != nil {
if errors.Is(err, networkifs.ErrNotFound) {
response.NotFound(c, err)
return
}
response.Internal(c, err)
return
}
response.OK(c, x)
}
func (h *NetworksHandler) Create(c *gin.Context) {
var req models.NetworkInterface
if err := c.ShouldBindJSON(&req); err != nil {
response.BadRequest(c, err)
return
}
out, err := h.Repo.Create(c.Request.Context(), req)
if err != nil {
response.Internal(c, err)
return
}
_ = h.Audit.Log(c.Request.Context(), actorOf(c), "network_interface.create", req.Name, out, h.NodeID)
response.Created(c, out)
}
func (h *NetworksHandler) Update(c *gin.Context) {
id, ok := parseID(c)
if !ok {
return
}
var req models.NetworkInterface
if err := c.ShouldBindJSON(&req); err != nil {
response.BadRequest(c, err)
return
}
out, err := h.Repo.Update(c.Request.Context(), id, req)
if err != nil {
if errors.Is(err, networkifs.ErrNotFound) {
response.NotFound(c, err)
return
}
response.Internal(c, err)
return
}
_ = h.Audit.Log(c.Request.Context(), actorOf(c), "network_interface.update", out.Name, out, h.NodeID)
response.OK(c, out)
}
func (h *NetworksHandler) Delete(c *gin.Context) {
id, ok := parseID(c)
if !ok {
return
}
if err := h.Repo.Delete(c.Request.Context(), id); err != nil {
if errors.Is(err, networkifs.ErrNotFound) {
response.NotFound(c, err)
return
}
response.Internal(c, err)
return
}
_ = h.Audit.Log(c.Request.Context(), actorOf(c), "network_interface.delete",
strconv.FormatInt(id, 10), gin.H{"id": id}, h.NodeID)
response.NoContent(c)
}
// ListIPs surfaces the addresses bound to a single interface — UI
// uses this for the per-interface IP-list tab.
func (h *NetworksHandler) ListIPs(c *gin.Context) {
id, ok := parseID(c)
if !ok {
return
}
out, err := h.IPs.ListForInterface(c.Request.Context(), id)
if err != nil {
response.Internal(c, err)
return
}
response.OK(c, gin.H{"ip_addresses": out})
}

104
internal/handlers/system.go
View File

@@ -2,6 +2,7 @@ package handlers
import (
"log/slog"
"net"
"net/http"
"os"
"os/exec"
@@ -30,6 +31,7 @@ func (h *SystemHandler) Register(rg *gin.RouterGroup) {
g.GET("/health", h.Health)
g.GET("/package-versions", h.PackageVersions)
g.POST("/upgrade", h.Upgrade)
g.GET("/interfaces", h.Interfaces)
}
func (h *SystemHandler) Health(c *gin.Context) {
@@ -116,6 +118,108 @@ rm -f /tmp/edgeguard-upgrade.sh
})
}
// addrInfo + interfaceInfo mirror the relevant subset of `ip -j addr
// show` so the frontend keeps its existing parsing code.
type addrInfo struct {
Family string `json:"family"` // "inet" | "inet6"
Local string `json:"local"`
PrefixLen int `json:"prefixlen"`
}
type interfaceInfo struct {
IfIndex int `json:"ifindex"`
IfName string `json:"ifname"`
Flags []string `json:"flags"`
MTU int `json:"mtu"`
LinkType string `json:"link_type,omitempty"`
Address string `json:"address,omitempty"`
AddrInfo []addrInfo `json:"addr_info"`
}
// Interfaces enumerates the kernel-side network interfaces using
// Go's net.Interfaces() — no shell-out, no AF_NETLINK exception
// in the systemd hardening required (the original `ip -j addr`
// approach was blocked by RestrictAddressFamilies).
//
// Output shape mirrors `ip -j addr show` enough for the UI's
// Networks "system-discovered" card.
func (h *SystemHandler) Interfaces(c *gin.Context) {
ifaces, err := net.Interfaces()
if err != nil {
slog.Warn("system/interfaces: net.Interfaces failed", "error", err)
response.OK(c, gin.H{"interfaces": []interfaceInfo{}})
return
}
out := make([]interfaceInfo, 0, len(ifaces))
for _, ifc := range ifaces {
info := interfaceInfo{
IfIndex: ifc.Index,
IfName: ifc.Name,
MTU: ifc.MTU,
Address: ifc.HardwareAddr.String(),
LinkType: classifyLinkType(ifc),
Flags: flagsToList(ifc.Flags),
AddrInfo: []addrInfo{},
}
addrs, err := ifc.Addrs()
if err != nil {
out = append(out, info)
continue
}
for _, a := range addrs {
ipnet, ok := a.(*net.IPNet)
if !ok {
continue
}
family := "inet"
if ipnet.IP.To4() == nil {
family = "inet6"
}
ones, _ := ipnet.Mask.Size()
info.AddrInfo = append(info.AddrInfo, addrInfo{
Family: family,
Local: ipnet.IP.String(),
PrefixLen: ones,
})
}
out = append(out, info)
}
response.OK(c, gin.H{"interfaces": out})
}
func classifyLinkType(ifc net.Interface) string {
if ifc.Flags&net.FlagLoopback != 0 {
return "loopback"
}
if len(ifc.HardwareAddr) > 0 {
return "ether"
}
return ""
}
func flagsToList(f net.Flags) []string {
var out []string
if f&net.FlagUp != 0 {
out = append(out, "UP")
}
if f&net.FlagBroadcast != 0 {
out = append(out, "BROADCAST")
}
if f&net.FlagLoopback != 0 {
out = append(out, "LOOPBACK")
}
if f&net.FlagPointToPoint != 0 {
out = append(out, "POINTOPOINT")
}
if f&net.FlagMulticast != 0 {
out = append(out, "MULTICAST")
}
if f&net.FlagRunning != 0 {
out = append(out, "LOWER_UP")
}
return out
}
// parseAptPolicy extracts "Installed: x" and "Candidate: y" from
// apt-cache policy output. Both can be "(none)"; we normalise that to
// empty string.

18
internal/models/ip_address.go Normal file
View File

@@ -0,0 +1,18 @@
package models
import "time"
type IPAddress struct {
ID int64 `gorm:"primaryKey" json:"id"`
InterfaceID int64 `gorm:"column:interface_id" json:"interface_id"`
Address string `gorm:"column:address" json:"address"`
Prefix int `gorm:"column:prefix" json:"prefix"`
IsVIP bool `gorm:"column:is_vip" json:"is_vip"`
VIPPriority *int `gorm:"column:vip_priority" json:"vip_priority,omitempty"`
Description *string `gorm:"column:description" json:"description,omitempty"`
Active bool `gorm:"column:active" json:"active"`
CreatedAt time.Time `gorm:"column:created_at" json:"created_at"`
UpdatedAt time.Time `gorm:"column:updated_at" json:"updated_at"`
}
func (IPAddress) TableName() string { return "ip_addresses" }

19
internal/models/network_interface.go Normal file
View File

@@ -0,0 +1,19 @@
package models
import "time"
type NetworkInterface struct {
ID int64 `gorm:"primaryKey" json:"id"`
Name string `gorm:"column:name;uniqueIndex" json:"name"`
Type string `gorm:"column:type" json:"type"`
Parent *string `gorm:"column:parent" json:"parent,omitempty"`
VLANID *int `gorm:"column:vlan_id" json:"vlan_id,omitempty"`
Role string `gorm:"column:role" json:"role"`
MTU *int `gorm:"column:mtu" json:"mtu,omitempty"`
Active bool `gorm:"column:active" json:"active"`
Description *string `gorm:"column:description" json:"description,omitempty"`
CreatedAt time.Time `gorm:"column:created_at" json:"created_at"`
UpdatedAt time.Time `gorm:"column:updated_at" json:"updated_at"`
}
func (NetworkInterface) TableName() string { return "network_interfaces" }

129
internal/services/ipaddresses/ipaddresses.go Normal file
View File

@@ -0,0 +1,129 @@
// Package ipaddresses implements CRUD against the `ip_addresses`
// table — addresses bound to operator-declared network interfaces,
// with is_vip + vip_priority for cluster-failover semantics.
package ipaddresses
import (
"context"
"errors"
"github.com/jackc/pgx/v5"
"github.com/jackc/pgx/v5/pgxpool"
"git.netcell-it.de/projekte/edgeguard-native/internal/models"
)
var ErrNotFound = errors.New("ip address not found")
type Repo struct {
Pool *pgxpool.Pool
}
func New(pool *pgxpool.Pool) *Repo { return &Repo{Pool: pool} }
const baseSelect = `
SELECT id, interface_id, address, prefix, is_vip, vip_priority,
description, active, created_at, updated_at
FROM ip_addresses
`
func (r *Repo) List(ctx context.Context) ([]models.IPAddress, error) {
rows, err := r.Pool.Query(ctx, baseSelect+" ORDER BY interface_id ASC, address ASC")
if err != nil {
return nil, err
}
defer rows.Close()
out := make([]models.IPAddress, 0, 8)
for rows.Next() {
a, err := scan(rows)
if err != nil {
return nil, err
}
out = append(out, *a)
}
return out, rows.Err()
}
func (r *Repo) ListForInterface(ctx context.Context, ifaceID int64) ([]models.IPAddress, error) {
rows, err := r.Pool.Query(ctx, baseSelect+
" WHERE interface_id = $1 ORDER BY address ASC", ifaceID)
if err != nil {
return nil, err
}
defer rows.Close()
out := make([]models.IPAddress, 0, 4)
for rows.Next() {
a, err := scan(rows)
if err != nil {
return nil, err
}
out = append(out, *a)
}
return out, rows.Err()
}
func (r *Repo) Get(ctx context.Context, id int64) (*models.IPAddress, error) {
row := r.Pool.QueryRow(ctx, baseSelect+" WHERE id = $1", id)
a, err := scan(row)
if err != nil {
if errors.Is(err, pgx.ErrNoRows) {
return nil, ErrNotFound
}
return nil, err
}
return a, nil
}
func (r *Repo) Create(ctx context.Context, a models.IPAddress) (*models.IPAddress, error) {
row := r.Pool.QueryRow(ctx, `
INSERT INTO ip_addresses (interface_id, address, prefix, is_vip, vip_priority, description, active)
VALUES ($1, $2, $3, $4, $5, $6, $7)
RETURNING id, interface_id, address, prefix, is_vip, vip_priority,
description, active, created_at, updated_at`,
a.InterfaceID, a.Address, a.Prefix, a.IsVIP, a.VIPPriority, a.Description, a.Active)
return scan(row)
}
func (r *Repo) Update(ctx context.Context, id int64, a models.IPAddress) (*models.IPAddress, error) {
row := r.Pool.QueryRow(ctx, `
UPDATE ip_addresses SET
interface_id = $1, address = $2, prefix = $3,
is_vip = $4, vip_priority = $5, description = $6, active = $7,
updated_at = NOW()
WHERE id = $8
RETURNING id, interface_id, address, prefix, is_vip, vip_priority,
description, active, created_at, updated_at`,
a.InterfaceID, a.Address, a.Prefix, a.IsVIP, a.VIPPriority, a.Description, a.Active, id)
out, err := scan(row)
if err != nil {
if errors.Is(err, pgx.ErrNoRows) {
return nil, ErrNotFound
}
return nil, err
}
return out, nil
}
func (r *Repo) Delete(ctx context.Context, id int64) error {
tag, err := r.Pool.Exec(ctx, `DELETE FROM ip_addresses WHERE id = $1`, id)
if err != nil {
return err
}
if tag.RowsAffected() == 0 {
return ErrNotFound
}
return nil
}
func scan(row interface{ Scan(...any) error }) (*models.IPAddress, error) {
var a models.IPAddress
if err := row.Scan(
&a.ID, &a.InterfaceID, &a.Address, &a.Prefix,
&a.IsVIP, &a.VIPPriority,
&a.Description, &a.Active,
&a.CreatedAt, &a.UpdatedAt,
); err != nil {
return nil, err
}
return &a, nil
}

110
internal/services/networkifs/networkifs.go Normal file
View File

@@ -0,0 +1,110 @@
// Package networkifs implements CRUD against the
// `network_interfaces` table — operator-declared interfaces
// (ethernet, vlan, bond, bridge, wireguard).
package networkifs
import (
"context"
"errors"
"github.com/jackc/pgx/v5"
"github.com/jackc/pgx/v5/pgxpool"
"git.netcell-it.de/projekte/edgeguard-native/internal/models"
)
var ErrNotFound = errors.New("network interface not found")
type Repo struct {
Pool *pgxpool.Pool
}
func New(pool *pgxpool.Pool) *Repo { return &Repo{Pool: pool} }
const baseSelect = `
SELECT id, name, type, parent, vlan_id, role, mtu, active, description,
created_at, updated_at
FROM network_interfaces
`
func (r *Repo) List(ctx context.Context) ([]models.NetworkInterface, error) {
rows, err := r.Pool.Query(ctx, baseSelect+" ORDER BY name ASC")
if err != nil {
return nil, err
}
defer rows.Close()
out := make([]models.NetworkInterface, 0, 8)
for rows.Next() {
i, err := scan(rows)
if err != nil {
return nil, err
}
out = append(out, *i)
}
return out, rows.Err()
}
func (r *Repo) Get(ctx context.Context, id int64) (*models.NetworkInterface, error) {
row := r.Pool.QueryRow(ctx, baseSelect+" WHERE id = $1", id)
i, err := scan(row)
if err != nil {
if errors.Is(err, pgx.ErrNoRows) {
return nil, ErrNotFound
}
return nil, err
}
return i, nil
}
func (r *Repo) Create(ctx context.Context, i models.NetworkInterface) (*models.NetworkInterface, error) {
row := r.Pool.QueryRow(ctx, `
INSERT INTO network_interfaces (name, type, parent, vlan_id, role, mtu, active, description)
VALUES ($1, $2, $3, $4, $5, $6, $7, $8)
RETURNING id, name, type, parent, vlan_id, role, mtu, active, description,
created_at, updated_at`,
i.Name, i.Type, i.Parent, i.VLANID, i.Role, i.MTU, i.Active, i.Description)
return scan(row)
}
func (r *Repo) Update(ctx context.Context, id int64, i models.NetworkInterface) (*models.NetworkInterface, error) {
row := r.Pool.QueryRow(ctx, `
UPDATE network_interfaces SET
name = $1, type = $2, parent = $3, vlan_id = $4,
role = $5, mtu = $6, active = $7, description = $8,
updated_at = NOW()
WHERE id = $9
RETURNING id, name, type, parent, vlan_id, role, mtu, active, description,
created_at, updated_at`,
i.Name, i.Type, i.Parent, i.VLANID, i.Role, i.MTU, i.Active, i.Description, id)
out, err := scan(row)
if err != nil {
if errors.Is(err, pgx.ErrNoRows) {
return nil, ErrNotFound
}
return nil, err
}
return out, nil
}
func (r *Repo) Delete(ctx context.Context, id int64) error {
tag, err := r.Pool.Exec(ctx, `DELETE FROM network_interfaces WHERE id = $1`, id)
if err != nil {
return err
}
if tag.RowsAffected() == 0 {
return ErrNotFound
}
return nil
}
func scan(row interface{ Scan(...any) error }) (*models.NetworkInterface, error) {
var i models.NetworkInterface
if err := row.Scan(
&i.ID, &i.Name, &i.Type, &i.Parent, &i.VLANID,
&i.Role, &i.MTU, &i.Active, &i.Description,
&i.CreatedAt, &i.UpdatedAt,
); err != nil {
return nil, err
}
return &i, nil
}