forked from wrenn/wrenn
pptx704
a5ad3731f2
Moves 12 packages from internal/ to pkg/ (config, id, validate, events, db, auth, lifecycle, scheduler, channels, audit, service) so they can be imported by the enterprise repo as a Go module dependency. Introduces pkg/cpextension (shared Extension interface + ServerContext) and pkg/cpserver (Run() entrypoint with functional options) so the enterprise main.go can call cpserver.Run(cpserver.WithExtensions(...)) without duplicating the 20-step server bootstrap. Adds db/migrations/embed.go for go:embed access to OSS SQL migrations from the enterprise module. cmd/control-plane/main.go is reduced to a 10-line wrapper around cpserver.Run.
739 lines
19 KiB
Go
739 lines
19 KiB
Go
// Code generated by sqlc. DO NOT EDIT.
|
|
// versions:
|
|
// sqlc v1.30.0
|
|
// source: hosts.sql
|
|
|
|
package db
|
|
|
|
import (
|
|
"context"
|
|
|
|
"github.com/jackc/pgx/v5/pgtype"
|
|
)
|
|
|
|
const addHostTag = `-- name: AddHostTag :exec
|
|
INSERT INTO host_tags (host_id, tag) VALUES ($1, $2) ON CONFLICT DO NOTHING
|
|
`
|
|
|
|
type AddHostTagParams struct {
|
|
HostID pgtype.UUID `json:"host_id"`
|
|
Tag string `json:"tag"`
|
|
}
|
|
|
|
func (q *Queries) AddHostTag(ctx context.Context, arg AddHostTagParams) error {
|
|
_, err := q.db.Exec(ctx, addHostTag, arg.HostID, arg.Tag)
|
|
return err
|
|
}
|
|
|
|
const deleteHost = `-- name: DeleteHost :exec
|
|
DELETE FROM hosts WHERE id = $1
|
|
`
|
|
|
|
func (q *Queries) DeleteHost(ctx context.Context, id pgtype.UUID) error {
|
|
_, err := q.db.Exec(ctx, deleteHost, id)
|
|
return err
|
|
}
|
|
|
|
const getHost = `-- name: GetHost :one
|
|
SELECT id, type, team_id, provider, availability_zone, arch, cpu_cores, memory_mb, disk_gb, address, status, last_heartbeat_at, metadata, created_by, created_at, updated_at, cert_fingerprint, cert_expires_at FROM hosts WHERE id = $1
|
|
`
|
|
|
|
func (q *Queries) GetHost(ctx context.Context, id pgtype.UUID) (Host, error) {
|
|
row := q.db.QueryRow(ctx, getHost, id)
|
|
var i Host
|
|
err := row.Scan(
|
|
&i.ID,
|
|
&i.Type,
|
|
&i.TeamID,
|
|
&i.Provider,
|
|
&i.AvailabilityZone,
|
|
&i.Arch,
|
|
&i.CpuCores,
|
|
&i.MemoryMb,
|
|
&i.DiskGb,
|
|
&i.Address,
|
|
&i.Status,
|
|
&i.LastHeartbeatAt,
|
|
&i.Metadata,
|
|
&i.CreatedBy,
|
|
&i.CreatedAt,
|
|
&i.UpdatedAt,
|
|
&i.CertFingerprint,
|
|
&i.CertExpiresAt,
|
|
)
|
|
return i, err
|
|
}
|
|
|
|
const getHostByTeam = `-- name: GetHostByTeam :one
|
|
SELECT id, type, team_id, provider, availability_zone, arch, cpu_cores, memory_mb, disk_gb, address, status, last_heartbeat_at, metadata, created_by, created_at, updated_at, cert_fingerprint, cert_expires_at FROM hosts WHERE id = $1 AND team_id = $2
|
|
`
|
|
|
|
type GetHostByTeamParams struct {
|
|
ID pgtype.UUID `json:"id"`
|
|
TeamID pgtype.UUID `json:"team_id"`
|
|
}
|
|
|
|
func (q *Queries) GetHostByTeam(ctx context.Context, arg GetHostByTeamParams) (Host, error) {
|
|
row := q.db.QueryRow(ctx, getHostByTeam, arg.ID, arg.TeamID)
|
|
var i Host
|
|
err := row.Scan(
|
|
&i.ID,
|
|
&i.Type,
|
|
&i.TeamID,
|
|
&i.Provider,
|
|
&i.AvailabilityZone,
|
|
&i.Arch,
|
|
&i.CpuCores,
|
|
&i.MemoryMb,
|
|
&i.DiskGb,
|
|
&i.Address,
|
|
&i.Status,
|
|
&i.LastHeartbeatAt,
|
|
&i.Metadata,
|
|
&i.CreatedBy,
|
|
&i.CreatedAt,
|
|
&i.UpdatedAt,
|
|
&i.CertFingerprint,
|
|
&i.CertExpiresAt,
|
|
)
|
|
return i, err
|
|
}
|
|
|
|
const getHostTags = `-- name: GetHostTags :many
|
|
SELECT tag FROM host_tags WHERE host_id = $1 ORDER BY tag
|
|
`
|
|
|
|
func (q *Queries) GetHostTags(ctx context.Context, hostID pgtype.UUID) ([]string, error) {
|
|
rows, err := q.db.Query(ctx, getHostTags, hostID)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
defer rows.Close()
|
|
var items []string
|
|
for rows.Next() {
|
|
var tag string
|
|
if err := rows.Scan(&tag); err != nil {
|
|
return nil, err
|
|
}
|
|
items = append(items, tag)
|
|
}
|
|
if err := rows.Err(); err != nil {
|
|
return nil, err
|
|
}
|
|
return items, nil
|
|
}
|
|
|
|
const getHostTokensByHost = `-- name: GetHostTokensByHost :many
|
|
SELECT id, host_id, created_by, created_at, expires_at, used_at FROM host_tokens WHERE host_id = $1 ORDER BY created_at DESC
|
|
`
|
|
|
|
func (q *Queries) GetHostTokensByHost(ctx context.Context, hostID pgtype.UUID) ([]HostToken, error) {
|
|
rows, err := q.db.Query(ctx, getHostTokensByHost, hostID)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
defer rows.Close()
|
|
var items []HostToken
|
|
for rows.Next() {
|
|
var i HostToken
|
|
if err := rows.Scan(
|
|
&i.ID,
|
|
&i.HostID,
|
|
&i.CreatedBy,
|
|
&i.CreatedAt,
|
|
&i.ExpiresAt,
|
|
&i.UsedAt,
|
|
); err != nil {
|
|
return nil, err
|
|
}
|
|
items = append(items, i)
|
|
}
|
|
if err := rows.Err(); err != nil {
|
|
return nil, err
|
|
}
|
|
return items, nil
|
|
}
|
|
|
|
const getHostsWithLoad = `-- name: GetHostsWithLoad :many
|
|
SELECT
|
|
h.id,
|
|
h.type,
|
|
h.team_id,
|
|
h.provider,
|
|
h.availability_zone,
|
|
h.arch,
|
|
h.cpu_cores,
|
|
h.memory_mb,
|
|
h.disk_gb,
|
|
h.address,
|
|
h.status,
|
|
h.last_heartbeat_at,
|
|
h.metadata,
|
|
h.created_by,
|
|
h.created_at,
|
|
h.updated_at,
|
|
h.cert_fingerprint,
|
|
h.cert_expires_at,
|
|
COALESCE(SUM(s.vcpus) FILTER (WHERE s.status IN ('running', 'starting', 'pending')), 0)::int AS running_vcpus,
|
|
COALESCE(SUM(s.memory_mb) FILTER (WHERE s.status IN ('running', 'starting', 'pending')), 0)::int AS running_memory_mb,
|
|
COALESCE(SUM(s.disk_size_mb) FILTER (WHERE s.status IN ('running', 'starting', 'pending')), 0)::int AS running_disk_mb,
|
|
COALESCE(SUM(s.memory_mb) FILTER (WHERE s.status = 'paused'), 0)::int AS paused_memory_mb,
|
|
COALESCE(SUM(s.disk_size_mb) FILTER (WHERE s.status = 'paused'), 0)::int AS paused_disk_mb
|
|
FROM hosts h
|
|
LEFT JOIN sandboxes s ON s.host_id = h.id
|
|
AND s.status IN ('running', 'paused', 'starting', 'pending')
|
|
WHERE h.status = 'online'
|
|
AND h.address != ''
|
|
GROUP BY h.id
|
|
ORDER BY h.created_at
|
|
`
|
|
|
|
type GetHostsWithLoadRow struct {
|
|
ID pgtype.UUID `json:"id"`
|
|
Type string `json:"type"`
|
|
TeamID pgtype.UUID `json:"team_id"`
|
|
Provider string `json:"provider"`
|
|
AvailabilityZone string `json:"availability_zone"`
|
|
Arch string `json:"arch"`
|
|
CpuCores int32 `json:"cpu_cores"`
|
|
MemoryMb int32 `json:"memory_mb"`
|
|
DiskGb int32 `json:"disk_gb"`
|
|
Address string `json:"address"`
|
|
Status string `json:"status"`
|
|
LastHeartbeatAt pgtype.Timestamptz `json:"last_heartbeat_at"`
|
|
Metadata []byte `json:"metadata"`
|
|
CreatedBy pgtype.UUID `json:"created_by"`
|
|
CreatedAt pgtype.Timestamptz `json:"created_at"`
|
|
UpdatedAt pgtype.Timestamptz `json:"updated_at"`
|
|
CertFingerprint string `json:"cert_fingerprint"`
|
|
CertExpiresAt pgtype.Timestamptz `json:"cert_expires_at"`
|
|
RunningVcpus int32 `json:"running_vcpus"`
|
|
RunningMemoryMb int32 `json:"running_memory_mb"`
|
|
RunningDiskMb int32 `json:"running_disk_mb"`
|
|
PausedMemoryMb int32 `json:"paused_memory_mb"`
|
|
PausedDiskMb int32 `json:"paused_disk_mb"`
|
|
}
|
|
|
|
// Returns all online hosts with raw per-host sandbox resource consumption.
|
|
// Separates running and paused sandbox totals so the caller can apply its own formulas.
|
|
func (q *Queries) GetHostsWithLoad(ctx context.Context) ([]GetHostsWithLoadRow, error) {
|
|
rows, err := q.db.Query(ctx, getHostsWithLoad)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
defer rows.Close()
|
|
var items []GetHostsWithLoadRow
|
|
for rows.Next() {
|
|
var i GetHostsWithLoadRow
|
|
if err := rows.Scan(
|
|
&i.ID,
|
|
&i.Type,
|
|
&i.TeamID,
|
|
&i.Provider,
|
|
&i.AvailabilityZone,
|
|
&i.Arch,
|
|
&i.CpuCores,
|
|
&i.MemoryMb,
|
|
&i.DiskGb,
|
|
&i.Address,
|
|
&i.Status,
|
|
&i.LastHeartbeatAt,
|
|
&i.Metadata,
|
|
&i.CreatedBy,
|
|
&i.CreatedAt,
|
|
&i.UpdatedAt,
|
|
&i.CertFingerprint,
|
|
&i.CertExpiresAt,
|
|
&i.RunningVcpus,
|
|
&i.RunningMemoryMb,
|
|
&i.RunningDiskMb,
|
|
&i.PausedMemoryMb,
|
|
&i.PausedDiskMb,
|
|
); err != nil {
|
|
return nil, err
|
|
}
|
|
items = append(items, i)
|
|
}
|
|
if err := rows.Err(); err != nil {
|
|
return nil, err
|
|
}
|
|
return items, nil
|
|
}
|
|
|
|
const insertHost = `-- name: InsertHost :one
|
|
INSERT INTO hosts (id, type, team_id, provider, availability_zone, created_by)
|
|
VALUES ($1, $2, $3, $4, $5, $6)
|
|
RETURNING id, type, team_id, provider, availability_zone, arch, cpu_cores, memory_mb, disk_gb, address, status, last_heartbeat_at, metadata, created_by, created_at, updated_at, cert_fingerprint, cert_expires_at
|
|
`
|
|
|
|
type InsertHostParams struct {
|
|
ID pgtype.UUID `json:"id"`
|
|
Type string `json:"type"`
|
|
TeamID pgtype.UUID `json:"team_id"`
|
|
Provider string `json:"provider"`
|
|
AvailabilityZone string `json:"availability_zone"`
|
|
CreatedBy pgtype.UUID `json:"created_by"`
|
|
}
|
|
|
|
func (q *Queries) InsertHost(ctx context.Context, arg InsertHostParams) (Host, error) {
|
|
row := q.db.QueryRow(ctx, insertHost,
|
|
arg.ID,
|
|
arg.Type,
|
|
arg.TeamID,
|
|
arg.Provider,
|
|
arg.AvailabilityZone,
|
|
arg.CreatedBy,
|
|
)
|
|
var i Host
|
|
err := row.Scan(
|
|
&i.ID,
|
|
&i.Type,
|
|
&i.TeamID,
|
|
&i.Provider,
|
|
&i.AvailabilityZone,
|
|
&i.Arch,
|
|
&i.CpuCores,
|
|
&i.MemoryMb,
|
|
&i.DiskGb,
|
|
&i.Address,
|
|
&i.Status,
|
|
&i.LastHeartbeatAt,
|
|
&i.Metadata,
|
|
&i.CreatedBy,
|
|
&i.CreatedAt,
|
|
&i.UpdatedAt,
|
|
&i.CertFingerprint,
|
|
&i.CertExpiresAt,
|
|
)
|
|
return i, err
|
|
}
|
|
|
|
const insertHostToken = `-- name: InsertHostToken :one
|
|
INSERT INTO host_tokens (id, host_id, created_by, expires_at)
|
|
VALUES ($1, $2, $3, $4)
|
|
RETURNING id, host_id, created_by, created_at, expires_at, used_at
|
|
`
|
|
|
|
type InsertHostTokenParams struct {
|
|
ID pgtype.UUID `json:"id"`
|
|
HostID pgtype.UUID `json:"host_id"`
|
|
CreatedBy pgtype.UUID `json:"created_by"`
|
|
ExpiresAt pgtype.Timestamptz `json:"expires_at"`
|
|
}
|
|
|
|
func (q *Queries) InsertHostToken(ctx context.Context, arg InsertHostTokenParams) (HostToken, error) {
|
|
row := q.db.QueryRow(ctx, insertHostToken,
|
|
arg.ID,
|
|
arg.HostID,
|
|
arg.CreatedBy,
|
|
arg.ExpiresAt,
|
|
)
|
|
var i HostToken
|
|
err := row.Scan(
|
|
&i.ID,
|
|
&i.HostID,
|
|
&i.CreatedBy,
|
|
&i.CreatedAt,
|
|
&i.ExpiresAt,
|
|
&i.UsedAt,
|
|
)
|
|
return i, err
|
|
}
|
|
|
|
const listActiveHosts = `-- name: ListActiveHosts :many
|
|
SELECT id, type, team_id, provider, availability_zone, arch, cpu_cores, memory_mb, disk_gb, address, status, last_heartbeat_at, metadata, created_by, created_at, updated_at, cert_fingerprint, cert_expires_at FROM hosts WHERE status NOT IN ('pending', 'offline') ORDER BY created_at
|
|
`
|
|
|
|
// Returns all hosts that have completed registration (not pending/offline).
|
|
func (q *Queries) ListActiveHosts(ctx context.Context) ([]Host, error) {
|
|
rows, err := q.db.Query(ctx, listActiveHosts)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
defer rows.Close()
|
|
var items []Host
|
|
for rows.Next() {
|
|
var i Host
|
|
if err := rows.Scan(
|
|
&i.ID,
|
|
&i.Type,
|
|
&i.TeamID,
|
|
&i.Provider,
|
|
&i.AvailabilityZone,
|
|
&i.Arch,
|
|
&i.CpuCores,
|
|
&i.MemoryMb,
|
|
&i.DiskGb,
|
|
&i.Address,
|
|
&i.Status,
|
|
&i.LastHeartbeatAt,
|
|
&i.Metadata,
|
|
&i.CreatedBy,
|
|
&i.CreatedAt,
|
|
&i.UpdatedAt,
|
|
&i.CertFingerprint,
|
|
&i.CertExpiresAt,
|
|
); err != nil {
|
|
return nil, err
|
|
}
|
|
items = append(items, i)
|
|
}
|
|
if err := rows.Err(); err != nil {
|
|
return nil, err
|
|
}
|
|
return items, nil
|
|
}
|
|
|
|
const listHosts = `-- name: ListHosts :many
|
|
SELECT id, type, team_id, provider, availability_zone, arch, cpu_cores, memory_mb, disk_gb, address, status, last_heartbeat_at, metadata, created_by, created_at, updated_at, cert_fingerprint, cert_expires_at FROM hosts ORDER BY created_at DESC
|
|
`
|
|
|
|
func (q *Queries) ListHosts(ctx context.Context) ([]Host, error) {
|
|
rows, err := q.db.Query(ctx, listHosts)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
defer rows.Close()
|
|
var items []Host
|
|
for rows.Next() {
|
|
var i Host
|
|
if err := rows.Scan(
|
|
&i.ID,
|
|
&i.Type,
|
|
&i.TeamID,
|
|
&i.Provider,
|
|
&i.AvailabilityZone,
|
|
&i.Arch,
|
|
&i.CpuCores,
|
|
&i.MemoryMb,
|
|
&i.DiskGb,
|
|
&i.Address,
|
|
&i.Status,
|
|
&i.LastHeartbeatAt,
|
|
&i.Metadata,
|
|
&i.CreatedBy,
|
|
&i.CreatedAt,
|
|
&i.UpdatedAt,
|
|
&i.CertFingerprint,
|
|
&i.CertExpiresAt,
|
|
); err != nil {
|
|
return nil, err
|
|
}
|
|
items = append(items, i)
|
|
}
|
|
if err := rows.Err(); err != nil {
|
|
return nil, err
|
|
}
|
|
return items, nil
|
|
}
|
|
|
|
const listHostsByStatus = `-- name: ListHostsByStatus :many
|
|
SELECT id, type, team_id, provider, availability_zone, arch, cpu_cores, memory_mb, disk_gb, address, status, last_heartbeat_at, metadata, created_by, created_at, updated_at, cert_fingerprint, cert_expires_at FROM hosts WHERE status = $1 ORDER BY created_at DESC
|
|
`
|
|
|
|
func (q *Queries) ListHostsByStatus(ctx context.Context, status string) ([]Host, error) {
|
|
rows, err := q.db.Query(ctx, listHostsByStatus, status)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
defer rows.Close()
|
|
var items []Host
|
|
for rows.Next() {
|
|
var i Host
|
|
if err := rows.Scan(
|
|
&i.ID,
|
|
&i.Type,
|
|
&i.TeamID,
|
|
&i.Provider,
|
|
&i.AvailabilityZone,
|
|
&i.Arch,
|
|
&i.CpuCores,
|
|
&i.MemoryMb,
|
|
&i.DiskGb,
|
|
&i.Address,
|
|
&i.Status,
|
|
&i.LastHeartbeatAt,
|
|
&i.Metadata,
|
|
&i.CreatedBy,
|
|
&i.CreatedAt,
|
|
&i.UpdatedAt,
|
|
&i.CertFingerprint,
|
|
&i.CertExpiresAt,
|
|
); err != nil {
|
|
return nil, err
|
|
}
|
|
items = append(items, i)
|
|
}
|
|
if err := rows.Err(); err != nil {
|
|
return nil, err
|
|
}
|
|
return items, nil
|
|
}
|
|
|
|
const listHostsByTag = `-- name: ListHostsByTag :many
|
|
SELECT h.id, h.type, h.team_id, h.provider, h.availability_zone, h.arch, h.cpu_cores, h.memory_mb, h.disk_gb, h.address, h.status, h.last_heartbeat_at, h.metadata, h.created_by, h.created_at, h.updated_at, h.cert_fingerprint, h.cert_expires_at FROM hosts h
|
|
JOIN host_tags ht ON ht.host_id = h.id
|
|
WHERE ht.tag = $1
|
|
ORDER BY h.created_at DESC
|
|
`
|
|
|
|
func (q *Queries) ListHostsByTag(ctx context.Context, tag string) ([]Host, error) {
|
|
rows, err := q.db.Query(ctx, listHostsByTag, tag)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
defer rows.Close()
|
|
var items []Host
|
|
for rows.Next() {
|
|
var i Host
|
|
if err := rows.Scan(
|
|
&i.ID,
|
|
&i.Type,
|
|
&i.TeamID,
|
|
&i.Provider,
|
|
&i.AvailabilityZone,
|
|
&i.Arch,
|
|
&i.CpuCores,
|
|
&i.MemoryMb,
|
|
&i.DiskGb,
|
|
&i.Address,
|
|
&i.Status,
|
|
&i.LastHeartbeatAt,
|
|
&i.Metadata,
|
|
&i.CreatedBy,
|
|
&i.CreatedAt,
|
|
&i.UpdatedAt,
|
|
&i.CertFingerprint,
|
|
&i.CertExpiresAt,
|
|
); err != nil {
|
|
return nil, err
|
|
}
|
|
items = append(items, i)
|
|
}
|
|
if err := rows.Err(); err != nil {
|
|
return nil, err
|
|
}
|
|
return items, nil
|
|
}
|
|
|
|
const listHostsByTeam = `-- name: ListHostsByTeam :many
|
|
SELECT id, type, team_id, provider, availability_zone, arch, cpu_cores, memory_mb, disk_gb, address, status, last_heartbeat_at, metadata, created_by, created_at, updated_at, cert_fingerprint, cert_expires_at FROM hosts WHERE team_id = $1 AND type = 'byoc' ORDER BY created_at DESC
|
|
`
|
|
|
|
func (q *Queries) ListHostsByTeam(ctx context.Context, teamID pgtype.UUID) ([]Host, error) {
|
|
rows, err := q.db.Query(ctx, listHostsByTeam, teamID)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
defer rows.Close()
|
|
var items []Host
|
|
for rows.Next() {
|
|
var i Host
|
|
if err := rows.Scan(
|
|
&i.ID,
|
|
&i.Type,
|
|
&i.TeamID,
|
|
&i.Provider,
|
|
&i.AvailabilityZone,
|
|
&i.Arch,
|
|
&i.CpuCores,
|
|
&i.MemoryMb,
|
|
&i.DiskGb,
|
|
&i.Address,
|
|
&i.Status,
|
|
&i.LastHeartbeatAt,
|
|
&i.Metadata,
|
|
&i.CreatedBy,
|
|
&i.CreatedAt,
|
|
&i.UpdatedAt,
|
|
&i.CertFingerprint,
|
|
&i.CertExpiresAt,
|
|
); err != nil {
|
|
return nil, err
|
|
}
|
|
items = append(items, i)
|
|
}
|
|
if err := rows.Err(); err != nil {
|
|
return nil, err
|
|
}
|
|
return items, nil
|
|
}
|
|
|
|
const listHostsByType = `-- name: ListHostsByType :many
|
|
SELECT id, type, team_id, provider, availability_zone, arch, cpu_cores, memory_mb, disk_gb, address, status, last_heartbeat_at, metadata, created_by, created_at, updated_at, cert_fingerprint, cert_expires_at FROM hosts WHERE type = $1 ORDER BY created_at DESC
|
|
`
|
|
|
|
func (q *Queries) ListHostsByType(ctx context.Context, type_ string) ([]Host, error) {
|
|
rows, err := q.db.Query(ctx, listHostsByType, type_)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
defer rows.Close()
|
|
var items []Host
|
|
for rows.Next() {
|
|
var i Host
|
|
if err := rows.Scan(
|
|
&i.ID,
|
|
&i.Type,
|
|
&i.TeamID,
|
|
&i.Provider,
|
|
&i.AvailabilityZone,
|
|
&i.Arch,
|
|
&i.CpuCores,
|
|
&i.MemoryMb,
|
|
&i.DiskGb,
|
|
&i.Address,
|
|
&i.Status,
|
|
&i.LastHeartbeatAt,
|
|
&i.Metadata,
|
|
&i.CreatedBy,
|
|
&i.CreatedAt,
|
|
&i.UpdatedAt,
|
|
&i.CertFingerprint,
|
|
&i.CertExpiresAt,
|
|
); err != nil {
|
|
return nil, err
|
|
}
|
|
items = append(items, i)
|
|
}
|
|
if err := rows.Err(); err != nil {
|
|
return nil, err
|
|
}
|
|
return items, nil
|
|
}
|
|
|
|
const markHostTokenUsed = `-- name: MarkHostTokenUsed :exec
|
|
UPDATE host_tokens SET used_at = NOW() WHERE id = $1
|
|
`
|
|
|
|
func (q *Queries) MarkHostTokenUsed(ctx context.Context, id pgtype.UUID) error {
|
|
_, err := q.db.Exec(ctx, markHostTokenUsed, id)
|
|
return err
|
|
}
|
|
|
|
const markHostUnreachable = `-- name: MarkHostUnreachable :exec
|
|
UPDATE hosts SET status = 'unreachable', updated_at = NOW() WHERE id = $1
|
|
`
|
|
|
|
func (q *Queries) MarkHostUnreachable(ctx context.Context, id pgtype.UUID) error {
|
|
_, err := q.db.Exec(ctx, markHostUnreachable, id)
|
|
return err
|
|
}
|
|
|
|
const registerHost = `-- name: RegisterHost :execrows
|
|
UPDATE hosts
|
|
SET arch = $2,
|
|
cpu_cores = $3,
|
|
memory_mb = $4,
|
|
disk_gb = $5,
|
|
address = $6,
|
|
cert_fingerprint = $7,
|
|
cert_expires_at = $8,
|
|
status = 'online',
|
|
last_heartbeat_at = NOW(),
|
|
updated_at = NOW()
|
|
WHERE id = $1 AND status = 'pending'
|
|
`
|
|
|
|
type RegisterHostParams struct {
|
|
ID pgtype.UUID `json:"id"`
|
|
Arch string `json:"arch"`
|
|
CpuCores int32 `json:"cpu_cores"`
|
|
MemoryMb int32 `json:"memory_mb"`
|
|
DiskGb int32 `json:"disk_gb"`
|
|
Address string `json:"address"`
|
|
CertFingerprint string `json:"cert_fingerprint"`
|
|
CertExpiresAt pgtype.Timestamptz `json:"cert_expires_at"`
|
|
}
|
|
|
|
func (q *Queries) RegisterHost(ctx context.Context, arg RegisterHostParams) (int64, error) {
|
|
result, err := q.db.Exec(ctx, registerHost,
|
|
arg.ID,
|
|
arg.Arch,
|
|
arg.CpuCores,
|
|
arg.MemoryMb,
|
|
arg.DiskGb,
|
|
arg.Address,
|
|
arg.CertFingerprint,
|
|
arg.CertExpiresAt,
|
|
)
|
|
if err != nil {
|
|
return 0, err
|
|
}
|
|
return result.RowsAffected(), nil
|
|
}
|
|
|
|
const removeHostTag = `-- name: RemoveHostTag :exec
|
|
DELETE FROM host_tags WHERE host_id = $1 AND tag = $2
|
|
`
|
|
|
|
type RemoveHostTagParams struct {
|
|
HostID pgtype.UUID `json:"host_id"`
|
|
Tag string `json:"tag"`
|
|
}
|
|
|
|
func (q *Queries) RemoveHostTag(ctx context.Context, arg RemoveHostTagParams) error {
|
|
_, err := q.db.Exec(ctx, removeHostTag, arg.HostID, arg.Tag)
|
|
return err
|
|
}
|
|
|
|
const updateHostCert = `-- name: UpdateHostCert :exec
|
|
UPDATE hosts
|
|
SET cert_fingerprint = $2,
|
|
cert_expires_at = $3,
|
|
updated_at = NOW()
|
|
WHERE id = $1
|
|
`
|
|
|
|
type UpdateHostCertParams struct {
|
|
ID pgtype.UUID `json:"id"`
|
|
CertFingerprint string `json:"cert_fingerprint"`
|
|
CertExpiresAt pgtype.Timestamptz `json:"cert_expires_at"`
|
|
}
|
|
|
|
func (q *Queries) UpdateHostCert(ctx context.Context, arg UpdateHostCertParams) error {
|
|
_, err := q.db.Exec(ctx, updateHostCert, arg.ID, arg.CertFingerprint, arg.CertExpiresAt)
|
|
return err
|
|
}
|
|
|
|
const updateHostHeartbeat = `-- name: UpdateHostHeartbeat :exec
|
|
UPDATE hosts SET last_heartbeat_at = NOW(), updated_at = NOW() WHERE id = $1
|
|
`
|
|
|
|
func (q *Queries) UpdateHostHeartbeat(ctx context.Context, id pgtype.UUID) error {
|
|
_, err := q.db.Exec(ctx, updateHostHeartbeat, id)
|
|
return err
|
|
}
|
|
|
|
const updateHostHeartbeatAndStatus = `-- name: UpdateHostHeartbeatAndStatus :execrows
|
|
UPDATE hosts
|
|
SET last_heartbeat_at = NOW(),
|
|
status = CASE WHEN status = 'unreachable' THEN 'online' ELSE status END,
|
|
updated_at = NOW()
|
|
WHERE id = $1
|
|
`
|
|
|
|
// Updates last_heartbeat_at and transitions unreachable hosts back to online.
|
|
// Returns 0 if no host was found (deleted), which the caller treats as 404.
|
|
func (q *Queries) UpdateHostHeartbeatAndStatus(ctx context.Context, id pgtype.UUID) (int64, error) {
|
|
result, err := q.db.Exec(ctx, updateHostHeartbeatAndStatus, id)
|
|
if err != nil {
|
|
return 0, err
|
|
}
|
|
return result.RowsAffected(), nil
|
|
}
|
|
|
|
const updateHostStatus = `-- name: UpdateHostStatus :exec
|
|
UPDATE hosts SET status = $2, updated_at = NOW() WHERE id = $1
|
|
`
|
|
|
|
type UpdateHostStatusParams struct {
|
|
ID pgtype.UUID `json:"id"`
|
|
Status string `json:"status"`
|
|
}
|
|
|
|
func (q *Queries) UpdateHostStatus(ctx context.Context, arg UpdateHostStatusParams) error {
|
|
_, err := q.db.Exec(ctx, updateHostStatus, arg.ID, arg.Status)
|
|
return err
|
|
}
|