feat: complete SyncServer implementation
Full-stack Go monolith with embedded React frontend for orchestrating rsync-over-SSH file synchronization with Wake-on-LAN support. Features: - JWT auth (HS256) with bcrypt password hashing - CRUD for machines (with WoL config) and sync_pairs - Ed25519 SSH key generation and known_hosts management - WoL magic packet sender + TCP-connect waiter with backoff - Sync engine: rsync subprocess, per-pair job queue, progress parsing - Homebrew cron parser for scheduled syncs - SSE stream for live job status (queued/waking_up/running/success/failed) - React+TS+Vite+Tailwind SPA embedded via embed.FS - Debian packaging with systemd unit, postinst/prerm/postrm Tech stack: - Go 1.22+ (CGO_ENABLED=0, pure SQLite via modernc.org/sqlite) - chi router for HTTP API - TypeScript + React 18 + Tailwind CSS frontend - Cross-compiled to Linux amd64 for Proxmox LXC deployment Tests: wol (MAC parsing, magic packet), syncengine/queue, scheduler/cron
This commit is contained in:
@@ -0,0 +1,145 @@
|
||||
package models
|
||||
|
||||
import (
|
||||
"database/sql"
|
||||
"time"
|
||||
)
|
||||
|
||||
type Job struct {
|
||||
ID int64 `db:"id" json:"id"`
|
||||
SyncPairID int64 `db:"sync_pair_id" json:"sync_pair_id"`
|
||||
TriggerType string `db:"trigger_type" json:"trigger_type"`
|
||||
Status string `db:"status" json:"status"`
|
||||
StartedAt *time.Time `db:"started_at" json:"started_at"`
|
||||
FinishedAt *time.Time `db:"finished_at" json:"finished_at"`
|
||||
LogFile *string `db:"log_file" json:"log_file"`
|
||||
CreatedAt time.Time `db:"created_at" json:"created_at"`
|
||||
}
|
||||
|
||||
type JobRepository struct {
|
||||
db *sql.DB
|
||||
}
|
||||
|
||||
func NewJobRepository(db *sql.DB) *JobRepository {
|
||||
return &JobRepository{db: db}
|
||||
}
|
||||
|
||||
func (r *JobRepository) Create(syncPairID int64, triggerType, status string) (int64, error) {
|
||||
res, err := r.db.Exec(`
|
||||
INSERT INTO jobs (sync_pair_id, trigger_type, status) VALUES (?, ?, ?)`,
|
||||
syncPairID, triggerType, status,
|
||||
)
|
||||
if err != nil {
|
||||
return 0, err
|
||||
}
|
||||
return res.LastInsertId()
|
||||
}
|
||||
|
||||
func (r *JobRepository) GetByID(id int64) (*Job, error) {
|
||||
var j Job
|
||||
var started, finished sql.NullTime
|
||||
var logFile sql.NullString
|
||||
err := r.db.QueryRow(`
|
||||
SELECT id, sync_pair_id, trigger_type, status, started_at, finished_at,
|
||||
log_file, created_at FROM jobs WHERE id = ?`, id).Scan(
|
||||
&j.ID, &j.SyncPairID, &j.TriggerType, &j.Status, &started, &finished,
|
||||
&logFile, &j.CreatedAt)
|
||||
if err != nil {
|
||||
return nil, err
|
||||
}
|
||||
if started.Valid {
|
||||
j.StartedAt = &started.Time
|
||||
}
|
||||
if finished.Valid {
|
||||
j.FinishedAt = &finished.Time
|
||||
}
|
||||
if logFile.Valid {
|
||||
j.LogFile = &logFile.String
|
||||
}
|
||||
return &j, nil
|
||||
}
|
||||
|
||||
func (r *JobRepository) GetAll(limit, offset int) ([]Job, error) {
|
||||
rows, err := r.db.Query(`
|
||||
SELECT id, sync_pair_id, trigger_type, status, started_at, finished_at,
|
||||
log_file, created_at FROM jobs ORDER BY created_at DESC LIMIT ? OFFSET ?`,
|
||||
limit, offset)
|
||||
if err != nil {
|
||||
return nil, err
|
||||
}
|
||||
defer rows.Close()
|
||||
|
||||
var jobs []Job
|
||||
for rows.Next() {
|
||||
var j Job
|
||||
var started, finished sql.NullTime
|
||||
var logFile sql.NullString
|
||||
if err := rows.Scan(&j.ID, &j.SyncPairID, &j.TriggerType, &j.Status,
|
||||
&started, &finished, &logFile, &j.CreatedAt); err != nil {
|
||||
return nil, err
|
||||
}
|
||||
if started.Valid {
|
||||
j.StartedAt = &started.Time
|
||||
}
|
||||
if finished.Valid {
|
||||
j.FinishedAt = &finished.Time
|
||||
}
|
||||
if logFile.Valid {
|
||||
j.LogFile = &logFile.String
|
||||
}
|
||||
jobs = append(jobs, j)
|
||||
}
|
||||
return jobs, rows.Err()
|
||||
}
|
||||
|
||||
func (r *JobRepository) UpdateStatus(id int64, status string) error {
|
||||
var query string
|
||||
var args []interface{}
|
||||
switch status {
|
||||
case "running", "waking_up":
|
||||
query = "UPDATE jobs SET status = ?, started_at = COALESCE(started_at, CURRENT_TIMESTAMP) WHERE id = ?"
|
||||
args = []interface{}{status, id}
|
||||
case "success", "failed", "cancelled":
|
||||
query = "UPDATE jobs SET status = ?, finished_at = CURRENT_TIMESTAMP WHERE id = ?"
|
||||
args = []interface{}{status, id}
|
||||
default:
|
||||
query = "UPDATE jobs SET status = ? WHERE id = ?"
|
||||
args = []interface{}{status, id}
|
||||
}
|
||||
_, err := r.db.Exec(query, args...)
|
||||
return err
|
||||
}
|
||||
|
||||
func (r *JobRepository) SetLogFile(id int64, path string) error {
|
||||
_, err := r.db.Exec("UPDATE jobs SET log_file = ? WHERE id = ?", path, id)
|
||||
return err
|
||||
}
|
||||
|
||||
func (r *JobRepository) GetRunningBySyncPair(syncPairID int64) (*Job, error) {
|
||||
var j Job
|
||||
var started sql.NullTime
|
||||
var logFile sql.NullString
|
||||
err := r.db.QueryRow(`
|
||||
SELECT id, sync_pair_id, trigger_type, status, started_at, finished_at,
|
||||
log_file, created_at FROM jobs
|
||||
WHERE sync_pair_id = ? AND status IN ('queued','waking_up','running')
|
||||
ORDER BY created_at DESC LIMIT 1`, syncPairID).Scan(
|
||||
&j.ID, &j.SyncPairID, &j.TriggerType, &j.Status, &started,
|
||||
&j.FinishedAt, &logFile, &j.CreatedAt)
|
||||
if err != nil {
|
||||
return nil, err
|
||||
}
|
||||
if started.Valid {
|
||||
j.StartedAt = &started.Time
|
||||
}
|
||||
if logFile.Valid {
|
||||
j.LogFile = &logFile.String
|
||||
}
|
||||
return &j, nil
|
||||
}
|
||||
|
||||
func (r *JobRepository) Count() (int64, error) {
|
||||
var n int64
|
||||
err := r.db.QueryRow("SELECT COUNT(*) FROM jobs").Scan(&n)
|
||||
return n, err
|
||||
}
|
||||
@@ -0,0 +1,161 @@
|
||||
package models
|
||||
|
||||
import (
|
||||
"database/sql"
|
||||
"time"
|
||||
)
|
||||
|
||||
type Machine struct {
|
||||
ID int64 `db:"id" json:"id"`
|
||||
Name string `db:"name" json:"name"`
|
||||
Host string `db:"host" json:"host"`
|
||||
Port int `db:"port" json:"port"`
|
||||
SSHUser string `db:"ssh_user" json:"ssh_user"`
|
||||
SSHKeyID *int64 `db:"ssh_key_id" json:"ssh_key_id"`
|
||||
MACAddress *string `db:"mac_address" json:"mac_address"`
|
||||
WoLEnabled bool `db:"wol_enabled" json:"wol_enabled"`
|
||||
BroadcastAddr *string `db:"broadcast_addr" json:"broadcast_addr"`
|
||||
WakeTimeoutSeconds int `db:"wake_timeout_seconds" json:"wake_timeout_seconds"`
|
||||
WakeCheckIntervalSeconds int `db:"wake_check_interval_seconds" json:"wake_check_interval_seconds"`
|
||||
FingerprintConfirmed bool `db:"fingerprint_confirmed" json:"fingerprint_confirmed"`
|
||||
Status string `db:"status" json:"status"`
|
||||
LastSeenAt *time.Time `db:"last_seen_at" json:"last_seen_at"`
|
||||
CreatedAt time.Time `db:"created_at" json:"created_at"`
|
||||
}
|
||||
|
||||
type MachineRepository struct {
|
||||
db *sql.DB
|
||||
}
|
||||
|
||||
func NewMachineRepository(db *sql.DB) *MachineRepository {
|
||||
return &MachineRepository{db: db}
|
||||
}
|
||||
|
||||
func (r *MachineRepository) Create(m *Machine) (int64, error) {
|
||||
res, err := r.db.Exec(`
|
||||
INSERT INTO machines (name, host, port, ssh_user, ssh_key_id, mac_address,
|
||||
wol_enabled, broadcast_addr, wake_timeout_seconds, wake_check_interval_seconds,
|
||||
fingerprint_confirmed, status)
|
||||
VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`,
|
||||
m.Name, m.Host, m.Port, m.SSHUser, m.SSHKeyID, m.MACAddress,
|
||||
boolToInt(m.WoLEnabled), m.BroadcastAddr, m.WakeTimeoutSeconds,
|
||||
m.WakeCheckIntervalSeconds, boolToInt(m.FingerprintConfirmed), m.Status,
|
||||
)
|
||||
if err != nil {
|
||||
return 0, err
|
||||
}
|
||||
return res.LastInsertId()
|
||||
}
|
||||
|
||||
func (r *MachineRepository) GetAll() ([]Machine, error) {
|
||||
rows, err := r.db.Query(`
|
||||
SELECT id, name, host, port, ssh_user, ssh_key_id, mac_address,
|
||||
wol_enabled, broadcast_addr, wake_timeout_seconds, wake_check_interval_seconds,
|
||||
fingerprint_confirmed, status, last_seen_at, created_at
|
||||
FROM machines ORDER BY name`)
|
||||
if err != nil {
|
||||
return nil, err
|
||||
}
|
||||
defer rows.Close()
|
||||
|
||||
var ms []Machine
|
||||
for rows.Next() {
|
||||
var m Machine
|
||||
var mac, bcast sql.NullString
|
||||
var keyID sql.NullInt64
|
||||
var lastSeen sql.NullTime
|
||||
err := rows.Scan(&m.ID, &m.Name, &m.Host, &m.Port, &m.SSHUser, &keyID,
|
||||
&mac, &m.WoLEnabled, &bcast, &m.WakeTimeoutSeconds,
|
||||
&m.WakeCheckIntervalSeconds, &m.FingerprintConfirmed,
|
||||
&m.Status, &lastSeen, &m.CreatedAt)
|
||||
if err != nil {
|
||||
return nil, err
|
||||
}
|
||||
if keyID.Valid {
|
||||
v := keyID.Int64
|
||||
m.SSHKeyID = &v
|
||||
}
|
||||
if mac.Valid {
|
||||
m.MACAddress = &mac.String
|
||||
}
|
||||
if bcast.Valid {
|
||||
m.BroadcastAddr = &bcast.String
|
||||
}
|
||||
if lastSeen.Valid {
|
||||
m.LastSeenAt = &lastSeen.Time
|
||||
}
|
||||
ms = append(ms, m)
|
||||
}
|
||||
return ms, rows.Err()
|
||||
}
|
||||
|
||||
func (r *MachineRepository) GetByID(id int64) (*Machine, error) {
|
||||
var m Machine
|
||||
var mac, bcast sql.NullString
|
||||
var keyID sql.NullInt64
|
||||
var lastSeen sql.NullTime
|
||||
err := r.db.QueryRow(`
|
||||
SELECT id, name, host, port, ssh_user, ssh_key_id, mac_address,
|
||||
wol_enabled, broadcast_addr, wake_timeout_seconds, wake_check_interval_seconds,
|
||||
fingerprint_confirmed, status, last_seen_at, created_at
|
||||
FROM machines WHERE id = ?`, id).Scan(
|
||||
&m.ID, &m.Name, &m.Host, &m.Port, &m.SSHUser, &keyID,
|
||||
&mac, &m.WoLEnabled, &bcast, &m.WakeTimeoutSeconds,
|
||||
&m.WakeCheckIntervalSeconds, &m.FingerprintConfirmed,
|
||||
&m.Status, &lastSeen, &m.CreatedAt)
|
||||
if err != nil {
|
||||
return nil, err
|
||||
}
|
||||
if keyID.Valid {
|
||||
v := keyID.Int64
|
||||
m.SSHKeyID = &v
|
||||
}
|
||||
if mac.Valid {
|
||||
m.MACAddress = &mac.String
|
||||
}
|
||||
if bcast.Valid {
|
||||
m.BroadcastAddr = &bcast.String
|
||||
}
|
||||
if lastSeen.Valid {
|
||||
m.LastSeenAt = &lastSeen.Time
|
||||
}
|
||||
return &m, nil
|
||||
}
|
||||
|
||||
func (r *MachineRepository) Update(m *Machine) error {
|
||||
_, err := r.db.Exec(`
|
||||
UPDATE machines SET name=?, host=?, port=?, ssh_user=?, ssh_key_id=?,
|
||||
mac_address=?, wol_enabled=?, broadcast_addr=?, wake_timeout_seconds=?,
|
||||
wake_check_interval_seconds=?, fingerprint_confirmed=?, status=?, last_seen_at=?
|
||||
WHERE id=?`,
|
||||
m.Name, m.Host, m.Port, m.SSHUser, m.SSHKeyID, m.MACAddress,
|
||||
boolToInt(m.WoLEnabled), m.BroadcastAddr, m.WakeTimeoutSeconds,
|
||||
m.WakeCheckIntervalSeconds, boolToInt(m.FingerprintConfirmed),
|
||||
m.Status, m.LastSeenAt, m.ID,
|
||||
)
|
||||
return err
|
||||
}
|
||||
|
||||
func (r *MachineRepository) Delete(id int64) error {
|
||||
_, err := r.db.Exec("DELETE FROM machines WHERE id = ?", id)
|
||||
return err
|
||||
}
|
||||
|
||||
func (r *MachineRepository) UpdateStatus(id int64, status string) error {
|
||||
_, err := r.db.Exec(
|
||||
"UPDATE machines SET status = ?, last_seen_at = CURRENT_TIMESTAMP WHERE id = ?",
|
||||
status, id,
|
||||
)
|
||||
return err
|
||||
}
|
||||
|
||||
func boolToInt(b bool) int {
|
||||
if b {
|
||||
return 1
|
||||
}
|
||||
return 0
|
||||
}
|
||||
|
||||
func intToBool(i int) bool {
|
||||
return i != 0
|
||||
}
|
||||
@@ -0,0 +1,124 @@
|
||||
package models
|
||||
|
||||
import (
|
||||
"database/sql"
|
||||
"time"
|
||||
)
|
||||
|
||||
type Schedule struct {
|
||||
ID int64 `db:"id" json:"id"`
|
||||
SyncPairID int64 `db:"sync_pair_id" json:"sync_pair_id"`
|
||||
CronExpr string `db:"cron_expr" json:"cron_expr"`
|
||||
NextRunAt *time.Time `db:"next_run_at" json:"next_run_at"`
|
||||
Enabled bool `db:"enabled" json:"enabled"`
|
||||
CreatedAt time.Time `db:"created_at" json:"created_at"`
|
||||
}
|
||||
|
||||
type ScheduleRepository struct {
|
||||
db *sql.DB
|
||||
}
|
||||
|
||||
func NewScheduleRepository(db *sql.DB) *ScheduleRepository {
|
||||
return &ScheduleRepository{db: db}
|
||||
}
|
||||
|
||||
func (r *ScheduleRepository) Create(s *Schedule) (int64, error) {
|
||||
res, err := r.db.Exec(`
|
||||
INSERT INTO schedules (sync_pair_id, cron_expr, next_run_at, enabled)
|
||||
VALUES (?, ?, ?, ?)`,
|
||||
s.SyncPairID, s.CronExpr, s.NextRunAt, boolToInt(s.Enabled),
|
||||
)
|
||||
if err != nil {
|
||||
return 0, err
|
||||
}
|
||||
return res.LastInsertId()
|
||||
}
|
||||
|
||||
func (r *ScheduleRepository) GetAll() ([]Schedule, error) {
|
||||
rows, err := r.db.Query(`
|
||||
SELECT id, sync_pair_id, cron_expr, next_run_at, enabled, created_at
|
||||
FROM schedules ORDER BY id`)
|
||||
if err != nil {
|
||||
return nil, err
|
||||
}
|
||||
defer rows.Close()
|
||||
|
||||
var schedules []Schedule
|
||||
for rows.Next() {
|
||||
var s Schedule
|
||||
var nextRun sql.NullTime
|
||||
if err := rows.Scan(&s.ID, &s.SyncPairID, &s.CronExpr, &nextRun,
|
||||
&s.Enabled, &s.CreatedAt); err != nil {
|
||||
return nil, err
|
||||
}
|
||||
if nextRun.Valid {
|
||||
s.NextRunAt = &nextRun.Time
|
||||
}
|
||||
s.Enabled = intToBool(intToInt(s.Enabled))
|
||||
schedules = append(schedules, s)
|
||||
}
|
||||
return schedules, rows.Err()
|
||||
}
|
||||
|
||||
func (r *ScheduleRepository) GetByID(id int64) (*Schedule, error) {
|
||||
var s Schedule
|
||||
var nextRun sql.NullTime
|
||||
err := r.db.QueryRow(`
|
||||
SELECT id, sync_pair_id, cron_expr, next_run_at, enabled, created_at
|
||||
FROM schedules WHERE id = ?`, id).Scan(
|
||||
&s.ID, &s.SyncPairID, &s.CronExpr, &nextRun, &s.Enabled, &s.CreatedAt)
|
||||
if err != nil {
|
||||
return nil, err
|
||||
}
|
||||
if nextRun.Valid {
|
||||
s.NextRunAt = &nextRun.Time
|
||||
}
|
||||
s.Enabled = intToBool(intToInt(s.Enabled))
|
||||
return &s, nil
|
||||
}
|
||||
|
||||
func (r *ScheduleRepository) Update(s *Schedule) error {
|
||||
_, err := r.db.Exec(`
|
||||
UPDATE schedules SET sync_pair_id=?, cron_expr=?, next_run_at=?, enabled=?
|
||||
WHERE id=?`,
|
||||
s.SyncPairID, s.CronExpr, s.NextRunAt, boolToInt(s.Enabled), s.ID,
|
||||
)
|
||||
return err
|
||||
}
|
||||
|
||||
func (r *ScheduleRepository) Delete(id int64) error {
|
||||
_, err := r.db.Exec("DELETE FROM schedules WHERE id = ?", id)
|
||||
return err
|
||||
}
|
||||
|
||||
func (r *ScheduleRepository) GetEnabledDue(before time.Time) ([]Schedule, error) {
|
||||
rows, err := r.db.Query(`
|
||||
SELECT id, sync_pair_id, cron_expr, next_run_at, enabled, created_at
|
||||
FROM schedules WHERE enabled = 1 AND next_run_at IS NOT NULL AND next_run_at <= ?
|
||||
ORDER BY next_run_at`, before)
|
||||
if err != nil {
|
||||
return nil, err
|
||||
}
|
||||
defer rows.Close()
|
||||
|
||||
var schedules []Schedule
|
||||
for rows.Next() {
|
||||
var s Schedule
|
||||
var nextRun sql.NullTime
|
||||
if err := rows.Scan(&s.ID, &s.SyncPairID, &s.CronExpr, &nextRun,
|
||||
&s.Enabled, &s.CreatedAt); err != nil {
|
||||
return nil, err
|
||||
}
|
||||
if nextRun.Valid {
|
||||
s.NextRunAt = &nextRun.Time
|
||||
}
|
||||
s.Enabled = true
|
||||
schedules = append(schedules, s)
|
||||
}
|
||||
return schedules, rows.Err()
|
||||
}
|
||||
|
||||
func (r *ScheduleRepository) UpdateNextRun(id int64, nextRun time.Time) error {
|
||||
_, err := r.db.Exec("UPDATE schedules SET next_run_at = ? WHERE id = ?", nextRun, id)
|
||||
return err
|
||||
}
|
||||
@@ -0,0 +1,80 @@
|
||||
package models
|
||||
|
||||
import (
|
||||
"database/sql"
|
||||
"time"
|
||||
)
|
||||
|
||||
type SSHKey struct {
|
||||
ID int64 `db:"id" json:"id"`
|
||||
Label string `db:"label" json:"label"`
|
||||
PrivateKeyPath string `db:"private_key_path" json:"-"`
|
||||
PublicKey string `db:"public_key" json:"public_key"`
|
||||
CreatedAt time.Time `db:"created_at" json:"created_at"`
|
||||
}
|
||||
|
||||
type SSHKeyRepository struct {
|
||||
db *sql.DB
|
||||
}
|
||||
|
||||
func NewSSHKeyRepository(db *sql.DB) *SSHKeyRepository {
|
||||
return &SSHKeyRepository{db: db}
|
||||
}
|
||||
|
||||
func (r *SSHKeyRepository) Create(label, privPath, pubKey string) (int64, error) {
|
||||
res, err := r.db.Exec(
|
||||
"INSERT INTO ssh_keys (label, private_key_path, public_key) VALUES (?, ?, ?)",
|
||||
label, privPath, pubKey,
|
||||
)
|
||||
if err != nil {
|
||||
return 0, err
|
||||
}
|
||||
return res.LastInsertId()
|
||||
}
|
||||
|
||||
func (r *SSHKeyRepository) GetByID(id int64) (*SSHKey, error) {
|
||||
var k SSHKey
|
||||
err := r.db.QueryRow(
|
||||
"SELECT id, label, private_key_path, public_key, created_at FROM ssh_keys WHERE id = ?",
|
||||
id,
|
||||
).Scan(&k.ID, &k.Label, &k.PrivateKeyPath, &k.PublicKey, &k.CreatedAt)
|
||||
if err != nil {
|
||||
return nil, err
|
||||
}
|
||||
return &k, nil
|
||||
}
|
||||
|
||||
func (r *SSHKeyRepository) GetAll() ([]SSHKey, error) {
|
||||
rows, err := r.db.Query(
|
||||
"SELECT id, label, private_key_path, public_key, created_at FROM ssh_keys ORDER BY label")
|
||||
if err != nil {
|
||||
return nil, err
|
||||
}
|
||||
defer rows.Close()
|
||||
|
||||
var keys []SSHKey
|
||||
for rows.Next() {
|
||||
var k SSHKey
|
||||
if err := rows.Scan(&k.ID, &k.Label, &k.PrivateKeyPath, &k.PublicKey, &k.CreatedAt); err != nil {
|
||||
return nil, err
|
||||
}
|
||||
keys = append(keys, k)
|
||||
}
|
||||
return keys, rows.Err()
|
||||
}
|
||||
|
||||
func (r *SSHKeyRepository) Delete(id int64) error {
|
||||
_, err := r.db.Exec("DELETE FROM ssh_keys WHERE id = ?", id)
|
||||
return err
|
||||
}
|
||||
|
||||
func (r *SSHKeyRepository) GetServerKey() (*SSHKey, error) {
|
||||
var k SSHKey
|
||||
err := r.db.QueryRow(
|
||||
"SELECT id, label, private_key_path, public_key, created_at FROM ssh_keys WHERE label = 'server' LIMIT 1",
|
||||
).Scan(&k.ID, &k.Label, &k.PrivateKeyPath, &k.PublicKey, &k.CreatedAt)
|
||||
if err != nil {
|
||||
return nil, err
|
||||
}
|
||||
return &k, nil
|
||||
}
|
||||
@@ -0,0 +1,181 @@
|
||||
package models
|
||||
|
||||
import (
|
||||
"database/sql"
|
||||
"strings"
|
||||
"time"
|
||||
)
|
||||
|
||||
type SyncPair struct {
|
||||
ID int64 `db:"id" json:"id"`
|
||||
Name string `db:"name" json:"name"`
|
||||
SourceMachineID *int64 `db:"source_machine_id" json:"source_machine_id"`
|
||||
SourcePath string `db:"source_path" json:"source_path"`
|
||||
DestMachineID *int64 `db:"dest_machine_id" json:"dest_machine_id"`
|
||||
DestPath string `db:"dest_path" json:"dest_path"`
|
||||
Direction string `db:"direction" json:"direction"`
|
||||
RsyncFlags string `db:"rsync_flags" json:"rsync_flags"`
|
||||
ExcludePatterns string `db:"exclude_patterns" json:"exclude_patterns"`
|
||||
Enabled bool `db:"enabled" json:"enabled"`
|
||||
CreatedAt time.Time `db:"created_at" json:"created_at"`
|
||||
}
|
||||
|
||||
type SyncPairRepository struct {
|
||||
db *sql.DB
|
||||
}
|
||||
|
||||
func NewSyncPairRepository(db *sql.DB) *SyncPairRepository {
|
||||
return &SyncPairRepository{db: db}
|
||||
}
|
||||
|
||||
func (r *SyncPairRepository) Create(sp *SyncPair) (int64, error) {
|
||||
res, err := r.db.Exec(`
|
||||
INSERT INTO sync_pairs (name, source_machine_id, source_path, dest_machine_id,
|
||||
dest_path, direction, rsync_flags, exclude_patterns, enabled)
|
||||
VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?)`,
|
||||
sp.Name, sp.SourceMachineID, sp.SourcePath, sp.DestMachineID,
|
||||
sp.DestPath, sp.Direction, sp.RsyncFlags, sp.ExcludePatterns, boolToInt(sp.Enabled),
|
||||
)
|
||||
if err != nil {
|
||||
return 0, err
|
||||
}
|
||||
return res.LastInsertId()
|
||||
}
|
||||
|
||||
func (r *SyncPairRepository) GetAll() ([]SyncPair, error) {
|
||||
rows, err := r.db.Query(`
|
||||
SELECT id, name, source_machine_id, source_path, dest_machine_id, dest_path,
|
||||
direction, rsync_flags, exclude_patterns, enabled, created_at
|
||||
FROM sync_pairs ORDER BY name`)
|
||||
if err != nil {
|
||||
return nil, err
|
||||
}
|
||||
defer rows.Close()
|
||||
|
||||
var pairs []SyncPair
|
||||
for rows.Next() {
|
||||
var p SyncPair
|
||||
var srcID, dstID sql.NullInt64
|
||||
if err := rows.Scan(&p.ID, &p.Name, &srcID, &p.SourcePath, &dstID,
|
||||
&p.DestPath, &p.Direction, &p.RsyncFlags, &p.ExcludePatterns,
|
||||
&p.Enabled, &p.CreatedAt); err != nil {
|
||||
return nil, err
|
||||
}
|
||||
if srcID.Valid {
|
||||
v := srcID.Int64
|
||||
p.SourceMachineID = &v
|
||||
}
|
||||
if dstID.Valid {
|
||||
v := dstID.Int64
|
||||
p.DestMachineID = &v
|
||||
}
|
||||
p.Enabled = intToBool(intToInt(p.Enabled))
|
||||
pairs = append(pairs, p)
|
||||
}
|
||||
return pairs, rows.Err()
|
||||
}
|
||||
|
||||
func intToInt(v interface{}) int {
|
||||
switch x := v.(type) {
|
||||
case int:
|
||||
return x
|
||||
case int64:
|
||||
return int(x)
|
||||
case bool:
|
||||
if x {
|
||||
return 1
|
||||
}
|
||||
return 0
|
||||
default:
|
||||
return 0
|
||||
}
|
||||
}
|
||||
|
||||
func (r *SyncPairRepository) GetByID(id int64) (*SyncPair, error) {
|
||||
var p SyncPair
|
||||
var srcID, dstID sql.NullInt64
|
||||
err := r.db.QueryRow(`
|
||||
SELECT id, name, source_machine_id, source_path, dest_machine_id, dest_path,
|
||||
direction, rsync_flags, exclude_patterns, enabled, created_at
|
||||
FROM sync_pairs WHERE id = ?`, id).Scan(
|
||||
&p.ID, &p.Name, &srcID, &p.SourcePath, &dstID,
|
||||
&p.DestPath, &p.Direction, &p.RsyncFlags, &p.ExcludePatterns,
|
||||
&p.Enabled, &p.CreatedAt)
|
||||
if err != nil {
|
||||
return nil, err
|
||||
}
|
||||
if srcID.Valid {
|
||||
v := srcID.Int64
|
||||
p.SourceMachineID = &v
|
||||
}
|
||||
if dstID.Valid {
|
||||
v := dstID.Int64
|
||||
p.DestMachineID = &v
|
||||
}
|
||||
p.Enabled = intToBool(intToInt(p.Enabled))
|
||||
return &p, nil
|
||||
}
|
||||
|
||||
func (r *SyncPairRepository) Update(sp *SyncPair) error {
|
||||
_, err := r.db.Exec(`
|
||||
UPDATE sync_pairs SET name=?, source_machine_id=?, source_path=?, dest_machine_id=?,
|
||||
dest_path=?, direction=?, rsync_flags=?, exclude_patterns=?, enabled=?
|
||||
WHERE id=?`,
|
||||
sp.Name, sp.SourceMachineID, sp.SourcePath, sp.DestMachineID,
|
||||
sp.DestPath, sp.Direction, sp.RsyncFlags, sp.ExcludePatterns,
|
||||
boolToInt(sp.Enabled), sp.ID,
|
||||
)
|
||||
return err
|
||||
}
|
||||
|
||||
func (r *SyncPairRepository) Delete(id int64) error {
|
||||
_, err := r.db.Exec("DELETE FROM sync_pairs WHERE id = ?", id)
|
||||
return err
|
||||
}
|
||||
|
||||
func (r *SyncPairRepository) GetEnabled() ([]SyncPair, error) {
|
||||
rows, err := r.db.Query(`
|
||||
SELECT id, name, source_machine_id, source_path, dest_machine_id, dest_path,
|
||||
direction, rsync_flags, exclude_patterns, enabled, created_at
|
||||
FROM sync_pairs WHERE enabled = 1`)
|
||||
if err != nil {
|
||||
return nil, err
|
||||
}
|
||||
defer rows.Close()
|
||||
|
||||
var pairs []SyncPair
|
||||
for rows.Next() {
|
||||
var p SyncPair
|
||||
var srcID, dstID sql.NullInt64
|
||||
if err := rows.Scan(&p.ID, &p.Name, &srcID, &p.SourcePath, &dstID,
|
||||
&p.DestPath, &p.Direction, &p.RsyncFlags, &p.ExcludePatterns,
|
||||
&p.Enabled, &p.CreatedAt); err != nil {
|
||||
return nil, err
|
||||
}
|
||||
if srcID.Valid {
|
||||
v := srcID.Int64
|
||||
p.SourceMachineID = &v
|
||||
}
|
||||
if dstID.Valid {
|
||||
v := dstID.Int64
|
||||
p.DestMachineID = &v
|
||||
}
|
||||
p.Enabled = true
|
||||
pairs = append(pairs, p)
|
||||
}
|
||||
return pairs, rows.Err()
|
||||
}
|
||||
|
||||
func (sp *SyncPair) ExcludePatternsList() []string {
|
||||
if sp.ExcludePatterns == "" {
|
||||
return nil
|
||||
}
|
||||
var patterns []string
|
||||
for _, p := range strings.Split(sp.ExcludePatterns, "\n") {
|
||||
p = strings.TrimSpace(p)
|
||||
if p != "" {
|
||||
patterns = append(patterns, p)
|
||||
}
|
||||
}
|
||||
return patterns
|
||||
}
|
||||
@@ -0,0 +1,66 @@
|
||||
package models
|
||||
|
||||
import (
|
||||
"database/sql"
|
||||
"time"
|
||||
)
|
||||
|
||||
type User struct {
|
||||
ID int64 `db:"id" json:"id"`
|
||||
Username string `db:"username" json:"username"`
|
||||
PasswordHash string `db:"password_hash" json:"-"`
|
||||
Role string `db:"role" json:"role"`
|
||||
CreatedAt time.Time `db:"created_at" json:"created_at"`
|
||||
}
|
||||
|
||||
type UserRepository struct {
|
||||
db *sql.DB
|
||||
}
|
||||
|
||||
func NewUserRepository(db *sql.DB) *UserRepository {
|
||||
return &UserRepository{db: db}
|
||||
}
|
||||
|
||||
func (r *UserRepository) Create(username, passwordHash, role string) (int64, error) {
|
||||
res, err := r.db.Exec(
|
||||
"INSERT INTO users (username, password_hash, role) VALUES (?, ?, ?)",
|
||||
username, passwordHash, role,
|
||||
)
|
||||
if err != nil {
|
||||
return 0, err
|
||||
}
|
||||
return res.LastInsertId()
|
||||
}
|
||||
|
||||
func (r *UserRepository) GetByUsername(username string) (*User, error) {
|
||||
var u User
|
||||
err := r.db.QueryRow(
|
||||
"SELECT id, username, password_hash, role, created_at FROM users WHERE username = ?",
|
||||
username,
|
||||
).Scan(&u.ID, &u.Username, &u.PasswordHash, &u.Role, &u.CreatedAt)
|
||||
if err != nil {
|
||||
return nil, err
|
||||
}
|
||||
return &u, nil
|
||||
}
|
||||
|
||||
func (r *UserRepository) Exists() (bool, error) {
|
||||
var n int
|
||||
err := r.db.QueryRow("SELECT COUNT(*) FROM users").Scan(&n)
|
||||
if err != nil {
|
||||
return false, err
|
||||
}
|
||||
return n > 0, nil
|
||||
}
|
||||
|
||||
func (r *UserRepository) GetByID(id int64) (*User, error) {
|
||||
var u User
|
||||
err := r.db.QueryRow(
|
||||
"SELECT id, username, password_hash, role, created_at FROM users WHERE id = ?",
|
||||
id,
|
||||
).Scan(&u.ID, &u.Username, &u.PasswordHash, &u.Role, &u.CreatedAt)
|
||||
if err != nil {
|
||||
return nil, err
|
||||
}
|
||||
return &u, nil
|
||||
}
|
||||
Reference in New Issue
Block a user