Izvuci logger/ - dijagnostika firmvera nema veze sa licencom
Prijemnik dijagnostike sa TERMINIA uredjaja je alat za trazenje kvarova u FIRMVERU. Nema nikakve veze sa izdavanjem i proverom licenci, a stajao je u ovom repou samo zato sto je i on serverski Go kod. Posledica koja je to i otkrila: da bi se pustio dijagnosticki alat, morao bi 'git pull' u repou od kog zavisi naplata - na produkciji. Dve nepovezane stvari ne smeju da se povlace jedna za drugom. Preseljeno u repo asp-terminia (uz firmver koji i sluzi da se debaguje). NIJE deployovano nigde.
This commit is contained in:
Nenad Djukic
parent
3480766c3e
commit
cee4a2c7dd
152
logger/README.md
152
logger/README.md
@ -1,152 +0,0 @@
|
|||||||
# Prijemnik dijagnostike sa TERMINIA uređaja
|
|
||||||
|
|
||||||
Mali samostalan servis: sluša UDP pakete koje terminal šalje (dnevnik rada i
|
|
||||||
heartbeat), piše ih u fajlove po uređaju i po danu, i prikazuje na jednoj
|
|
||||||
web stranici.
|
|
||||||
|
|
||||||
- **Nema bazu**, nema spoljnih Go zavisnosti (samo standardna biblioteka).
|
|
||||||
- **Ne dira licencni servis** — zaseban proces, zaseban port, zaseban
|
|
||||||
systemd unit. Deli samo Go modul (isti repo).
|
|
||||||
- Ugovor o formatu paketa: ASP repo, `docs/24-servisni-kanal.md`.
|
|
||||||
|
|
||||||
## Šta prima
|
|
||||||
|
|
||||||
| Vrsta | Kako se prepoznaje | Šta radi sa njim |
|
|
||||||
|---|---|---|
|
|
||||||
| Dnevnik rada (dbg) | čist tekst; prvi red `#TERMINIA <naziv> <MAC> <fw>` | linije se upisuju u fajl uređaja |
|
|
||||||
| Heartbeat | paket počinje sa `{` (JSON sa `"hb":1`) | pamti se u memoriji (naziv, MAC, IP, FW, vreme) |
|
|
||||||
| Sve ostalo | — | tiho se odbacuje, brojač „odbačeno" na stranici |
|
|
||||||
|
|
||||||
**Zaglavlje dnevnika postoji tek od FW 0.13.4.** Stariji uređaj šalje goli
|
|
||||||
tekst — takav se vodi kao **nepoznat uređaj**, razvrstava po izvornoj IP
|
|
||||||
adresi i tako je i **označen na stranici** (ne pravimo se da znamo ko je).
|
|
||||||
|
|
||||||
Prijemnik **ne odgovara** na pakete. Prijem naloga na uređaju nije
|
|
||||||
implementiran i traži potpis (docs/24 §3.2), pa slanja naloga ovde nema.
|
|
||||||
|
|
||||||
## Web stranica
|
|
||||||
|
|
||||||
| Ruta | Šta daje |
|
|
||||||
|---|---|
|
|
||||||
| `/` | spisak uređaja: naziv, MAC, IP, FW, „poslednji put pre X"; **crveno** = nije se javio duže od 3× svog intervala |
|
|
||||||
| `/uredjaj?k=<ključ>&q=<pretraga>&n=<broj>` | poslednjih N linija dnevnika, sa pretragom po tekstu |
|
|
||||||
| `/dnevnik.txt?k=<ključ>&n=&q=` | isto, kao čist tekst (za `curl`) |
|
|
||||||
| `/api/uredjaji` | JSON spisak uređaja (za alate) |
|
|
||||||
|
|
||||||
Interval javljanja se **meri** iz razmaka između dva heartbeat-a; dok ga nema,
|
|
||||||
koristi se `LOGGER_HB_DEFAULT_SEC`.
|
|
||||||
|
|
||||||
## Pokretanje lokalno
|
|
||||||
|
|
||||||
```powershell
|
|
||||||
cd D:\Terminia\TERMINIA-SOFTWARE\licence-server
|
|
||||||
go build -o terminia-logger.exe .\logger\cmd\terminia-logger
|
|
||||||
|
|
||||||
$env:LOGGER_UDP_PORT="46465"
|
|
||||||
$env:LOGGER_HTTP_PORT="8081"
|
|
||||||
$env:LOGGER_DIR="D:\Terminia\TERMINIA-SOFTWARE\licence-server\data\logger"
|
|
||||||
.\terminia-logger.exe
|
|
||||||
```
|
|
||||||
|
|
||||||
Zatim otvoriti `http://127.0.0.1:8081`.
|
|
||||||
|
|
||||||
Proba bez uređaja (PowerShell, u drugom prozoru):
|
|
||||||
|
|
||||||
```powershell
|
|
||||||
$u=New-Object System.Net.Sockets.UdpClient; $u.Connect("127.0.0.1",46465)
|
|
||||||
function Send($s){ $b=[System.Text.Encoding]::UTF8.GetBytes($s); [void]$u.Send($b,$b.Length) }
|
|
||||||
Send '{"app":"TERMINIA","name":"TERM-001","mac":"1C:DB:D4:A6:A4:60","ip":"192.168.0.20","fw":"0.13.4","hb":1}'
|
|
||||||
Send "#TERMINIA TERM-001 1C:DB:D4:A6:A4:60 0.13.4`n[stampac] javio se na 192.168.123.100`n"
|
|
||||||
$u.Close()
|
|
||||||
```
|
|
||||||
|
|
||||||
Testovi:
|
|
||||||
|
|
||||||
```powershell
|
|
||||||
go test ./logger/...
|
|
||||||
```
|
|
||||||
|
|
||||||
## Env promenljive
|
|
||||||
|
|
||||||
| Promenljiva | Podrazumevano | Značenje |
|
|
||||||
|---|---|---|
|
|
||||||
| `LOGGER_UDP_PORT` | `46465` | port na koji uređaji šalju. **Ne 46464** — tamo uređaji slušaju discovery |
|
|
||||||
| `LOGGER_UDP_HOST` | (prazno) | adresa za slušanje; prazno = sve |
|
|
||||||
| `LOGGER_HTTP_HOST` | `127.0.0.1` | web sluša samo lokalno jer dnevnik sadrži **brojeve karata** |
|
|
||||||
| `LOGGER_HTTP_PORT` | `8081` | port web pregleda |
|
|
||||||
| `LOGGER_TOKEN` | (prazno) | ako je postavljen, web traži `?t=<token>` (obavezno ako web nije samo lokalni) |
|
|
||||||
| `LOGGER_DIR` | `./data/logger` | folder sa dnevnicima |
|
|
||||||
| `LOGGER_KEEP_DAYS` | `14` | koliko dana se dnevnici čuvaju |
|
|
||||||
| `LOGGER_MAX_FILE_MB` | `10` | preko toga se dnevni fajl rotira (`.log.001`, `.002`…) |
|
|
||||||
| `LOGGER_MAX_DEVICE_MB` | `50` | kvota po uređaju; preko toga se briše najstarije |
|
|
||||||
| `LOGGER_MAX_TOTAL_MB` | `1024` | ukupna kvota za sve uređaje |
|
|
||||||
| `LOGGER_MAX_DEVICES` | `500` | koliko uređaja se drži u memoriji |
|
|
||||||
| `LOGGER_HB_DEFAULT_SEC` | `60` | pretpostavljeni interval dok se ne izmeri |
|
|
||||||
|
|
||||||
Neispravna vrednost = servis se **ne pokreće** i kaže koja promenljiva ne valja
|
|
||||||
(bolje nego da tiho radi sa pogrešnim podešavanjem).
|
|
||||||
|
|
||||||
## Šta se upisuje u uređaj
|
|
||||||
|
|
||||||
U SPA uređaja: **Podešavanja → Servis**
|
|
||||||
|
|
||||||
| Polje | Vrednost |
|
|
||||||
|---|---|
|
|
||||||
| `svcLogHost` | `157.180.119.151:46465` |
|
|
||||||
| „Šalji dnevnik rada na server" | **uključeno** |
|
|
||||||
| heartbeat (`svcHbSeconds`) | npr. `60` |
|
|
||||||
|
|
||||||
Uređaj šalje **samo brojčani IP:port** — domen se ne može upisati (docs/24 §1).
|
|
||||||
|
|
||||||
> ⚠️ Ovo ide preko interneta **u čistom tekstu**, a u dnevniku ima brojeva
|
|
||||||
> karata. Za trajno praćenje flote predviđen je HTTPS kanal (docs/24 §3);
|
|
||||||
> ovaj prijemnik je za dijagnostiku dok se problem lovi.
|
|
||||||
|
|
||||||
## Puštanje na server (radi vlasnik)
|
|
||||||
|
|
||||||
```bash
|
|
||||||
# 1) build na serveru
|
|
||||||
cd /root/projects/licence-server
|
|
||||||
git pull
|
|
||||||
go build -o terminia-logger ./logger/cmd/terminia-logger
|
|
||||||
|
|
||||||
# 2) podešavanja
|
|
||||||
cp logger/deploy/terminia-logger.env.example logger.env
|
|
||||||
$EDITOR logger.env
|
|
||||||
|
|
||||||
# 3) systemd
|
|
||||||
cp logger/deploy/terminia-logger.service /etc/systemd/system/
|
|
||||||
systemctl daemon-reload
|
|
||||||
systemctl enable --now terminia-logger
|
|
||||||
systemctl status terminia-logger
|
|
||||||
journalctl -u terminia-logger -f
|
|
||||||
|
|
||||||
# 4) firewall — SAMO taj port, UDP
|
|
||||||
ufw allow 46465/udp
|
|
||||||
|
|
||||||
# 5) provera sa strane (ne sme da vrati odgovor, samo da ne pukne)
|
|
||||||
echo '#TERMINIA PROBA AA:BB:CC:DD:EE:FF 0.13.4
|
|
||||||
proba veze' | nc -u -w1 157.180.119.151 46465
|
|
||||||
|
|
||||||
# 6) pregled (web je vezan za 127.0.0.1) — SSH tunel sa svog racunara:
|
|
||||||
ssh -L 8081:127.0.0.1:8081 root@157.180.119.151
|
|
||||||
# pa u pregledacu: http://127.0.0.1:8081
|
|
||||||
```
|
|
||||||
|
|
||||||
Ako web treba da bude dostupan bez tunela: postaviti `LOGGER_TOKEN`, staviti
|
|
||||||
nginx ispred sa TLS-om i lozinkom, i tek onda promeniti `LOGGER_HTTP_HOST`.
|
|
||||||
**Ne otvarati port 8081 direktno na internet.**
|
|
||||||
|
|
||||||
Šta ovaj servis **ne dira**: bazu `licence_db`, proces `licence-server`, nginx
|
|
||||||
konfiguraciju, portove 8090/8091/8092.
|
|
||||||
|
|
||||||
## Granice i odbrane
|
|
||||||
|
|
||||||
- Paket može poslati bilo ko: sve iz paketa je ograničeno po dužini, kontrolni
|
|
||||||
znaci se izbacuju, a ime foldera se pravi isključivo od belih znakova
|
|
||||||
(`[A-Za-z0-9_-]`) — sadržaj paketa ne može da odluči gde se piše.
|
|
||||||
- Broj uređaja u memoriji je ograničen; kad se granica dostigne, izbacuje se
|
|
||||||
onaj koji se najduže nije javio.
|
|
||||||
- Dnevnici se brišu po tri pravila redom: starost → kvota po uređaju → ukupna
|
|
||||||
kvota. Fajl koji je trenutno otvoren za pisanje se nikad ne briše.
|
|
||||||
- Greška pri upisu ne obara prijem — vidi se kao brojač „greške upisa".
|
|
||||||
@ -1,35 +0,0 @@
|
|||||||
# Podesavanja prijemnika dijagnostike (systemd EnvironmentFile).
|
|
||||||
# Kopirati u /root/projects/licence-server/logger.env i izmeniti po potrebi.
|
|
||||||
# Sve promenljive su opcione - bez njih vaze podrazumevane vrednosti iz koda.
|
|
||||||
|
|
||||||
# --- mreza ---------------------------------------------------------------
|
|
||||||
# UDP port na koji uredjaji salju dnevnik i heartbeat (svcLogHost = IP:PORT).
|
|
||||||
# NE koristiti 46464 - na tom portu uredjaji slusaju discovery.
|
|
||||||
LOGGER_UDP_PORT=46465
|
|
||||||
# Prazno = slusaj na svim adresama.
|
|
||||||
LOGGER_UDP_HOST=
|
|
||||||
|
|
||||||
# Web pregled. Podrazumevano SAMO lokalno, jer dnevnik sadrzi brojeve karata.
|
|
||||||
# Napolje ide kroz SSH tunel ili nginx sa lozinkom.
|
|
||||||
LOGGER_HTTP_HOST=127.0.0.1
|
|
||||||
LOGGER_HTTP_PORT=8081
|
|
||||||
|
|
||||||
# Ako se web ipak otvori ka mrezi, obavezno postaviti token (pristup: ?t=<token>).
|
|
||||||
# LOGGER_TOKEN=
|
|
||||||
|
|
||||||
# --- dnevnici ------------------------------------------------------------
|
|
||||||
# Folder sa dnevnicima (systemd StateDirectory pravi /var/lib/terminia-logger).
|
|
||||||
LOGGER_DIR=/var/lib/terminia-logger
|
|
||||||
|
|
||||||
# Granice da dnevnici ne napune disk (najstarije se brise prvo).
|
|
||||||
LOGGER_KEEP_DAYS=14
|
|
||||||
LOGGER_MAX_FILE_MB=10
|
|
||||||
LOGGER_MAX_DEVICE_MB=50
|
|
||||||
LOGGER_MAX_TOTAL_MB=1024
|
|
||||||
|
|
||||||
# Najveci broj uredjaja koji se drzi u memoriji (paket moze poslati bilo ko).
|
|
||||||
LOGGER_MAX_DEVICES=500
|
|
||||||
|
|
||||||
# Pretpostavljeni interval javljanja kad ga uredjaj jos nije pokazao.
|
|
||||||
# Uredjaj je "tih" kad se ne javi duze od 3x ovog intervala.
|
|
||||||
LOGGER_HB_DEFAULT_SEC=60
|
|
||||||
@ -1,42 +0,0 @@
|
|||||||
# Prijemnik servisne dijagnostike sa TERMINIA uredjaja.
|
|
||||||
# Obrazac: licence-server.service (vidi docs/SETUP.md), ali BEZ MySQL zavisnosti -
|
|
||||||
# ovaj servis nema bazu i ne dodiruje licencni servis.
|
|
||||||
#
|
|
||||||
# Instalacija:
|
|
||||||
# cp logger/deploy/terminia-logger.service /etc/systemd/system/
|
|
||||||
# cp logger/deploy/terminia-logger.env.example /root/projects/licence-server/logger.env
|
|
||||||
# systemctl daemon-reload && systemctl enable --now terminia-logger
|
|
||||||
|
|
||||||
[Unit]
|
|
||||||
Description=TERMINIA prijemnik dijagnostike (UDP dnevnik + heartbeat)
|
|
||||||
After=network-online.target
|
|
||||||
Wants=network-online.target
|
|
||||||
|
|
||||||
[Service]
|
|
||||||
Type=simple
|
|
||||||
User=root
|
|
||||||
WorkingDirectory=/root/projects/licence-server
|
|
||||||
ExecStart=/root/projects/licence-server/terminia-logger
|
|
||||||
EnvironmentFile=-/root/projects/licence-server/logger.env
|
|
||||||
Restart=always
|
|
||||||
RestartSec=5
|
|
||||||
StandardOutput=journal
|
|
||||||
StandardError=journal
|
|
||||||
SyslogIdentifier=terminia-logger
|
|
||||||
KillMode=mixed
|
|
||||||
KillSignal=SIGTERM
|
|
||||||
TimeoutStopSec=15
|
|
||||||
|
|
||||||
# Dnevnici sadrze BROJEVE KARATA - folder je citljiv samo vlasniku procesa.
|
|
||||||
StateDirectory=terminia-logger
|
|
||||||
StateDirectoryMode=0750
|
|
||||||
|
|
||||||
# Osnovno ogradjivanje: servis samo slusa UDP i pise u svoj folder.
|
|
||||||
NoNewPrivileges=true
|
|
||||||
PrivateTmp=true
|
|
||||||
ProtectSystem=full
|
|
||||||
# ProtectHome se NE ukljucuje: binar i EnvironmentFile stoje pod /root/projects
|
|
||||||
# (isto kao licence-server), a ProtectHome bi taj folder sakrio od servisa.
|
|
||||||
|
|
||||||
[Install]
|
|
||||||
WantedBy=multi-user.target
|
|
||||||
268
logger/packet.go
268
logger/packet.go
@ -1,268 +0,0 @@
|
|||||||
// Package logger je prijemnik servisne dijagnostike sa TERMINIA uredjaja.
|
|
||||||
//
|
|
||||||
// Uredjaj salje dve vrste UDP paketa na isto odrediste (cfg.svcLogHost):
|
|
||||||
// - dnevnik rada (dbg): cist tekst, prvi red je zaglavlje "#TERMINIA ..."
|
|
||||||
// - heartbeat: JSON identitet sa "hb":1
|
|
||||||
//
|
|
||||||
// Ugovor je opisan u ASP repou, docs/24-servisni-kanal.md.
|
|
||||||
package logger
|
|
||||||
|
|
||||||
import (
|
|
||||||
"encoding/json"
|
|
||||||
"net"
|
|
||||||
"strings"
|
|
||||||
"unicode"
|
|
||||||
"unicode/utf8"
|
|
||||||
)
|
|
||||||
|
|
||||||
// Vrsta paketa.
|
|
||||||
type Kind int
|
|
||||||
|
|
||||||
const (
|
|
||||||
KindGarbage Kind = iota // ne prepoznajemo ga - odbacuje se
|
|
||||||
KindHeartbeat // JSON identitet
|
|
||||||
KindLog // linije dnevnika
|
|
||||||
)
|
|
||||||
|
|
||||||
// Tvrde granice. UDP paket moze doci od bilo koga, pa se sve sto ulazi u
|
|
||||||
// memoriju ili u fajl mora ograniciti pre nego sto se dodirne.
|
|
||||||
const (
|
|
||||||
MaxPacketBytes = 4096 // uredjaj salje do ~1100 B; ostalo je visak
|
|
||||||
MaxLinesPerPacket = 64
|
|
||||||
MaxLineLen = 400
|
|
||||||
MaxNameLen = 40
|
|
||||||
MaxFWLen = 24
|
|
||||||
MaxSerialLen = 40
|
|
||||||
MaxKeyLen = 48
|
|
||||||
)
|
|
||||||
|
|
||||||
const headerPrefix = "#TERMINIA"
|
|
||||||
|
|
||||||
// Packet je rezultat parsiranja jednog UDP paketa. Nikad ne sadrzi sirove
|
|
||||||
// bajtove iz mreze - sva polja su prosla kroz sanitizaciju.
|
|
||||||
type Packet struct {
|
|
||||||
Kind Kind
|
|
||||||
Name string
|
|
||||||
MAC string // kanonski "AA:BB:CC:DD:EE:FF", prazan ako ga nema
|
|
||||||
IP string
|
|
||||||
FW string
|
|
||||||
Serial string
|
|
||||||
Identified bool // paket sam kaze ko je (zaglavlje ili heartbeat)
|
|
||||||
Lines []string
|
|
||||||
SourceIP string
|
|
||||||
}
|
|
||||||
|
|
||||||
// heartbeatJSON prati format iz firmvera (pure::discoveryReply + "hb").
|
|
||||||
// Polje "id" postoji zbog starijih/drugacijih klijenata koji serijski broj
|
|
||||||
// salju pod tim imenom - ne kostaje nista, a spasava kompatibilnost.
|
|
||||||
type heartbeatJSON struct {
|
|
||||||
App string `json:"app"`
|
|
||||||
Name string `json:"name"`
|
|
||||||
MAC string `json:"mac"`
|
|
||||||
IP string `json:"ip"`
|
|
||||||
FW string `json:"fw"`
|
|
||||||
Serial string `json:"serial"`
|
|
||||||
ID string `json:"id"`
|
|
||||||
HB json.RawMessage `json:"hb"`
|
|
||||||
}
|
|
||||||
|
|
||||||
// ParsePacket razvrstava jedan primljen paket. Nikad ne panici i nikad ne
|
|
||||||
// vraca gresku - los paket je samo KindGarbage.
|
|
||||||
func ParsePacket(data []byte, sourceIP string) Packet {
|
|
||||||
p := Packet{Kind: KindGarbage, SourceIP: sanitizeText(sourceIP, 45)}
|
|
||||||
if len(data) == 0 {
|
|
||||||
return p
|
|
||||||
}
|
|
||||||
if len(data) > MaxPacketBytes {
|
|
||||||
data = data[:MaxPacketBytes]
|
|
||||||
}
|
|
||||||
body := strings.TrimLeft(string(data), " \t\r\n\x00")
|
|
||||||
if body == "" {
|
|
||||||
return p
|
|
||||||
}
|
|
||||||
if body[0] == '{' {
|
|
||||||
return parseHeartbeat(body, p)
|
|
||||||
}
|
|
||||||
return parseLog(body, p)
|
|
||||||
}
|
|
||||||
|
|
||||||
func parseHeartbeat(body string, p Packet) Packet {
|
|
||||||
var hb heartbeatJSON
|
|
||||||
if err := json.Unmarshal([]byte(body), &hb); err != nil {
|
|
||||||
return p // krnj JSON - odbacujemo, servis se ne ruzi zbog toga
|
|
||||||
}
|
|
||||||
mac, okMac := NormalizeMAC(hb.MAC)
|
|
||||||
name := sanitizeText(hb.Name, MaxNameLen)
|
|
||||||
serial := hb.Serial
|
|
||||||
if serial == "" {
|
|
||||||
serial = hb.ID
|
|
||||||
}
|
|
||||||
// Bez ijednog upotrebljivog polja identiteta paket nema smisla: to je
|
|
||||||
// neki tudji JSON koji je slucajno stigao na nas port.
|
|
||||||
if !okMac && name == "" {
|
|
||||||
return p
|
|
||||||
}
|
|
||||||
p.Kind = KindHeartbeat
|
|
||||||
p.Identified = true
|
|
||||||
p.Name = name
|
|
||||||
p.MAC = mac
|
|
||||||
p.IP = sanitizeIP(hb.IP)
|
|
||||||
p.FW = sanitizeText(hb.FW, MaxFWLen)
|
|
||||||
p.Serial = sanitizeText(serial, MaxSerialLen)
|
|
||||||
return p
|
|
||||||
}
|
|
||||||
|
|
||||||
func parseLog(body string, p Packet) Packet {
|
|
||||||
p.Kind = KindLog
|
|
||||||
raw := strings.Split(body, "\n")
|
|
||||||
if len(raw) > 0 && strings.HasPrefix(raw[0], headerPrefix) {
|
|
||||||
parseHeader(raw[0], &p)
|
|
||||||
raw = raw[1:]
|
|
||||||
}
|
|
||||||
for _, ln := range raw {
|
|
||||||
if len(p.Lines) >= MaxLinesPerPacket {
|
|
||||||
break
|
|
||||||
}
|
|
||||||
s := sanitizeText(ln, MaxLineLen)
|
|
||||||
if s == "" {
|
|
||||||
continue
|
|
||||||
}
|
|
||||||
p.Lines = append(p.Lines, s)
|
|
||||||
}
|
|
||||||
if len(p.Lines) == 0 && !p.Identified {
|
|
||||||
p.Kind = KindGarbage
|
|
||||||
}
|
|
||||||
return p
|
|
||||||
}
|
|
||||||
|
|
||||||
// parseHeader cita "#TERMINIA <naziv> <MAC> <fw>".
|
|
||||||
//
|
|
||||||
// Naziv uredjaja SME da sadrzi razmake (korisnik ga slobodno kuca), pa se ne
|
|
||||||
// oslanjamo na redni broj polja: trazi se prvo polje koje je validan MAC, sve
|
|
||||||
// pre njega je naziv, prvo posle njega je verzija firmvera.
|
|
||||||
func parseHeader(line string, p *Packet) {
|
|
||||||
fields := strings.Fields(strings.TrimPrefix(line, headerPrefix))
|
|
||||||
macAt := -1
|
|
||||||
for i, f := range fields {
|
|
||||||
if _, ok := NormalizeMAC(f); ok {
|
|
||||||
macAt = i
|
|
||||||
break
|
|
||||||
}
|
|
||||||
}
|
|
||||||
if macAt < 0 {
|
|
||||||
// Zaglavlje bez MAC-a nije upotrebljivo za razvrstavanje; ipak
|
|
||||||
// uzimamo naziv ako ga ima, ali uredjaj ostaje "neidentifikovan".
|
|
||||||
if len(fields) > 0 {
|
|
||||||
p.Name = sanitizeText(strings.Join(fields, " "), MaxNameLen)
|
|
||||||
}
|
|
||||||
return
|
|
||||||
}
|
|
||||||
p.MAC, _ = NormalizeMAC(fields[macAt])
|
|
||||||
p.Name = sanitizeText(strings.Join(fields[:macAt], " "), MaxNameLen)
|
|
||||||
if macAt+1 < len(fields) {
|
|
||||||
p.FW = sanitizeText(fields[macAt+1], MaxFWLen)
|
|
||||||
}
|
|
||||||
p.Identified = true
|
|
||||||
}
|
|
||||||
|
|
||||||
// NormalizeMAC prima "1C:DB:D4:A6:A4:60", "1c-db-d4-a6-a4-60" ili
|
|
||||||
// "1CDBD4A6A460" i vraca kanonski oblik sa dvotackama.
|
|
||||||
func NormalizeMAC(s string) (string, bool) {
|
|
||||||
if len(s) > 24 {
|
|
||||||
return "", false
|
|
||||||
}
|
|
||||||
var hex strings.Builder
|
|
||||||
for _, r := range s {
|
|
||||||
switch {
|
|
||||||
case r >= '0' && r <= '9', r >= 'A' && r <= 'F':
|
|
||||||
hex.WriteRune(r)
|
|
||||||
case r >= 'a' && r <= 'f':
|
|
||||||
hex.WriteRune(unicode.ToUpper(r))
|
|
||||||
case r == ':' || r == '-' || r == '.':
|
|
||||||
// razdvajaci se preskacu
|
|
||||||
default:
|
|
||||||
return "", false
|
|
||||||
}
|
|
||||||
}
|
|
||||||
h := hex.String()
|
|
||||||
if len(h) != 12 {
|
|
||||||
return "", false
|
|
||||||
}
|
|
||||||
var out strings.Builder
|
|
||||||
for i := 0; i < 12; i += 2 {
|
|
||||||
if i > 0 {
|
|
||||||
out.WriteByte(':')
|
|
||||||
}
|
|
||||||
out.WriteString(h[i : i+2])
|
|
||||||
}
|
|
||||||
return out.String(), true
|
|
||||||
}
|
|
||||||
|
|
||||||
// DeviceKey je kljuc pod kojim se uredjaj vodi u registru I u imenu foldera.
|
|
||||||
// Kad MAC nedostaje (FW stariji od 0.13.4 salje dnevnik bez zaglavlja), jedino
|
|
||||||
// sto imamo je izvorna IP adresa - takav uredjaj se JASNO oznacava kao
|
|
||||||
// nepoznat, da se ne pravimo da znamo ko je.
|
|
||||||
func DeviceKey(mac, sourceIP string) string {
|
|
||||||
if m, ok := NormalizeMAC(mac); ok {
|
|
||||||
return SanitizeSegment(strings.ReplaceAll(m, ":", ""))
|
|
||||||
}
|
|
||||||
ip := sourceIP
|
|
||||||
if ip == "" {
|
|
||||||
ip = "bez-adrese"
|
|
||||||
}
|
|
||||||
return SanitizeSegment("nepoznat-" + ip)
|
|
||||||
}
|
|
||||||
|
|
||||||
// SanitizeSegment pravi bezbedan deo putanje. Sve sto nije [A-Za-z0-9_-]
|
|
||||||
// postaje '_', pa ".." i "/" ne mogu da prezive - podatak iz paketa nikad ne
|
|
||||||
// sme da odluci gde se pise.
|
|
||||||
func SanitizeSegment(s string) string {
|
|
||||||
var b strings.Builder
|
|
||||||
for _, r := range s {
|
|
||||||
switch {
|
|
||||||
case r >= 'a' && r <= 'z', r >= 'A' && r <= 'Z', r >= '0' && r <= '9', r == '-', r == '_':
|
|
||||||
b.WriteRune(r)
|
|
||||||
default:
|
|
||||||
b.WriteByte('_')
|
|
||||||
}
|
|
||||||
if b.Len() >= MaxKeyLen {
|
|
||||||
break
|
|
||||||
}
|
|
||||||
}
|
|
||||||
out := strings.Trim(b.String(), "_-")
|
|
||||||
if out == "" {
|
|
||||||
return "nepoznat"
|
|
||||||
}
|
|
||||||
return out
|
|
||||||
}
|
|
||||||
|
|
||||||
// sanitizeText izbacuje kontrolne znake (ukljucujuci CR i ESC sekvence koje bi
|
|
||||||
// unakazile ispis u terminalu) i sece string na zadatu duzinu.
|
|
||||||
func sanitizeText(s string, max int) string {
|
|
||||||
var b strings.Builder
|
|
||||||
n := 0
|
|
||||||
for _, r := range s {
|
|
||||||
if r == '\t' {
|
|
||||||
r = ' '
|
|
||||||
}
|
|
||||||
// utf8.RuneError se javlja na neispravnim bajtovima - to je binarno
|
|
||||||
// smece koje je stiglo na port, ne tekst uredjaja.
|
|
||||||
if r < 0x20 || r == 0x7f || r == utf8.RuneError || (!unicode.IsPrint(r) && r != ' ') {
|
|
||||||
continue
|
|
||||||
}
|
|
||||||
b.WriteRune(r)
|
|
||||||
n++
|
|
||||||
if n >= max {
|
|
||||||
break
|
|
||||||
}
|
|
||||||
}
|
|
||||||
return strings.TrimSpace(b.String())
|
|
||||||
}
|
|
||||||
|
|
||||||
func sanitizeIP(s string) string {
|
|
||||||
s = strings.TrimSpace(s)
|
|
||||||
if ip := net.ParseIP(s); ip != nil {
|
|
||||||
return ip.String()
|
|
||||||
}
|
|
||||||
return ""
|
|
||||||
}
|
|
||||||
@ -1,213 +0,0 @@
|
|||||||
package logger
|
|
||||||
|
|
||||||
import (
|
|
||||||
"strings"
|
|
||||||
"testing"
|
|
||||||
)
|
|
||||||
|
|
||||||
func TestParseLogSaZaglavljem(t *testing.T) {
|
|
||||||
raw := "#TERMINIA TERM-001 1C:DB:D4:A6:A4:60 0.13.4\n" +
|
|
||||||
"[stampac] opet se javlja na 192.168.123.100 (ping)\n" +
|
|
||||||
"[izvestaj] dan 20659: 14 karata, 2100 RSD\n"
|
|
||||||
p := ParsePacket([]byte(raw), "192.168.0.20")
|
|
||||||
|
|
||||||
if p.Kind != KindLog {
|
|
||||||
t.Fatalf("vrsta = %v, ocekivano KindLog", p.Kind)
|
|
||||||
}
|
|
||||||
if !p.Identified {
|
|
||||||
t.Error("paket sa zaglavljem mora biti identifikovan")
|
|
||||||
}
|
|
||||||
if p.Name != "TERM-001" || p.MAC != "1C:DB:D4:A6:A4:60" || p.FW != "0.13.4" {
|
|
||||||
t.Errorf("identitet = %q / %q / %q", p.Name, p.MAC, p.FW)
|
|
||||||
}
|
|
||||||
if len(p.Lines) != 2 {
|
|
||||||
t.Fatalf("linija = %d, ocekivano 2: %q", len(p.Lines), p.Lines)
|
|
||||||
}
|
|
||||||
if !strings.HasPrefix(p.Lines[0], "[stampac]") {
|
|
||||||
t.Errorf("prva linija = %q", p.Lines[0])
|
|
||||||
}
|
|
||||||
if got := DeviceKey(p.MAC, p.SourceIP); got != "1CDBD4A6A460" {
|
|
||||||
t.Errorf("kljuc = %q", got)
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
func TestParseZaglavljeSaRazmakomUNazivu(t *testing.T) {
|
|
||||||
// Naziv uredjaja kuca korisnik i sme da ima razmake.
|
|
||||||
p := ParsePacket([]byte("#TERMINIA Bazen Ulaz A 1c-db-d4-a6-a4-60 0.13.4\nzdravo\n"), "10.0.0.5")
|
|
||||||
if p.Name != "Bazen Ulaz A" {
|
|
||||||
t.Errorf("naziv = %q", p.Name)
|
|
||||||
}
|
|
||||||
if p.MAC != "1C:DB:D4:A6:A4:60" {
|
|
||||||
t.Errorf("mac = %q", p.MAC)
|
|
||||||
}
|
|
||||||
if p.FW != "0.13.4" {
|
|
||||||
t.Errorf("fw = %q", p.FW)
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
func TestParseHeartbeat(t *testing.T) {
|
|
||||||
raw := `{"app":"TERMINIA","name":"TERM-001","mac":"1C:DB:D4:A6:A4:60",` +
|
|
||||||
`"ip":"192.168.0.20","fw":"0.13.4","serial":"1CDBD4A6A460","hb":1}`
|
|
||||||
p := ParsePacket([]byte(raw), "192.168.0.20")
|
|
||||||
|
|
||||||
if p.Kind != KindHeartbeat {
|
|
||||||
t.Fatalf("vrsta = %v, ocekivano KindHeartbeat", p.Kind)
|
|
||||||
}
|
|
||||||
if !p.Identified || p.MAC != "1C:DB:D4:A6:A4:60" || p.IP != "192.168.0.20" ||
|
|
||||||
p.FW != "0.13.4" || p.Serial != "1CDBD4A6A460" || p.Name != "TERM-001" {
|
|
||||||
t.Errorf("identitet = %+v", p)
|
|
||||||
}
|
|
||||||
if len(p.Lines) != 0 {
|
|
||||||
t.Errorf("heartbeat ne sme imati linije: %q", p.Lines)
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
func TestParseHeartbeatSaIdPoljem(t *testing.T) {
|
|
||||||
// Stariji/drugaciji klijent salje serijski pod imenom "id".
|
|
||||||
p := ParsePacket([]byte(`{"name":"T","mac":"AABBCCDDEEFF","id":"XYZ","hb":1}`), "10.0.0.1")
|
|
||||||
if p.Kind != KindHeartbeat || p.Serial != "XYZ" {
|
|
||||||
t.Errorf("rezultat = %+v", p)
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
func TestParseBezZaglavlja(t *testing.T) {
|
|
||||||
// FW stariji od 0.13.4: goli tekst, znamo samo izvornu adresu.
|
|
||||||
p := ParsePacket([]byte("nesto se desilo\ndrugi red\n"), "192.168.0.77")
|
|
||||||
if p.Kind != KindLog {
|
|
||||||
t.Fatalf("vrsta = %v", p.Kind)
|
|
||||||
}
|
|
||||||
if p.Identified {
|
|
||||||
t.Error("paket bez zaglavlja NE SME da vazi za identifikovan")
|
|
||||||
}
|
|
||||||
if p.MAC != "" {
|
|
||||||
t.Errorf("mac = %q, ocekivano prazno", p.MAC)
|
|
||||||
}
|
|
||||||
key := DeviceKey(p.MAC, p.SourceIP)
|
|
||||||
if key != "nepoznat-192_168_0_77" {
|
|
||||||
t.Errorf("kljuc = %q", key)
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
func TestParseSmeceNeObaraServis(t *testing.T) {
|
|
||||||
slucajevi := [][]byte{
|
|
||||||
nil,
|
|
||||||
{},
|
|
||||||
[]byte("\n\n\n"),
|
|
||||||
[]byte("{"), // krnj JSON
|
|
||||||
[]byte(`{"app":"TERMINIA"`), // presecen paket
|
|
||||||
[]byte(`{"nesto":"tudje"}`), // JSON bez identiteta
|
|
||||||
{0x00, 0x01, 0x02, 0xff, 0xfe}, // binarno smece
|
|
||||||
[]byte("#TERMINIA\n"), // zaglavlje bez ijednog polja
|
|
||||||
[]byte(strings.Repeat("A", MaxPacketBytes*3)), // predugacak paket
|
|
||||||
}
|
|
||||||
for i, c := range slucajevi {
|
|
||||||
func() {
|
|
||||||
defer func() {
|
|
||||||
if r := recover(); r != nil {
|
|
||||||
t.Fatalf("slucaj %d: panika: %v", i, r)
|
|
||||||
}
|
|
||||||
}()
|
|
||||||
p := ParsePacket(c, "1.2.3.4")
|
|
||||||
// Bilo koji ishod je prihvatljiv osim pada; ako je nesto proslo,
|
|
||||||
// mora biti u granicama.
|
|
||||||
if len(p.Lines) > MaxLinesPerPacket {
|
|
||||||
t.Errorf("slucaj %d: previse linija %d", i, len(p.Lines))
|
|
||||||
}
|
|
||||||
for _, ln := range p.Lines {
|
|
||||||
if len([]rune(ln)) > MaxLineLen {
|
|
||||||
t.Errorf("slucaj %d: linija duza od granice", i)
|
|
||||||
}
|
|
||||||
}
|
|
||||||
}()
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
func TestParseSeceIKontrolneZnake(t *testing.T) {
|
|
||||||
dugacko := strings.Repeat("x", 1000)
|
|
||||||
raw := "#TERMINIA " + strings.Repeat("N", 200) + " 1C:DB:D4:A6:A4:60 " + strings.Repeat("9", 100) + "\n" +
|
|
||||||
"linija\x1b[31m sa ESC \x07 i \x00 nulom\n" + dugacko + "\n"
|
|
||||||
p := ParsePacket([]byte(raw), "1.2.3.4")
|
|
||||||
|
|
||||||
if len([]rune(p.Name)) > MaxNameLen {
|
|
||||||
t.Errorf("naziv nije skracen: %d", len([]rune(p.Name)))
|
|
||||||
}
|
|
||||||
if len([]rune(p.FW)) > MaxFWLen {
|
|
||||||
t.Errorf("fw nije skracen: %d", len([]rune(p.FW)))
|
|
||||||
}
|
|
||||||
if strings.ContainsAny(p.Lines[0], "\x1b\x07\x00") {
|
|
||||||
t.Errorf("kontrolni znaci nisu uklonjeni: %q", p.Lines[0])
|
|
||||||
}
|
|
||||||
if len([]rune(p.Lines[1])) > MaxLineLen {
|
|
||||||
t.Errorf("linija nije skracena: %d", len([]rune(p.Lines[1])))
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
func TestParsePreviseLinija(t *testing.T) {
|
|
||||||
var b strings.Builder
|
|
||||||
b.WriteString("#TERMINIA T 1C:DB:D4:A6:A4:60 0.13.4\n")
|
|
||||||
for i := 0; i < 500; i++ {
|
|
||||||
b.WriteString("linija\n")
|
|
||||||
}
|
|
||||||
p := ParsePacket([]byte(b.String()), "1.2.3.4")
|
|
||||||
if len(p.Lines) != MaxLinesPerPacket {
|
|
||||||
t.Errorf("linija = %d, ocekivano %d", len(p.Lines), MaxLinesPerPacket)
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
func TestNormalizeMAC(t *testing.T) {
|
|
||||||
dobri := map[string]string{
|
|
||||||
"1C:DB:D4:A6:A4:60": "1C:DB:D4:A6:A4:60",
|
|
||||||
"1c:db:d4:a6:a4:60": "1C:DB:D4:A6:A4:60",
|
|
||||||
"1cdbd4a6a460": "1C:DB:D4:A6:A4:60",
|
|
||||||
"1C-DB-D4-A6-A4-60": "1C:DB:D4:A6:A4:60",
|
|
||||||
}
|
|
||||||
for in, want := range dobri {
|
|
||||||
got, ok := NormalizeMAC(in)
|
|
||||||
if !ok || got != want {
|
|
||||||
t.Errorf("NormalizeMAC(%q) = %q,%v", in, got, ok)
|
|
||||||
}
|
|
||||||
}
|
|
||||||
losi := []string{"", "1C:DB:D4:A6:A4", "1C:DB:D4:A6:A4:6G", "../../etc/passwd",
|
|
||||||
strings.Repeat("A", 200), "1C:DB:D4:A6:A4:60:70"}
|
|
||||||
for _, in := range losi {
|
|
||||||
if _, ok := NormalizeMAC(in); ok {
|
|
||||||
t.Errorf("NormalizeMAC(%q) je prosao, a ne bi smeo", in)
|
|
||||||
}
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
func TestSanitizeSegmentNemaIzlaskaIzFoldera(t *testing.T) {
|
|
||||||
slucajevi := map[string]string{
|
|
||||||
"../../etc/passwd": "etc_passwd",
|
|
||||||
"/apsolutno/putanja": "apsolutno_putanja",
|
|
||||||
"C:\\Windows\\win": "C__Windows_win",
|
|
||||||
"": "nepoznat",
|
|
||||||
"...": "nepoznat",
|
|
||||||
"1CDBD4A6A460": "1CDBD4A6A460",
|
|
||||||
}
|
|
||||||
for in, want := range slucajevi {
|
|
||||||
got := SanitizeSegment(in)
|
|
||||||
if got != want {
|
|
||||||
t.Errorf("SanitizeSegment(%q) = %q, ocekivano %q", in, got, want)
|
|
||||||
}
|
|
||||||
if strings.ContainsAny(got, `/\`) || got == ".." {
|
|
||||||
t.Errorf("SanitizeSegment(%q) = %q — pusta izlazak iz foldera", in, got)
|
|
||||||
}
|
|
||||||
}
|
|
||||||
if n := len(SanitizeSegment(strings.Repeat("a", 500))); n > MaxKeyLen {
|
|
||||||
t.Errorf("kljuc nije ogranicen: %d", n)
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
func TestDeviceKeyPoIPKadNemaMAC(t *testing.T) {
|
|
||||||
if got := DeviceKey("", "10.20.30.40"); got != "nepoznat-10_20_30_40" {
|
|
||||||
t.Errorf("kljuc = %q", got)
|
|
||||||
}
|
|
||||||
if got := DeviceKey("", ""); got != "nepoznat-bez-adrese" {
|
|
||||||
t.Errorf("kljuc bez adrese = %q", got)
|
|
||||||
}
|
|
||||||
// Lazna izvorna adresa ne sme da napravi putanju.
|
|
||||||
if got := DeviceKey("", "../../root"); strings.ContainsAny(got, `/\`) {
|
|
||||||
t.Errorf("kljuc = %q", got)
|
|
||||||
}
|
|
||||||
}
|
|
||||||
@ -1,194 +0,0 @@
|
|||||||
package logger
|
|
||||||
|
|
||||||
import (
|
|
||||||
"sort"
|
|
||||||
"sync"
|
|
||||||
"time"
|
|
||||||
)
|
|
||||||
|
|
||||||
// Device je sve sto pamtimo o jednom uredjaju. Sve je u memoriji i sve je
|
|
||||||
// ograniceno po velicini - dnevnik ide u fajlove, ne ovde.
|
|
||||||
type Device struct {
|
|
||||||
Key string
|
|
||||||
Name string
|
|
||||||
MAC string
|
|
||||||
IP string // adresa koju uredjaj sam prijavi (heartbeat)
|
|
||||||
SourceIP string // adresa sa koje je paket stvarno stigao
|
|
||||||
FW string
|
|
||||||
Serial string
|
|
||||||
Identified bool // znamo li ko je (zaglavlje/heartbeat) ili samo nagadjamo po IP-u
|
|
||||||
|
|
||||||
FirstSeen time.Time
|
|
||||||
LastSeen time.Time
|
|
||||||
LastHeartbeat time.Time
|
|
||||||
|
|
||||||
Heartbeats uint64
|
|
||||||
LogPackets uint64
|
|
||||||
LogLines uint64
|
|
||||||
|
|
||||||
IntervalSec int // izmeren razmak izmedju dva heartbeata (0 = jos ne znamo)
|
|
||||||
LastLine string // poslednja linija dnevnika, samo za pregled
|
|
||||||
}
|
|
||||||
|
|
||||||
// Registry cuva uredjaje u memoriji. Broj uredjaja je ogranicen jer paket moze
|
|
||||||
// poslati bilo ko - bez granice bi jedan izvor sa laznim MAC-ovima pojeo RAM.
|
|
||||||
type Registry struct {
|
|
||||||
mu sync.RWMutex
|
|
||||||
devices map[string]*Device
|
|
||||||
maxDevices int
|
|
||||||
defaultHb int // pretpostavljeni interval kad uredjaj nikad nije poslao heartbeat
|
|
||||||
}
|
|
||||||
|
|
||||||
func NewRegistry(maxDevices, defaultHbSec int) *Registry {
|
|
||||||
if maxDevices <= 0 {
|
|
||||||
maxDevices = 500
|
|
||||||
}
|
|
||||||
if defaultHbSec <= 0 {
|
|
||||||
defaultHbSec = 60
|
|
||||||
}
|
|
||||||
return &Registry{
|
|
||||||
devices: make(map[string]*Device),
|
|
||||||
maxDevices: maxDevices,
|
|
||||||
defaultHb: defaultHbSec,
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
// Update ubacuje paket u registar i vraca kljuc uredjaja (i da li je primljen).
|
|
||||||
// Paket koji nije prepoznat se ignorise.
|
|
||||||
func (r *Registry) Update(p Packet, now time.Time) (string, bool) {
|
|
||||||
if p.Kind == KindGarbage {
|
|
||||||
return "", false
|
|
||||||
}
|
|
||||||
key := DeviceKey(p.MAC, p.SourceIP)
|
|
||||||
|
|
||||||
r.mu.Lock()
|
|
||||||
defer r.mu.Unlock()
|
|
||||||
|
|
||||||
d, ok := r.devices[key]
|
|
||||||
if !ok {
|
|
||||||
if len(r.devices) >= r.maxDevices {
|
|
||||||
r.evictOldestLocked()
|
|
||||||
}
|
|
||||||
d = &Device{Key: key, FirstSeen: now}
|
|
||||||
r.devices[key] = d
|
|
||||||
}
|
|
||||||
|
|
||||||
d.LastSeen = now
|
|
||||||
d.SourceIP = p.SourceIP
|
|
||||||
if p.Name != "" {
|
|
||||||
d.Name = p.Name
|
|
||||||
}
|
|
||||||
if p.MAC != "" {
|
|
||||||
d.MAC = p.MAC
|
|
||||||
}
|
|
||||||
if p.FW != "" {
|
|
||||||
d.FW = p.FW
|
|
||||||
}
|
|
||||||
if p.Serial != "" {
|
|
||||||
d.Serial = p.Serial
|
|
||||||
}
|
|
||||||
if p.Identified {
|
|
||||||
d.Identified = true
|
|
||||||
}
|
|
||||||
|
|
||||||
switch p.Kind {
|
|
||||||
case KindHeartbeat:
|
|
||||||
if p.IP != "" {
|
|
||||||
d.IP = p.IP
|
|
||||||
}
|
|
||||||
// Interval ne dolazi u paketu - meri se izmedju dva javljanja.
|
|
||||||
// Uzima se poslednji razmak, uz clamp da jedan izgubljen paket ili
|
|
||||||
// restart uredjaja ne razvuku prag na sate.
|
|
||||||
if !d.LastHeartbeat.IsZero() {
|
|
||||||
if sec := int(now.Sub(d.LastHeartbeat).Seconds()); sec >= 5 && sec <= 3600 {
|
|
||||||
d.IntervalSec = sec
|
|
||||||
}
|
|
||||||
}
|
|
||||||
d.LastHeartbeat = now
|
|
||||||
d.Heartbeats++
|
|
||||||
case KindLog:
|
|
||||||
d.LogPackets++
|
|
||||||
d.LogLines += uint64(len(p.Lines))
|
|
||||||
if n := len(p.Lines); n > 0 {
|
|
||||||
d.LastLine = p.Lines[n-1]
|
|
||||||
}
|
|
||||||
}
|
|
||||||
return key, true
|
|
||||||
}
|
|
||||||
|
|
||||||
// evictOldestLocked izbacuje uredjaj koji se najduze nije javio. Poziva se samo
|
|
||||||
// kad je registar pun.
|
|
||||||
func (r *Registry) evictOldestLocked() {
|
|
||||||
var oldestKey string
|
|
||||||
var oldest time.Time
|
|
||||||
for k, d := range r.devices {
|
|
||||||
if oldestKey == "" || d.LastSeen.Before(oldest) {
|
|
||||||
oldestKey, oldest = k, d.LastSeen
|
|
||||||
}
|
|
||||||
}
|
|
||||||
if oldestKey != "" {
|
|
||||||
delete(r.devices, oldestKey)
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
// Interval vraca interval po kom se procenjuje da li je uredjaj tih.
|
|
||||||
func (r *Registry) Interval(d *Device) int {
|
|
||||||
if d.IntervalSec > 0 {
|
|
||||||
return d.IntervalSec
|
|
||||||
}
|
|
||||||
return r.defaultHb
|
|
||||||
}
|
|
||||||
|
|
||||||
// Stale je tacno kad se uredjaj nije javio duze od 3x svog intervala.
|
|
||||||
func (r *Registry) Stale(d *Device, now time.Time) bool {
|
|
||||||
limit := time.Duration(3*r.Interval(d)) * time.Second
|
|
||||||
return now.Sub(d.LastSeen) > limit
|
|
||||||
}
|
|
||||||
|
|
||||||
// Snapshot vraca kopije uredjaja, sortirane: prvo tihi (da bode oci), pa po
|
|
||||||
// nazivu/kljucu.
|
|
||||||
func (r *Registry) Snapshot(now time.Time) []Device {
|
|
||||||
r.mu.RLock()
|
|
||||||
out := make([]Device, 0, len(r.devices))
|
|
||||||
for _, d := range r.devices {
|
|
||||||
out = append(out, *d)
|
|
||||||
}
|
|
||||||
r.mu.RUnlock()
|
|
||||||
|
|
||||||
sort.Slice(out, func(i, j int) bool {
|
|
||||||
si, sj := r.Stale(&out[i], now), r.Stale(&out[j], now)
|
|
||||||
if si != sj {
|
|
||||||
return si
|
|
||||||
}
|
|
||||||
ni, nj := out[i].Name, out[j].Name
|
|
||||||
if ni == "" {
|
|
||||||
ni = out[i].Key
|
|
||||||
}
|
|
||||||
if nj == "" {
|
|
||||||
nj = out[j].Key
|
|
||||||
}
|
|
||||||
if ni != nj {
|
|
||||||
return ni < nj
|
|
||||||
}
|
|
||||||
return out[i].Key < out[j].Key
|
|
||||||
})
|
|
||||||
return out
|
|
||||||
}
|
|
||||||
|
|
||||||
// Get vraca kopiju jednog uredjaja.
|
|
||||||
func (r *Registry) Get(key string) (Device, bool) {
|
|
||||||
r.mu.RLock()
|
|
||||||
defer r.mu.RUnlock()
|
|
||||||
d, ok := r.devices[key]
|
|
||||||
if !ok {
|
|
||||||
return Device{}, false
|
|
||||||
}
|
|
||||||
return *d, true
|
|
||||||
}
|
|
||||||
|
|
||||||
// Count vraca broj uredjaja u registru.
|
|
||||||
func (r *Registry) Count() int {
|
|
||||||
r.mu.RLock()
|
|
||||||
defer r.mu.RUnlock()
|
|
||||||
return len(r.devices)
|
|
||||||
}
|
|
||||||
@ -1,113 +0,0 @@
|
|||||||
package logger
|
|
||||||
|
|
||||||
import (
|
|
||||||
"fmt"
|
|
||||||
"testing"
|
|
||||||
"time"
|
|
||||||
)
|
|
||||||
|
|
||||||
func hbPaket(mac string) Packet {
|
|
||||||
return ParsePacket([]byte(fmt.Sprintf(
|
|
||||||
`{"app":"TERMINIA","name":"TERM","mac":"%s","ip":"192.168.0.20","fw":"0.13.4","hb":1}`, mac)),
|
|
||||||
"192.168.0.20")
|
|
||||||
}
|
|
||||||
|
|
||||||
func TestRegistryMeriIntervalHeartbeata(t *testing.T) {
|
|
||||||
r := NewRegistry(10, 60)
|
|
||||||
t0 := time.Date(2026, 7, 25, 12, 0, 0, 0, time.UTC)
|
|
||||||
|
|
||||||
r.Update(hbPaket("1C:DB:D4:A6:A4:60"), t0)
|
|
||||||
key, _ := r.Update(hbPaket("1C:DB:D4:A6:A4:60"), t0.Add(30*time.Second))
|
|
||||||
|
|
||||||
d, ok := r.Get(key)
|
|
||||||
if !ok {
|
|
||||||
t.Fatal("uredjaj nije u registru")
|
|
||||||
}
|
|
||||||
if d.IntervalSec != 30 {
|
|
||||||
t.Errorf("interval = %d, ocekivano 30", d.IntervalSec)
|
|
||||||
}
|
|
||||||
if d.Heartbeats != 2 {
|
|
||||||
t.Errorf("heartbeata = %d", d.Heartbeats)
|
|
||||||
}
|
|
||||||
// 3x30 s = 90 s praga (poslednji paket je stigao u t0+30 s)
|
|
||||||
if r.Stale(&d, t0.Add(150*time.Second)) == false {
|
|
||||||
t.Error("posle 90 s tisine uredjaj mora biti oznacen kao tih")
|
|
||||||
}
|
|
||||||
if r.Stale(&d, t0.Add(40*time.Second)) {
|
|
||||||
t.Error("uredjaj koji se javio pre 10 s ne sme biti tih")
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
func TestRegistryBezHeartbeataKoristiPodrazumevaniInterval(t *testing.T) {
|
|
||||||
r := NewRegistry(10, 60)
|
|
||||||
t0 := time.Now()
|
|
||||||
key, _ := r.Update(ParsePacket([]byte("#TERMINIA T 1C:DB:D4:A6:A4:60 0.13.4\nred\n"), "1.2.3.4"), t0)
|
|
||||||
d, _ := r.Get(key)
|
|
||||||
if got := r.Interval(&d); got != 60 {
|
|
||||||
t.Errorf("interval = %d, ocekivano 60 (podrazumevani)", got)
|
|
||||||
}
|
|
||||||
if !r.Stale(&d, t0.Add(200*time.Second)) {
|
|
||||||
t.Error("posle 180 s mora biti tih")
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
func TestRegistryOgranicavaBrojUredjaja(t *testing.T) {
|
|
||||||
r := NewRegistry(3, 60)
|
|
||||||
t0 := time.Now()
|
|
||||||
for i := 0; i < 50; i++ {
|
|
||||||
p := ParsePacket([]byte("neka linija\n"), fmt.Sprintf("10.0.0.%d", i))
|
|
||||||
r.Update(p, t0.Add(time.Duration(i)*time.Second))
|
|
||||||
}
|
|
||||||
if n := r.Count(); n != 3 {
|
|
||||||
t.Errorf("uredjaja u registru = %d, ocekivano 3 (granica)", n)
|
|
||||||
}
|
|
||||||
// Najstariji mora ispasti, najnoviji ostati.
|
|
||||||
if _, ok := r.Get("nepoznat-10_0_0_49"); !ok {
|
|
||||||
t.Error("poslednji uredjaj mora ostati u registru")
|
|
||||||
}
|
|
||||||
if _, ok := r.Get("nepoznat-10_0_0_0"); ok {
|
|
||||||
t.Error("najstariji uredjaj je morao biti izbacen")
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
func TestRegistryZadrzavaIdentitetIzZaglavlja(t *testing.T) {
|
|
||||||
r := NewRegistry(10, 60)
|
|
||||||
t0 := time.Now()
|
|
||||||
key, _ := r.Update(ParsePacket([]byte("#TERMINIA TERM-001 1C:DB:D4:A6:A4:60 0.13.4\nprvi red\n"), "1.2.3.4"), t0)
|
|
||||||
// Kasniji paket bez zaglavlja sa istim MAC-om ne postoji, ali heartbeat
|
|
||||||
// dopunjuje IP i serijski.
|
|
||||||
r.Update(hbPaket("1C:DB:D4:A6:A4:60"), t0.Add(time.Second))
|
|
||||||
|
|
||||||
d, _ := r.Get(key)
|
|
||||||
if !d.Identified || d.MAC != "1C:DB:D4:A6:A4:60" || d.IP != "192.168.0.20" {
|
|
||||||
t.Errorf("uredjaj = %+v", d)
|
|
||||||
}
|
|
||||||
if d.LogLines != 1 || d.LastLine != "prvi red" {
|
|
||||||
t.Errorf("linije = %d / %q", d.LogLines, d.LastLine)
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
func TestRegistrySnapshotStavljaTiheNaVrh(t *testing.T) {
|
|
||||||
r := NewRegistry(10, 60)
|
|
||||||
t0 := time.Date(2026, 7, 25, 12, 0, 0, 0, time.UTC)
|
|
||||||
r.Update(hbPaket("AA:AA:AA:AA:AA:AA"), t0.Add(-time.Hour))
|
|
||||||
r.Update(hbPaket("BB:BB:BB:BB:BB:BB"), t0)
|
|
||||||
|
|
||||||
snap := r.Snapshot(t0)
|
|
||||||
if len(snap) != 2 {
|
|
||||||
t.Fatalf("snapshot = %d", len(snap))
|
|
||||||
}
|
|
||||||
if snap[0].MAC != "AA:AA:AA:AA:AA:AA" {
|
|
||||||
t.Errorf("tih uredjaj mora biti prvi, dobijeno %s", snap[0].MAC)
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
func TestRegistryIgnorisSmece(t *testing.T) {
|
|
||||||
r := NewRegistry(10, 60)
|
|
||||||
if _, ok := r.Update(ParsePacket([]byte("{"), "1.2.3.4"), time.Now()); ok {
|
|
||||||
t.Error("smece ne sme uci u registar")
|
|
||||||
}
|
|
||||||
if r.Count() != 0 {
|
|
||||||
t.Errorf("registar nije prazan: %d", r.Count())
|
|
||||||
}
|
|
||||||
}
|
|
||||||
@ -1,259 +0,0 @@
|
|||||||
package logger
|
|
||||||
|
|
||||||
import (
|
|
||||||
"context"
|
|
||||||
"errors"
|
|
||||||
"fmt"
|
|
||||||
"log"
|
|
||||||
"net"
|
|
||||||
"net/http"
|
|
||||||
"os"
|
|
||||||
"strconv"
|
|
||||||
"sync/atomic"
|
|
||||||
"time"
|
|
||||||
)
|
|
||||||
|
|
||||||
// Config je citav podesivi deo prijemnika. Sve dolazi iz env promenljivih
|
|
||||||
// (systemd EnvironmentFile), nista nije zakucano u kodu.
|
|
||||||
type Config struct {
|
|
||||||
UDPHost string // prazno = sve adrese
|
|
||||||
UDPPort int
|
|
||||||
HTTPHost string
|
|
||||||
HTTPPort int
|
|
||||||
Dir string
|
|
||||||
Token string // ako je postavljen, web trazi ?t=<token>
|
|
||||||
KeepDays int
|
|
||||||
MaxFileMB int
|
|
||||||
MaxDeviceMB int
|
|
||||||
MaxTotalMB int
|
|
||||||
MaxDevices int
|
|
||||||
HbDefaultSec int
|
|
||||||
}
|
|
||||||
|
|
||||||
// DefaultConfig su podrazumevane vrednosti.
|
|
||||||
//
|
|
||||||
// UDP 46465 namerno NIJE 46464: na tom portu uredjaji slusaju discovery, pa bi
|
|
||||||
// prijemnik na istoj mrezi ulazio u sukob sa njima.
|
|
||||||
//
|
|
||||||
// Web sluza samo na 127.0.0.1 jer dnevnik sadrzi BROJEVE KARATA - napolje se
|
|
||||||
// pusta iskljucivo kroz SSH tunel ili nginx sa autentikacijom.
|
|
||||||
func DefaultConfig() Config {
|
|
||||||
return Config{
|
|
||||||
UDPHost: "",
|
|
||||||
UDPPort: 46465,
|
|
||||||
HTTPHost: "127.0.0.1",
|
|
||||||
HTTPPort: 8081,
|
|
||||||
Dir: "./data/logger",
|
|
||||||
KeepDays: 14,
|
|
||||||
MaxFileMB: 10,
|
|
||||||
MaxDeviceMB: 50,
|
|
||||||
MaxTotalMB: 1024,
|
|
||||||
MaxDevices: 500,
|
|
||||||
HbDefaultSec: 60,
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
// ConfigFromEnv cita podesavanja preko podrazumevanih vrednosti.
|
|
||||||
func ConfigFromEnv() (Config, error) {
|
|
||||||
c := DefaultConfig()
|
|
||||||
var err error
|
|
||||||
str := func(key string, dst *string) {
|
|
||||||
if v, ok := os.LookupEnv(key); ok {
|
|
||||||
*dst = v
|
|
||||||
}
|
|
||||||
}
|
|
||||||
num := func(key string, dst *int, min, max int) {
|
|
||||||
v, ok := os.LookupEnv(key)
|
|
||||||
if !ok || v == "" {
|
|
||||||
return
|
|
||||||
}
|
|
||||||
n, e := strconv.Atoi(v)
|
|
||||||
if e != nil || n < min || n > max {
|
|
||||||
err = fmt.Errorf("%s: neispravna vrednost %q (ocekuje se broj %d-%d)", key, v, min, max)
|
|
||||||
return
|
|
||||||
}
|
|
||||||
*dst = n
|
|
||||||
}
|
|
||||||
str("LOGGER_UDP_HOST", &c.UDPHost)
|
|
||||||
str("LOGGER_HTTP_HOST", &c.HTTPHost)
|
|
||||||
str("LOGGER_DIR", &c.Dir)
|
|
||||||
str("LOGGER_TOKEN", &c.Token)
|
|
||||||
num("LOGGER_UDP_PORT", &c.UDPPort, 1, 65535)
|
|
||||||
num("LOGGER_HTTP_PORT", &c.HTTPPort, 1, 65535)
|
|
||||||
num("LOGGER_KEEP_DAYS", &c.KeepDays, 1, 3650)
|
|
||||||
num("LOGGER_MAX_FILE_MB", &c.MaxFileMB, 1, 10240)
|
|
||||||
num("LOGGER_MAX_DEVICE_MB", &c.MaxDeviceMB, 1, 102400)
|
|
||||||
num("LOGGER_MAX_TOTAL_MB", &c.MaxTotalMB, 1, 1024000)
|
|
||||||
num("LOGGER_MAX_DEVICES", &c.MaxDevices, 1, 100000)
|
|
||||||
num("LOGGER_HB_DEFAULT_SEC", &c.HbDefaultSec, 5, 86400)
|
|
||||||
if err != nil {
|
|
||||||
return c, err
|
|
||||||
}
|
|
||||||
if c.MaxDeviceMB > c.MaxTotalMB {
|
|
||||||
return c, fmt.Errorf("LOGGER_MAX_DEVICE_MB (%d) ne sme biti vece od LOGGER_MAX_TOTAL_MB (%d)",
|
|
||||||
c.MaxDeviceMB, c.MaxTotalMB)
|
|
||||||
}
|
|
||||||
return c, nil
|
|
||||||
}
|
|
||||||
|
|
||||||
// Stats su brojaci prijemnika za prikaz na stranici.
|
|
||||||
type Stats struct {
|
|
||||||
Packets atomic.Uint64
|
|
||||||
Heartbeat atomic.Uint64
|
|
||||||
LogPkts atomic.Uint64
|
|
||||||
Garbage atomic.Uint64
|
|
||||||
WriteErrs atomic.Uint64
|
|
||||||
}
|
|
||||||
|
|
||||||
// Service spaja UDP prijem, registar uredjaja, pisanje u fajlove i web.
|
|
||||||
type Service struct {
|
|
||||||
cfg Config
|
|
||||||
reg *Registry
|
|
||||||
store *Store
|
|
||||||
stats *Stats
|
|
||||||
started time.Time
|
|
||||||
now func() time.Time // zamenjivo u testovima
|
|
||||||
}
|
|
||||||
|
|
||||||
func New(cfg Config) (*Service, error) {
|
|
||||||
st, err := NewStore(StoreConfig{
|
|
||||||
Dir: cfg.Dir,
|
|
||||||
MaxFileBytes: int64(cfg.MaxFileMB) << 20,
|
|
||||||
MaxDeviceBytes: int64(cfg.MaxDeviceMB) << 20,
|
|
||||||
MaxTotalBytes: int64(cfg.MaxTotalMB) << 20,
|
|
||||||
KeepDays: cfg.KeepDays,
|
|
||||||
})
|
|
||||||
if err != nil {
|
|
||||||
return nil, err
|
|
||||||
}
|
|
||||||
return &Service{
|
|
||||||
cfg: cfg,
|
|
||||||
reg: NewRegistry(cfg.MaxDevices, cfg.HbDefaultSec),
|
|
||||||
store: st,
|
|
||||||
stats: &Stats{},
|
|
||||||
started: time.Now(),
|
|
||||||
now: time.Now,
|
|
||||||
}, nil
|
|
||||||
}
|
|
||||||
|
|
||||||
// Handle obradjuje jedan primljen paket. Izdvojeno iz petlje da bi moglo da se
|
|
||||||
// testira bez mreze.
|
|
||||||
func (s *Service) Handle(data []byte, sourceIP string) {
|
|
||||||
s.stats.Packets.Add(1)
|
|
||||||
p := ParsePacket(data, sourceIP)
|
|
||||||
if p.Kind == KindGarbage {
|
|
||||||
s.stats.Garbage.Add(1)
|
|
||||||
return
|
|
||||||
}
|
|
||||||
now := s.now()
|
|
||||||
key, ok := s.reg.Update(p, now)
|
|
||||||
if !ok {
|
|
||||||
return
|
|
||||||
}
|
|
||||||
switch p.Kind {
|
|
||||||
case KindHeartbeat:
|
|
||||||
s.stats.Heartbeat.Add(1)
|
|
||||||
case KindLog:
|
|
||||||
s.stats.LogPkts.Add(1)
|
|
||||||
if err := s.store.Write(key, now, p.Lines); err != nil {
|
|
||||||
// Greska pisanja ne sme da obori prijem: paket se izgubi, a
|
|
||||||
// brojac gresaka se vidi na stranici.
|
|
||||||
s.stats.WriteErrs.Add(1)
|
|
||||||
log.Printf("prijemnik: %v", err)
|
|
||||||
}
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
// Run pokrece UDP prijem, web i odrzavanje. Vraca se kad se kontekst otkaze.
|
|
||||||
func (s *Service) Run(ctx context.Context) error {
|
|
||||||
udpAddr := net.JoinHostPort(s.cfg.UDPHost, strconv.Itoa(s.cfg.UDPPort))
|
|
||||||
pc, err := net.ListenPacket("udp", udpAddr)
|
|
||||||
if err != nil {
|
|
||||||
return fmt.Errorf("UDP %s: %w", udpAddr, err)
|
|
||||||
}
|
|
||||||
defer pc.Close()
|
|
||||||
|
|
||||||
httpAddr := net.JoinHostPort(s.cfg.HTTPHost, strconv.Itoa(s.cfg.HTTPPort))
|
|
||||||
srv := &http.Server{
|
|
||||||
Addr: httpAddr,
|
|
||||||
Handler: s.Handler(),
|
|
||||||
ReadHeaderTimeout: 5 * time.Second,
|
|
||||||
}
|
|
||||||
ln, err := net.Listen("tcp", httpAddr)
|
|
||||||
if err != nil {
|
|
||||||
return fmt.Errorf("HTTP %s: %w", httpAddr, err)
|
|
||||||
}
|
|
||||||
|
|
||||||
log.Printf("prijemnik dijagnostike: UDP %s, web http://%s, dnevnici u %s",
|
|
||||||
udpAddr, httpAddr, s.cfg.Dir)
|
|
||||||
if s.cfg.Token == "" && s.cfg.HTTPHost != "127.0.0.1" && s.cfg.HTTPHost != "localhost" {
|
|
||||||
log.Printf("UPOZORENJE: web je otvoren ka mrezi bez tokena (LOGGER_TOKEN), a dnevnik sadrzi brojeve karata")
|
|
||||||
}
|
|
||||||
|
|
||||||
errCh := make(chan error, 1)
|
|
||||||
go func() {
|
|
||||||
if err := srv.Serve(ln); err != nil && !errors.Is(err, http.ErrServerClosed) {
|
|
||||||
errCh <- err
|
|
||||||
}
|
|
||||||
}()
|
|
||||||
go s.readLoop(pc, errCh)
|
|
||||||
go s.maintenance(ctx)
|
|
||||||
|
|
||||||
select {
|
|
||||||
case <-ctx.Done():
|
|
||||||
case err = <-errCh:
|
|
||||||
}
|
|
||||||
|
|
||||||
shutCtx, cancel := context.WithTimeout(context.Background(), 5*time.Second)
|
|
||||||
defer cancel()
|
|
||||||
srv.Shutdown(shutCtx)
|
|
||||||
pc.Close()
|
|
||||||
s.store.Close()
|
|
||||||
return err
|
|
||||||
}
|
|
||||||
|
|
||||||
func (s *Service) readLoop(pc net.PacketConn, errCh chan<- error) {
|
|
||||||
buf := make([]byte, MaxPacketBytes)
|
|
||||||
for {
|
|
||||||
n, addr, err := pc.ReadFrom(buf)
|
|
||||||
if err != nil {
|
|
||||||
// Zatvoren soket je uredan kraj; sve ostalo je greska mreze
|
|
||||||
// koju ne pokusavamo da lecimo.
|
|
||||||
if errors.Is(err, net.ErrClosed) {
|
|
||||||
return
|
|
||||||
}
|
|
||||||
errCh <- fmt.Errorf("UDP prijem: %w", err)
|
|
||||||
return
|
|
||||||
}
|
|
||||||
src := ""
|
|
||||||
if ua, ok := addr.(*net.UDPAddr); ok && ua.IP != nil {
|
|
||||||
src = ua.IP.String()
|
|
||||||
}
|
|
||||||
s.Handle(buf[:n], src)
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
// maintenance povremeno cisti stare dnevnike i zatvara mirne fajlove.
|
|
||||||
func (s *Service) maintenance(ctx context.Context) {
|
|
||||||
if n, err := s.store.Cleanup(s.now()); err != nil {
|
|
||||||
log.Printf("prijemnik: ciscenje: %v", err)
|
|
||||||
} else if n > 0 {
|
|
||||||
log.Printf("prijemnik: obrisano %d starih dnevnika", n)
|
|
||||||
}
|
|
||||||
t := time.NewTicker(time.Minute)
|
|
||||||
defer t.Stop()
|
|
||||||
for {
|
|
||||||
select {
|
|
||||||
case <-ctx.Done():
|
|
||||||
return
|
|
||||||
case <-t.C:
|
|
||||||
now := s.now()
|
|
||||||
s.store.CloseIdle(now, 5*time.Minute)
|
|
||||||
if n, err := s.store.Cleanup(now); err != nil {
|
|
||||||
log.Printf("prijemnik: ciscenje: %v", err)
|
|
||||||
} else if n > 0 {
|
|
||||||
log.Printf("prijemnik: obrisano %d starih dnevnika", n)
|
|
||||||
}
|
|
||||||
}
|
|
||||||
}
|
|
||||||
}
|
|
||||||
@ -1,200 +0,0 @@
|
|||||||
package logger
|
|
||||||
|
|
||||||
import (
|
|
||||||
"net/http"
|
|
||||||
"net/http/httptest"
|
|
||||||
"strings"
|
|
||||||
"testing"
|
|
||||||
"time"
|
|
||||||
)
|
|
||||||
|
|
||||||
func testService(t *testing.T, prilagodi func(*Config)) *Service {
|
|
||||||
t.Helper()
|
|
||||||
cfg := DefaultConfig()
|
|
||||||
cfg.Dir = t.TempDir()
|
|
||||||
if prilagodi != nil {
|
|
||||||
prilagodi(&cfg)
|
|
||||||
}
|
|
||||||
s, err := New(cfg)
|
|
||||||
if err != nil {
|
|
||||||
t.Fatalf("New: %v", err)
|
|
||||||
}
|
|
||||||
t.Cleanup(s.store.Close)
|
|
||||||
return s
|
|
||||||
}
|
|
||||||
|
|
||||||
func TestServiceHandleUpisujeDnevnikIPamtiHeartbeat(t *testing.T) {
|
|
||||||
s := testService(t, nil)
|
|
||||||
t0 := time.Date(2026, 7, 25, 12, 0, 0, 0, time.UTC)
|
|
||||||
s.now = func() time.Time { return t0 }
|
|
||||||
|
|
||||||
s.Handle([]byte(`{"app":"TERMINIA","name":"TERM-001","mac":"1C:DB:D4:A6:A4:60","ip":"192.168.0.20","fw":"0.13.4","hb":1}`), "192.168.0.20")
|
|
||||||
s.Handle([]byte("#TERMINIA TERM-001 1C:DB:D4:A6:A4:60 0.13.4\n[stampac] javio se\n"), "192.168.0.20")
|
|
||||||
s.Handle([]byte{0x00, 0x01, 0x02, 0xff, 0xfe}, "9.9.9.9") // binarno smece
|
|
||||||
|
|
||||||
if got := s.stats.Heartbeat.Load(); got != 1 {
|
|
||||||
t.Errorf("heartbeata = %d", got)
|
|
||||||
}
|
|
||||||
if got := s.stats.LogPkts.Load(); got != 1 {
|
|
||||||
t.Errorf("paketa dnevnika = %d", got)
|
|
||||||
}
|
|
||||||
if got := s.stats.WriteErrs.Load(); got != 0 {
|
|
||||||
t.Errorf("gresaka upisa = %d", got)
|
|
||||||
}
|
|
||||||
lines, _ := s.store.Tail("1CDBD4A6A460", 10, "")
|
|
||||||
if len(lines) != 1 || !strings.Contains(lines[0], "[stampac] javio se") {
|
|
||||||
t.Errorf("dnevnik = %q", lines)
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
func TestServiceStranicaUredjaja(t *testing.T) {
|
|
||||||
s := testService(t, nil)
|
|
||||||
t0 := time.Date(2026, 7, 25, 12, 0, 0, 0, time.UTC)
|
|
||||||
s.now = func() time.Time { return t0 }
|
|
||||||
s.Handle([]byte("#TERMINIA TERM-001 1C:DB:D4:A6:A4:60 0.13.4\n[stampac] javio se\n[kapija] prolaz\n"), "192.168.0.20")
|
|
||||||
h := s.Handler()
|
|
||||||
|
|
||||||
rec := httptest.NewRecorder()
|
|
||||||
h.ServeHTTP(rec, httptest.NewRequest("GET", "/", nil))
|
|
||||||
if rec.Code != http.StatusOK {
|
|
||||||
t.Fatalf("/ = %d", rec.Code)
|
|
||||||
}
|
|
||||||
body := rec.Body.String()
|
|
||||||
if !strings.Contains(body, "TERM-001") || !strings.Contains(body, "1C:DB:D4:A6:A4:60") {
|
|
||||||
t.Errorf("spisak ne prikazuje uredjaj: %s", body)
|
|
||||||
}
|
|
||||||
|
|
||||||
rec = httptest.NewRecorder()
|
|
||||||
h.ServeHTTP(rec, httptest.NewRequest("GET", "/uredjaj?k=1CDBD4A6A460&q=stampac", nil))
|
|
||||||
if rec.Code != http.StatusOK {
|
|
||||||
t.Fatalf("/uredjaj = %d", rec.Code)
|
|
||||||
}
|
|
||||||
body = rec.Body.String()
|
|
||||||
if !strings.Contains(body, "[stampac] javio se") {
|
|
||||||
t.Error("pretraga ne vraca ocekivanu liniju")
|
|
||||||
}
|
|
||||||
if strings.Contains(body, "[kapija] prolaz") {
|
|
||||||
t.Error("pretraga vraca i linije koje ne odgovaraju upitu")
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
func TestServiceNepoznatUredjajJeOznacen(t *testing.T) {
|
|
||||||
s := testService(t, nil)
|
|
||||||
s.Handle([]byte("goli tekst bez zaglavlja\n"), "192.168.0.77")
|
|
||||||
|
|
||||||
rec := httptest.NewRecorder()
|
|
||||||
s.Handler().ServeHTTP(rec, httptest.NewRequest("GET", "/", nil))
|
|
||||||
body := rec.Body.String()
|
|
||||||
if !strings.Contains(body, "nepoznat uređaj") {
|
|
||||||
t.Errorf("uredjaj bez zaglavlja nije oznacen kao nepoznat:\n%s", body)
|
|
||||||
}
|
|
||||||
if !strings.Contains(body, "192.168.0.77") {
|
|
||||||
t.Error("nije prikazana izvorna adresa nepoznatog uredjaja")
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
func TestServiceTihUredjajJeCrven(t *testing.T) {
|
|
||||||
s := testService(t, nil)
|
|
||||||
t0 := time.Date(2026, 7, 25, 12, 0, 0, 0, time.UTC)
|
|
||||||
s.now = func() time.Time { return t0 }
|
|
||||||
s.Handle([]byte(`{"name":"TERM-001","mac":"1C:DB:D4:A6:A4:60","hb":1}`), "192.168.0.20")
|
|
||||||
|
|
||||||
s.now = func() time.Time { return t0.Add(10 * time.Minute) } // 3x60 s je davno proslo
|
|
||||||
rec := httptest.NewRecorder()
|
|
||||||
s.Handler().ServeHTTP(rec, httptest.NewRequest("GET", "/", nil))
|
|
||||||
if !strings.Contains(rec.Body.String(), `class="tih"`) {
|
|
||||||
t.Error("tih uredjaj nije oznacen crvenim redom")
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
func TestServiceHTMLEscapeIzPaketa(t *testing.T) {
|
|
||||||
// Sadrzaj paketa je tudji tekst - ne sme da postane HTML.
|
|
||||||
s := testService(t, nil)
|
|
||||||
s.Handle([]byte("#TERMINIA <script>alert(1)</script> 1C:DB:D4:A6:A4:60 0.13.4\n<img src=x onerror=alert(2)>\n"), "1.2.3.4")
|
|
||||||
|
|
||||||
for _, url := range []string{"/", "/uredjaj?k=1CDBD4A6A460"} {
|
|
||||||
rec := httptest.NewRecorder()
|
|
||||||
s.Handler().ServeHTTP(rec, httptest.NewRequest("GET", url, nil))
|
|
||||||
if strings.Contains(rec.Body.String(), "<script>alert(1)</script>") ||
|
|
||||||
strings.Contains(rec.Body.String(), "<img src=x") {
|
|
||||||
t.Errorf("%s: HTML iz paketa nije ekranovan", url)
|
|
||||||
}
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
func TestServiceToken(t *testing.T) {
|
|
||||||
s := testService(t, func(c *Config) { c.Token = "tajna" })
|
|
||||||
h := s.Handler()
|
|
||||||
|
|
||||||
rec := httptest.NewRecorder()
|
|
||||||
h.ServeHTTP(rec, httptest.NewRequest("GET", "/", nil))
|
|
||||||
if rec.Code != http.StatusForbidden {
|
|
||||||
t.Errorf("bez tokena = %d, ocekivano 403", rec.Code)
|
|
||||||
}
|
|
||||||
|
|
||||||
rec = httptest.NewRecorder()
|
|
||||||
h.ServeHTTP(rec, httptest.NewRequest("GET", "/?t=tajna", nil))
|
|
||||||
if rec.Code != http.StatusOK {
|
|
||||||
t.Errorf("sa tokenom = %d", rec.Code)
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
func TestServiceAPIJson(t *testing.T) {
|
|
||||||
s := testService(t, nil)
|
|
||||||
s.Handle([]byte(`{"name":"TERM-001","mac":"1C:DB:D4:A6:A4:60","ip":"192.168.0.20","fw":"0.13.4","hb":1}`), "192.168.0.20")
|
|
||||||
|
|
||||||
rec := httptest.NewRecorder()
|
|
||||||
s.Handler().ServeHTTP(rec, httptest.NewRequest("GET", "/api/uredjaji", nil))
|
|
||||||
if rec.Code != http.StatusOK {
|
|
||||||
t.Fatalf("/api/uredjaji = %d", rec.Code)
|
|
||||||
}
|
|
||||||
if !strings.Contains(rec.Body.String(), `"mac": "1C:DB:D4:A6:A4:60"`) {
|
|
||||||
t.Errorf("JSON = %s", rec.Body.String())
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
func TestServiceRawTekst(t *testing.T) {
|
|
||||||
s := testService(t, nil)
|
|
||||||
s.Handle([]byte("#TERMINIA T 1C:DB:D4:A6:A4:60 0.13.4\nprva\ndruga\n"), "1.2.3.4")
|
|
||||||
|
|
||||||
rec := httptest.NewRecorder()
|
|
||||||
s.Handler().ServeHTTP(rec, httptest.NewRequest("GET", "/dnevnik.txt?k=1CDBD4A6A460", nil))
|
|
||||||
if ct := rec.Header().Get("Content-Type"); !strings.HasPrefix(ct, "text/plain") {
|
|
||||||
t.Errorf("Content-Type = %q", ct)
|
|
||||||
}
|
|
||||||
if !strings.Contains(rec.Body.String(), "prva") {
|
|
||||||
t.Errorf("telo = %q", rec.Body.String())
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
func TestConfigFromEnv(t *testing.T) {
|
|
||||||
t.Setenv("LOGGER_UDP_PORT", "46465")
|
|
||||||
t.Setenv("LOGGER_HTTP_PORT", "8081")
|
|
||||||
t.Setenv("LOGGER_DIR", "/var/log/terminia")
|
|
||||||
cfg, err := ConfigFromEnv()
|
|
||||||
if err != nil {
|
|
||||||
t.Fatalf("ConfigFromEnv: %v", err)
|
|
||||||
}
|
|
||||||
if cfg.UDPPort != 46465 || cfg.HTTPPort != 8081 || cfg.Dir != "/var/log/terminia" {
|
|
||||||
t.Errorf("cfg = %+v", cfg)
|
|
||||||
}
|
|
||||||
|
|
||||||
t.Setenv("LOGGER_UDP_PORT", "nije-broj")
|
|
||||||
if _, err := ConfigFromEnv(); err == nil {
|
|
||||||
t.Error("neispravan port mora dati gresku, ne tihu podrazumevanu vrednost")
|
|
||||||
}
|
|
||||||
|
|
||||||
t.Setenv("LOGGER_UDP_PORT", "46465")
|
|
||||||
t.Setenv("LOGGER_MAX_DEVICE_MB", "5000")
|
|
||||||
t.Setenv("LOGGER_MAX_TOTAL_MB", "100")
|
|
||||||
if _, err := ConfigFromEnv(); err == nil {
|
|
||||||
t.Error("kvota po uredjaju veca od ukupne mora dati gresku")
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
func TestDefaultConfigNijeNaPortuUredjaja(t *testing.T) {
|
|
||||||
// 46464 je port na kom UREDJAJI slusaju discovery - prijemnik tamo ne sme.
|
|
||||||
if DefaultConfig().UDPPort == 46464 {
|
|
||||||
t.Error("podrazumevani UDP port se sudara sa discovery portom uredjaja")
|
|
||||||
}
|
|
||||||
}
|
|
||||||
476
logger/store.go
476
logger/store.go
@ -1,476 +0,0 @@
|
|||||||
package logger
|
|
||||||
|
|
||||||
import (
|
|
||||||
"bufio"
|
|
||||||
"fmt"
|
|
||||||
"io"
|
|
||||||
"os"
|
|
||||||
"path/filepath"
|
|
||||||
"sort"
|
|
||||||
"strings"
|
|
||||||
"sync"
|
|
||||||
"time"
|
|
||||||
)
|
|
||||||
|
|
||||||
// Imena fajlova: dnevni fajl je "2026-07-25.log", a kad prebaci granicu
|
|
||||||
// velicine nastavlja se "2026-07-25.log.001", ".002" ...
|
|
||||||
//
|
|
||||||
// Nastavci su nula-dopunjeni namerno: fajlovi se brisu redom po IMENU, a
|
|
||||||
// leksikografski redosled ovakvih imena je i hronoloski (".log" < ".log.001"
|
|
||||||
// < ".log.002" < sledeci dan). Bez dopune bi ".log.10" doslo pre ".log.2".
|
|
||||||
const (
|
|
||||||
dayLayout = "2006-01-02"
|
|
||||||
logExt = ".log"
|
|
||||||
maxOpenFiles = 64
|
|
||||||
tailReadCap = 2 << 20 // koliko najvise bajtova citamo iz jednog fajla pri prikazu
|
|
||||||
)
|
|
||||||
|
|
||||||
// StoreConfig su granice pisanja. Sve u bajtovima osim KeepDays.
|
|
||||||
type StoreConfig struct {
|
|
||||||
Dir string
|
|
||||||
MaxFileBytes int64 // preko ovoga se rotira na sledeci nastavak
|
|
||||||
MaxDeviceBytes int64 // ukupno po uredjaju
|
|
||||||
MaxTotalBytes int64 // ukupno za sve uredjaje
|
|
||||||
KeepDays int // stariji dnevnici se brisu
|
|
||||||
}
|
|
||||||
|
|
||||||
// Store pise linije dnevnika u fajlove i pazi da ne napuni disk.
|
|
||||||
type Store struct {
|
|
||||||
cfg StoreConfig
|
|
||||||
|
|
||||||
mu sync.Mutex
|
|
||||||
open map[string]*openFile
|
|
||||||
}
|
|
||||||
|
|
||||||
type openFile struct {
|
|
||||||
f *os.File
|
|
||||||
w *bufio.Writer
|
|
||||||
path string
|
|
||||||
day string
|
|
||||||
seq int
|
|
||||||
size int64
|
|
||||||
used time.Time
|
|
||||||
}
|
|
||||||
|
|
||||||
func NewStore(cfg StoreConfig) (*Store, error) {
|
|
||||||
if cfg.Dir == "" {
|
|
||||||
return nil, fmt.Errorf("store: prazna putanja direktorijuma")
|
|
||||||
}
|
|
||||||
if cfg.MaxFileBytes <= 0 {
|
|
||||||
cfg.MaxFileBytes = 10 << 20
|
|
||||||
}
|
|
||||||
if cfg.MaxDeviceBytes <= 0 {
|
|
||||||
cfg.MaxDeviceBytes = 50 << 20
|
|
||||||
}
|
|
||||||
if cfg.MaxTotalBytes <= 0 {
|
|
||||||
cfg.MaxTotalBytes = 1 << 30
|
|
||||||
}
|
|
||||||
if cfg.KeepDays <= 0 {
|
|
||||||
cfg.KeepDays = 14
|
|
||||||
}
|
|
||||||
if err := os.MkdirAll(cfg.Dir, 0o750); err != nil {
|
|
||||||
return nil, fmt.Errorf("store: kreiranje %s: %w", cfg.Dir, err)
|
|
||||||
}
|
|
||||||
return &Store{cfg: cfg, open: make(map[string]*openFile)}, nil
|
|
||||||
}
|
|
||||||
|
|
||||||
// Write dopisuje linije u dnevnik uredjaja. Kljuc MORA biti vec sanitizovan
|
|
||||||
// (DeviceKey), ali se sanitizuje jos jednom - pisanje je poslednja odbrana.
|
|
||||||
func (s *Store) Write(key string, when time.Time, lines []string) error {
|
|
||||||
if len(lines) == 0 {
|
|
||||||
return nil
|
|
||||||
}
|
|
||||||
key = SanitizeSegment(key)
|
|
||||||
|
|
||||||
s.mu.Lock()
|
|
||||||
defer s.mu.Unlock()
|
|
||||||
|
|
||||||
of, err := s.fileForLocked(key, when)
|
|
||||||
if err != nil {
|
|
||||||
return err
|
|
||||||
}
|
|
||||||
stamp := when.Format("2006-01-02 15:04:05")
|
|
||||||
for _, ln := range lines {
|
|
||||||
n, err := fmt.Fprintf(of.w, "%s %s\n", stamp, ln)
|
|
||||||
if err != nil {
|
|
||||||
return fmt.Errorf("store: upis u %s: %w", of.path, err)
|
|
||||||
}
|
|
||||||
of.size += int64(n)
|
|
||||||
}
|
|
||||||
if err := of.w.Flush(); err != nil {
|
|
||||||
return fmt.Errorf("store: pranjenje bafera %s: %w", of.path, err)
|
|
||||||
}
|
|
||||||
of.used = when
|
|
||||||
if of.size >= s.cfg.MaxFileBytes {
|
|
||||||
s.closeLocked(key) // sledeci upis otvara naredni nastavak
|
|
||||||
}
|
|
||||||
return nil
|
|
||||||
}
|
|
||||||
|
|
||||||
func (s *Store) fileForLocked(key string, when time.Time) (*openFile, error) {
|
|
||||||
day := when.Format(dayLayout)
|
|
||||||
if of, ok := s.open[key]; ok {
|
|
||||||
if of.day == day && of.size < s.cfg.MaxFileBytes {
|
|
||||||
return of, nil
|
|
||||||
}
|
|
||||||
s.closeLocked(key)
|
|
||||||
}
|
|
||||||
if len(s.open) >= maxOpenFiles {
|
|
||||||
s.closeIdlestLocked()
|
|
||||||
}
|
|
||||||
dir := filepath.Join(s.cfg.Dir, key)
|
|
||||||
if err := os.MkdirAll(dir, 0o750); err != nil {
|
|
||||||
return nil, fmt.Errorf("store: kreiranje %s: %w", dir, err)
|
|
||||||
}
|
|
||||||
path, size, seq, err := nextPath(dir, day, s.cfg.MaxFileBytes)
|
|
||||||
if err != nil {
|
|
||||||
return nil, err
|
|
||||||
}
|
|
||||||
f, err := os.OpenFile(path, os.O_CREATE|os.O_WRONLY|os.O_APPEND, 0o640)
|
|
||||||
if err != nil {
|
|
||||||
return nil, fmt.Errorf("store: otvaranje %s: %w", path, err)
|
|
||||||
}
|
|
||||||
of := &openFile{f: f, w: bufio.NewWriter(f), path: path, day: day, seq: seq, size: size, used: when}
|
|
||||||
s.open[key] = of
|
|
||||||
return of, nil
|
|
||||||
}
|
|
||||||
|
|
||||||
// nextPath bira u koji fajl se pise za dati dan: osnovni ako jos nije pun,
|
|
||||||
// inace prvi slobodan nastavak.
|
|
||||||
func nextPath(dir, day string, maxBytes int64) (string, int64, int, error) {
|
|
||||||
base := filepath.Join(dir, day+logExt)
|
|
||||||
st, err := os.Stat(base)
|
|
||||||
switch {
|
|
||||||
case os.IsNotExist(err):
|
|
||||||
return base, 0, 0, nil
|
|
||||||
case err != nil:
|
|
||||||
return "", 0, 0, fmt.Errorf("store: stat %s: %w", base, err)
|
|
||||||
case st.Size() < maxBytes:
|
|
||||||
return base, st.Size(), 0, nil
|
|
||||||
}
|
|
||||||
for seq := 1; seq < 1000; seq++ {
|
|
||||||
p := fmt.Sprintf("%s.%03d", base, seq)
|
|
||||||
st, err := os.Stat(p)
|
|
||||||
if os.IsNotExist(err) {
|
|
||||||
return p, 0, seq, nil
|
|
||||||
}
|
|
||||||
if err != nil {
|
|
||||||
return "", 0, 0, fmt.Errorf("store: stat %s: %w", p, err)
|
|
||||||
}
|
|
||||||
if st.Size() < maxBytes {
|
|
||||||
return p, st.Size(), seq, nil
|
|
||||||
}
|
|
||||||
}
|
|
||||||
return "", 0, 0, fmt.Errorf("store: previse nastavaka za %s", base)
|
|
||||||
}
|
|
||||||
|
|
||||||
func (s *Store) closeLocked(key string) {
|
|
||||||
if of, ok := s.open[key]; ok {
|
|
||||||
of.w.Flush()
|
|
||||||
of.f.Close()
|
|
||||||
delete(s.open, key)
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
func (s *Store) closeIdlestLocked() {
|
|
||||||
var key string
|
|
||||||
var oldest time.Time
|
|
||||||
for k, of := range s.open {
|
|
||||||
if key == "" || of.used.Before(oldest) {
|
|
||||||
key, oldest = k, of.used
|
|
||||||
}
|
|
||||||
}
|
|
||||||
if key != "" {
|
|
||||||
s.closeLocked(key)
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
// CloseIdle zatvara fajlove u koje se duze nista ne pise (da se ne drze
|
|
||||||
// otvoreni deskriptori i da rotacija/brisanje ne nailazi na njih).
|
|
||||||
func (s *Store) CloseIdle(now time.Time, idle time.Duration) {
|
|
||||||
s.mu.Lock()
|
|
||||||
defer s.mu.Unlock()
|
|
||||||
for k, of := range s.open {
|
|
||||||
if now.Sub(of.used) > idle {
|
|
||||||
s.closeLocked(k)
|
|
||||||
}
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
// Close zatvara sve otvorene fajlove.
|
|
||||||
func (s *Store) Close() {
|
|
||||||
s.mu.Lock()
|
|
||||||
defer s.mu.Unlock()
|
|
||||||
for k := range s.open {
|
|
||||||
s.closeLocked(k)
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
type logFile struct {
|
|
||||||
key string
|
|
||||||
path string
|
|
||||||
name string
|
|
||||||
day string
|
|
||||||
size int64
|
|
||||||
}
|
|
||||||
|
|
||||||
// list nabraja sve dnevnicke fajlove, sortirane od najstarijeg ka najnovijem.
|
|
||||||
func (s *Store) list() ([]logFile, error) {
|
|
||||||
dirs, err := os.ReadDir(s.cfg.Dir)
|
|
||||||
if err != nil {
|
|
||||||
return nil, fmt.Errorf("store: citanje %s: %w", s.cfg.Dir, err)
|
|
||||||
}
|
|
||||||
var out []logFile
|
|
||||||
for _, d := range dirs {
|
|
||||||
if !d.IsDir() {
|
|
||||||
continue
|
|
||||||
}
|
|
||||||
key := d.Name()
|
|
||||||
files, err := os.ReadDir(filepath.Join(s.cfg.Dir, key))
|
|
||||||
if err != nil {
|
|
||||||
continue // uredjaj bez foldera nije razlog za pad prijemnika
|
|
||||||
}
|
|
||||||
for _, f := range files {
|
|
||||||
name := f.Name()
|
|
||||||
if f.IsDir() || !strings.Contains(name, logExt) {
|
|
||||||
continue
|
|
||||||
}
|
|
||||||
day := name
|
|
||||||
if i := strings.Index(name, logExt); i > 0 {
|
|
||||||
day = name[:i]
|
|
||||||
}
|
|
||||||
if _, err := time.Parse(dayLayout, day); err != nil {
|
|
||||||
continue // tudji fajl u folderu - ne diramo ga
|
|
||||||
}
|
|
||||||
info, err := f.Info()
|
|
||||||
if err != nil {
|
|
||||||
continue
|
|
||||||
}
|
|
||||||
out = append(out, logFile{
|
|
||||||
key: key,
|
|
||||||
path: filepath.Join(s.cfg.Dir, key, name),
|
|
||||||
name: name,
|
|
||||||
day: day,
|
|
||||||
size: info.Size(),
|
|
||||||
})
|
|
||||||
}
|
|
||||||
}
|
|
||||||
sort.Slice(out, func(i, j int) bool {
|
|
||||||
if out[i].name != out[j].name {
|
|
||||||
return out[i].name < out[j].name
|
|
||||||
}
|
|
||||||
return out[i].key < out[j].key
|
|
||||||
})
|
|
||||||
return out, nil
|
|
||||||
}
|
|
||||||
|
|
||||||
// Cleanup sprovodi tri granice redom: starost, kvota po uredjaju, ukupna
|
|
||||||
// kvota. Vraca broj obrisanih fajlova.
|
|
||||||
//
|
|
||||||
// Fajl koji je trenutno otvoren za pisanje se NIKAD ne brise: na Linuxu
|
|
||||||
// brisanje otvorenog fajla ne oslobodi prostor dok se ne zatvori, a upisi
|
|
||||||
// posle toga tiho odlaze u nepostojeci fajl.
|
|
||||||
func (s *Store) Cleanup(now time.Time) (int, error) {
|
|
||||||
files, err := s.list()
|
|
||||||
if err != nil {
|
|
||||||
return 0, err
|
|
||||||
}
|
|
||||||
s.mu.Lock()
|
|
||||||
busy := make(map[string]bool, len(s.open))
|
|
||||||
for _, of := range s.open {
|
|
||||||
busy[of.path] = true
|
|
||||||
}
|
|
||||||
s.mu.Unlock()
|
|
||||||
|
|
||||||
deleted := 0
|
|
||||||
remove := func(f logFile) bool {
|
|
||||||
if busy[f.path] {
|
|
||||||
return false
|
|
||||||
}
|
|
||||||
if err := os.Remove(f.path); err != nil {
|
|
||||||
return false
|
|
||||||
}
|
|
||||||
deleted++
|
|
||||||
return true
|
|
||||||
}
|
|
||||||
|
|
||||||
// 1) starost
|
|
||||||
cutoff := now.AddDate(0, 0, -s.cfg.KeepDays)
|
|
||||||
kept := files[:0]
|
|
||||||
for _, f := range files {
|
|
||||||
d, err := time.Parse(dayLayout, f.day)
|
|
||||||
if err == nil && d.Before(cutoff) && remove(f) {
|
|
||||||
continue
|
|
||||||
}
|
|
||||||
kept = append(kept, f)
|
|
||||||
}
|
|
||||||
files = kept
|
|
||||||
|
|
||||||
// 2) kvota po uredjaju
|
|
||||||
perDevice := map[string]int64{}
|
|
||||||
for _, f := range files {
|
|
||||||
perDevice[f.key] += f.size
|
|
||||||
}
|
|
||||||
kept = files[:0]
|
|
||||||
for _, f := range files {
|
|
||||||
if perDevice[f.key] > s.cfg.MaxDeviceBytes && remove(f) {
|
|
||||||
perDevice[f.key] -= f.size
|
|
||||||
continue
|
|
||||||
}
|
|
||||||
kept = append(kept, f)
|
|
||||||
}
|
|
||||||
files = kept
|
|
||||||
|
|
||||||
// 3) ukupna kvota
|
|
||||||
var total int64
|
|
||||||
for _, f := range files {
|
|
||||||
total += f.size
|
|
||||||
}
|
|
||||||
for _, f := range files {
|
|
||||||
if total <= s.cfg.MaxTotalBytes {
|
|
||||||
break
|
|
||||||
}
|
|
||||||
if remove(f) {
|
|
||||||
total -= f.size
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
s.pruneEmptyDirs()
|
|
||||||
return deleted, nil
|
|
||||||
}
|
|
||||||
|
|
||||||
// pruneEmptyDirs brise foldere uredjaja koji su ostali bez ijednog dnevnika.
|
|
||||||
func (s *Store) pruneEmptyDirs() {
|
|
||||||
dirs, err := os.ReadDir(s.cfg.Dir)
|
|
||||||
if err != nil {
|
|
||||||
return
|
|
||||||
}
|
|
||||||
for _, d := range dirs {
|
|
||||||
if !d.IsDir() {
|
|
||||||
continue
|
|
||||||
}
|
|
||||||
p := filepath.Join(s.cfg.Dir, d.Name())
|
|
||||||
if entries, err := os.ReadDir(p); err == nil && len(entries) == 0 {
|
|
||||||
os.Remove(p)
|
|
||||||
}
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
// Usage vraca ukupno zauzece na disku (bajtova) i broj fajlova.
|
|
||||||
func (s *Store) Usage() (int64, int) {
|
|
||||||
files, err := s.list()
|
|
||||||
if err != nil {
|
|
||||||
return 0, 0
|
|
||||||
}
|
|
||||||
var total int64
|
|
||||||
for _, f := range files {
|
|
||||||
total += f.size
|
|
||||||
}
|
|
||||||
return total, len(files)
|
|
||||||
}
|
|
||||||
|
|
||||||
// Tail vraca poslednjih n linija dnevnika jednog uredjaja, opciono filtriranih
|
|
||||||
// po tekstu (bez razlike u velicini slova). Redosled je hronoloski.
|
|
||||||
func (s *Store) Tail(key string, n int, query string) ([]string, error) {
|
|
||||||
key = SanitizeSegment(key)
|
|
||||||
if n <= 0 || n > 5000 {
|
|
||||||
n = 200
|
|
||||||
}
|
|
||||||
// Bafer se prazni da bi i linije primljene pre sekund bile vidljive.
|
|
||||||
s.mu.Lock()
|
|
||||||
if of, ok := s.open[key]; ok {
|
|
||||||
of.w.Flush()
|
|
||||||
}
|
|
||||||
s.mu.Unlock()
|
|
||||||
|
|
||||||
files, err := s.list()
|
|
||||||
if err != nil {
|
|
||||||
return nil, err
|
|
||||||
}
|
|
||||||
var mine []logFile
|
|
||||||
for _, f := range files {
|
|
||||||
if f.key == key {
|
|
||||||
mine = append(mine, f)
|
|
||||||
}
|
|
||||||
}
|
|
||||||
q := strings.ToLower(strings.TrimSpace(query))
|
|
||||||
|
|
||||||
out := make([]string, 0, n)
|
|
||||||
// od najnovijeg fajla unazad, dok se ne skupi n linija
|
|
||||||
for i := len(mine) - 1; i >= 0 && len(out) < n; i-- {
|
|
||||||
lines, err := readTailLines(mine[i].path, tailReadCap)
|
|
||||||
if err != nil {
|
|
||||||
continue
|
|
||||||
}
|
|
||||||
for j := len(lines) - 1; j >= 0 && len(out) < n; j-- {
|
|
||||||
if q != "" && !strings.Contains(strings.ToLower(lines[j]), q) {
|
|
||||||
continue
|
|
||||||
}
|
|
||||||
out = append(out, lines[j])
|
|
||||||
}
|
|
||||||
}
|
|
||||||
// out je od najnovije ka najstarijoj - okrecemo
|
|
||||||
for i, j := 0, len(out)-1; i < j; i, j = i+1, j-1 {
|
|
||||||
out[i], out[j] = out[j], out[i]
|
|
||||||
}
|
|
||||||
return out, nil
|
|
||||||
}
|
|
||||||
|
|
||||||
// readTailLines cita poslednjih najvise cap bajtova fajla i vraca cele linije.
|
|
||||||
func readTailLines(path string, cap int64) ([]string, error) {
|
|
||||||
f, err := os.Open(path)
|
|
||||||
if err != nil {
|
|
||||||
return nil, err
|
|
||||||
}
|
|
||||||
defer f.Close()
|
|
||||||
st, err := f.Stat()
|
|
||||||
if err != nil {
|
|
||||||
return nil, err
|
|
||||||
}
|
|
||||||
size := st.Size()
|
|
||||||
off := int64(0)
|
|
||||||
if size > cap {
|
|
||||||
off = size - cap
|
|
||||||
}
|
|
||||||
if _, err := f.Seek(off, io.SeekStart); err != nil {
|
|
||||||
return nil, err
|
|
||||||
}
|
|
||||||
buf := make([]byte, size-off)
|
|
||||||
if _, err := io.ReadFull(f, buf); err != nil && err != io.ErrUnexpectedEOF {
|
|
||||||
return nil, err
|
|
||||||
}
|
|
||||||
text := string(buf)
|
|
||||||
if off > 0 {
|
|
||||||
// prva linija je verovatno presecena na pola - odbacujemo je
|
|
||||||
if i := strings.IndexByte(text, '\n'); i >= 0 {
|
|
||||||
text = text[i+1:]
|
|
||||||
}
|
|
||||||
}
|
|
||||||
lines := strings.Split(text, "\n")
|
|
||||||
out := lines[:0]
|
|
||||||
for _, ln := range lines {
|
|
||||||
if strings.TrimSpace(ln) != "" {
|
|
||||||
out = append(out, ln)
|
|
||||||
}
|
|
||||||
}
|
|
||||||
return out, nil
|
|
||||||
}
|
|
||||||
|
|
||||||
// Days vraca datume za koje postoji dnevnik datog uredjaja (najnoviji prvi).
|
|
||||||
func (s *Store) Days(key string) []string {
|
|
||||||
key = SanitizeSegment(key)
|
|
||||||
files, err := s.list()
|
|
||||||
if err != nil {
|
|
||||||
return nil
|
|
||||||
}
|
|
||||||
seen := map[string]bool{}
|
|
||||||
var out []string
|
|
||||||
for i := len(files) - 1; i >= 0; i-- {
|
|
||||||
if files[i].key != key || seen[files[i].day] {
|
|
||||||
continue
|
|
||||||
}
|
|
||||||
seen[files[i].day] = true
|
|
||||||
out = append(out, files[i].day)
|
|
||||||
}
|
|
||||||
return out
|
|
||||||
}
|
|
||||||
@ -1,245 +0,0 @@
|
|||||||
package logger
|
|
||||||
|
|
||||||
import (
|
|
||||||
"fmt"
|
|
||||||
"os"
|
|
||||||
"path/filepath"
|
|
||||||
"strings"
|
|
||||||
"testing"
|
|
||||||
"time"
|
|
||||||
)
|
|
||||||
|
|
||||||
func testStore(t *testing.T, cfg StoreConfig) *Store {
|
|
||||||
t.Helper()
|
|
||||||
cfg.Dir = t.TempDir()
|
|
||||||
s, err := NewStore(cfg)
|
|
||||||
if err != nil {
|
|
||||||
t.Fatalf("NewStore: %v", err)
|
|
||||||
}
|
|
||||||
t.Cleanup(s.Close)
|
|
||||||
return s
|
|
||||||
}
|
|
||||||
|
|
||||||
func TestStorePiseIVracaLinije(t *testing.T) {
|
|
||||||
s := testStore(t, StoreConfig{})
|
|
||||||
t0 := time.Date(2026, 7, 25, 12, 0, 0, 0, time.UTC)
|
|
||||||
|
|
||||||
if err := s.Write("1CDBD4A6A460", t0, []string{"prva", "druga"}); err != nil {
|
|
||||||
t.Fatalf("Write: %v", err)
|
|
||||||
}
|
|
||||||
if err := s.Write("1CDBD4A6A460", t0.Add(time.Second), []string{"treca"}); err != nil {
|
|
||||||
t.Fatalf("Write: %v", err)
|
|
||||||
}
|
|
||||||
|
|
||||||
lines, err := s.Tail("1CDBD4A6A460", 10, "")
|
|
||||||
if err != nil {
|
|
||||||
t.Fatalf("Tail: %v", err)
|
|
||||||
}
|
|
||||||
if len(lines) != 3 {
|
|
||||||
t.Fatalf("linija = %d: %q", len(lines), lines)
|
|
||||||
}
|
|
||||||
if !strings.HasSuffix(lines[0], "prva") || !strings.HasSuffix(lines[2], "treca") {
|
|
||||||
t.Errorf("redosled nije hronoloski: %q", lines)
|
|
||||||
}
|
|
||||||
if !strings.HasPrefix(lines[0], "2026-07-25 12:00:00") {
|
|
||||||
t.Errorf("nedostaje vremenska oznaka: %q", lines[0])
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
func TestStorePretraga(t *testing.T) {
|
|
||||||
s := testStore(t, StoreConfig{})
|
|
||||||
t0 := time.Now()
|
|
||||||
s.Write("dev", t0, []string{"[stampac] greska", "[kapija] prolaz", "[stampac] ok"})
|
|
||||||
|
|
||||||
lines, _ := s.Tail("dev", 10, "STAMPAC")
|
|
||||||
if len(lines) != 2 {
|
|
||||||
t.Fatalf("pretraga = %d linija: %q", len(lines), lines)
|
|
||||||
}
|
|
||||||
lines, _ = s.Tail("dev", 10, "nepostojece")
|
|
||||||
if len(lines) != 0 {
|
|
||||||
t.Errorf("ocekivano 0 linija, dobijeno %q", lines)
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
func TestStoreOgranicavaBrojLinija(t *testing.T) {
|
|
||||||
s := testStore(t, StoreConfig{})
|
|
||||||
t0 := time.Now()
|
|
||||||
for i := 0; i < 100; i++ {
|
|
||||||
s.Write("dev", t0, []string{fmt.Sprintf("linija %d", i)})
|
|
||||||
}
|
|
||||||
lines, _ := s.Tail("dev", 10, "")
|
|
||||||
if len(lines) != 10 {
|
|
||||||
t.Fatalf("linija = %d", len(lines))
|
|
||||||
}
|
|
||||||
if !strings.HasSuffix(lines[9], "linija 99") {
|
|
||||||
t.Errorf("poslednja linija = %q", lines[9])
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
func TestStoreRotacijaPoVelicini(t *testing.T) {
|
|
||||||
s := testStore(t, StoreConfig{MaxFileBytes: 200})
|
|
||||||
t0 := time.Date(2026, 7, 25, 12, 0, 0, 0, time.UTC)
|
|
||||||
for i := 0; i < 30; i++ {
|
|
||||||
if err := s.Write("dev", t0, []string{fmt.Sprintf("popunjavanje %02d", i)}); err != nil {
|
|
||||||
t.Fatalf("Write: %v", err)
|
|
||||||
}
|
|
||||||
}
|
|
||||||
files, err := os.ReadDir(filepath.Join(s.cfg.Dir, "dev"))
|
|
||||||
if err != nil {
|
|
||||||
t.Fatalf("ReadDir: %v", err)
|
|
||||||
}
|
|
||||||
if len(files) < 2 {
|
|
||||||
t.Fatalf("ocekivana rotacija, fajlova = %d", len(files))
|
|
||||||
}
|
|
||||||
var imena []string
|
|
||||||
for _, f := range files {
|
|
||||||
imena = append(imena, f.Name())
|
|
||||||
if info, _ := f.Info(); info.Size() > 400 {
|
|
||||||
t.Errorf("fajl %s je %d B — granica se ne postuje", f.Name(), info.Size())
|
|
||||||
}
|
|
||||||
}
|
|
||||||
if imena[0] != "2026-07-25.log" || imena[1] != "2026-07-25.log.001" {
|
|
||||||
t.Errorf("imena fajlova = %q", imena)
|
|
||||||
}
|
|
||||||
// Sve linije se i dalje citaju, hronoloski.
|
|
||||||
lines, _ := s.Tail("dev", 100, "")
|
|
||||||
if len(lines) != 30 {
|
|
||||||
t.Errorf("procitano %d linija, ocekivano 30", len(lines))
|
|
||||||
}
|
|
||||||
if !strings.HasSuffix(lines[0], "popunjavanje 00") || !strings.HasSuffix(lines[29], "popunjavanje 29") {
|
|
||||||
t.Errorf("redosled kroz rotirane fajlove nije dobar: %q ... %q", lines[0], lines[29])
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
func TestStoreNoviDanNoviFajl(t *testing.T) {
|
|
||||||
s := testStore(t, StoreConfig{})
|
|
||||||
t0 := time.Date(2026, 7, 25, 23, 59, 0, 0, time.UTC)
|
|
||||||
s.Write("dev", t0, []string{"juce"})
|
|
||||||
s.Write("dev", t0.Add(2*time.Minute), []string{"danas"})
|
|
||||||
|
|
||||||
dani := s.Days("dev")
|
|
||||||
if len(dani) != 2 || dani[0] != "2026-07-26" || dani[1] != "2026-07-25" {
|
|
||||||
t.Errorf("dani = %q", dani)
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
func TestCleanupBriseStareDnevnike(t *testing.T) {
|
|
||||||
s := testStore(t, StoreConfig{KeepDays: 3})
|
|
||||||
now := time.Date(2026, 7, 25, 12, 0, 0, 0, time.UTC)
|
|
||||||
for i := 0; i < 10; i++ {
|
|
||||||
s.Write("dev", now.AddDate(0, 0, -i), []string{"nesto"})
|
|
||||||
}
|
|
||||||
s.Close() // da ciscenje sme da dira i tekuci fajl
|
|
||||||
|
|
||||||
n, err := s.Cleanup(now)
|
|
||||||
if err != nil {
|
|
||||||
t.Fatalf("Cleanup: %v", err)
|
|
||||||
}
|
|
||||||
if n == 0 {
|
|
||||||
t.Fatal("nista nije obrisano")
|
|
||||||
}
|
|
||||||
dani := s.Days("dev")
|
|
||||||
for _, d := range dani {
|
|
||||||
dd, _ := time.Parse(dayLayout, d)
|
|
||||||
if dd.Before(now.AddDate(0, 0, -3)) {
|
|
||||||
t.Errorf("ostao stari dnevnik %s", d)
|
|
||||||
}
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
func TestCleanupPostujeKvotuPoUredjaju(t *testing.T) {
|
|
||||||
s := testStore(t, StoreConfig{MaxFileBytes: 300, MaxDeviceBytes: 600, KeepDays: 3650})
|
|
||||||
base := time.Date(2026, 7, 1, 12, 0, 0, 0, time.UTC)
|
|
||||||
for i := 0; i < 20; i++ {
|
|
||||||
s.Write("dev", base.AddDate(0, 0, i), []string{strings.Repeat("x", 200)})
|
|
||||||
}
|
|
||||||
s.Close()
|
|
||||||
|
|
||||||
if _, err := s.Cleanup(base.AddDate(0, 0, 20)); err != nil {
|
|
||||||
t.Fatalf("Cleanup: %v", err)
|
|
||||||
}
|
|
||||||
total, _ := s.Usage()
|
|
||||||
if total > 600 {
|
|
||||||
t.Errorf("posle ciscenja %d B, kvota je 600 B", total)
|
|
||||||
}
|
|
||||||
if total == 0 {
|
|
||||||
t.Error("ciscenje je obrisalo sve — najnoviji dnevnik mora ostati")
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
func TestCleanupPostujeUkupnuKvotu(t *testing.T) {
|
|
||||||
s := testStore(t, StoreConfig{MaxFileBytes: 300, MaxDeviceBytes: 1 << 20, MaxTotalBytes: 800, KeepDays: 3650})
|
|
||||||
base := time.Date(2026, 7, 1, 12, 0, 0, 0, time.UTC)
|
|
||||||
for i := 0; i < 10; i++ {
|
|
||||||
s.Write(fmt.Sprintf("dev%d", i), base.AddDate(0, 0, i), []string{strings.Repeat("y", 200)})
|
|
||||||
}
|
|
||||||
s.Close()
|
|
||||||
|
|
||||||
if _, err := s.Cleanup(base.AddDate(0, 0, 10)); err != nil {
|
|
||||||
t.Fatalf("Cleanup: %v", err)
|
|
||||||
}
|
|
||||||
total, _ := s.Usage()
|
|
||||||
if total > 800 {
|
|
||||||
t.Errorf("posle ciscenja %d B, ukupna kvota je 800 B", total)
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
func TestCleanupNeBriseOtvoreniFajl(t *testing.T) {
|
|
||||||
// Fajl u koji se trenutno pise ne sme da nestane: na Linuxu bi upisi
|
|
||||||
// posle brisanja tiho odlazili u nepostojeci fajl.
|
|
||||||
s := testStore(t, StoreConfig{MaxTotalBytes: 1, MaxDeviceBytes: 1, KeepDays: 1})
|
|
||||||
now := time.Date(2026, 7, 25, 12, 0, 0, 0, time.UTC)
|
|
||||||
s.Write("dev", now, []string{"vazna linija"})
|
|
||||||
|
|
||||||
if _, err := s.Cleanup(now); err != nil {
|
|
||||||
t.Fatalf("Cleanup: %v", err)
|
|
||||||
}
|
|
||||||
if _, err := os.Stat(filepath.Join(s.cfg.Dir, "dev", "2026-07-25.log")); err != nil {
|
|
||||||
t.Errorf("otvoreni fajl je obrisan: %v", err)
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
func TestStoreOdbijaIzlazakIzFoldera(t *testing.T) {
|
|
||||||
s := testStore(t, StoreConfig{})
|
|
||||||
now := time.Now()
|
|
||||||
if err := s.Write("../../../pobegao", now, []string{"linija"}); err != nil {
|
|
||||||
t.Fatalf("Write: %v", err)
|
|
||||||
}
|
|
||||||
// Sve mora ostati unutar Dir.
|
|
||||||
var vanFoldera []string
|
|
||||||
filepath.Walk(filepath.Dir(s.cfg.Dir), func(p string, info os.FileInfo, err error) error {
|
|
||||||
if err != nil || info.IsDir() {
|
|
||||||
return nil
|
|
||||||
}
|
|
||||||
if !strings.HasPrefix(p, s.cfg.Dir) {
|
|
||||||
vanFoldera = append(vanFoldera, p)
|
|
||||||
}
|
|
||||||
return nil
|
|
||||||
})
|
|
||||||
if len(vanFoldera) > 0 {
|
|
||||||
t.Errorf("fajlovi napravljeni van foldera dnevnika: %q", vanFoldera)
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
func TestTailPreseceneLinijeNaGranici(t *testing.T) {
|
|
||||||
s := testStore(t, StoreConfig{})
|
|
||||||
now := time.Now()
|
|
||||||
s.Write("dev", now, []string{"cela linija jedan", "cela linija dva"})
|
|
||||||
lines, _ := s.Tail("dev", 5, "")
|
|
||||||
for _, ln := range lines {
|
|
||||||
if !strings.Contains(ln, "cela linija") {
|
|
||||||
t.Errorf("krnja linija u ispisu: %q", ln)
|
|
||||||
}
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
func TestTailNepostojeciUredjaj(t *testing.T) {
|
|
||||||
s := testStore(t, StoreConfig{})
|
|
||||||
lines, err := s.Tail("nema-ga", 10, "")
|
|
||||||
if err != nil {
|
|
||||||
t.Fatalf("Tail: %v", err)
|
|
||||||
}
|
|
||||||
if len(lines) != 0 {
|
|
||||||
t.Errorf("linije = %q", lines)
|
|
||||||
}
|
|
||||||
}
|
|
||||||
365
logger/web.go
365
logger/web.go
@ -1,365 +0,0 @@
|
|||||||
package logger
|
|
||||||
|
|
||||||
import (
|
|
||||||
"encoding/json"
|
|
||||||
"fmt"
|
|
||||||
"html/template"
|
|
||||||
"net/http"
|
|
||||||
"strconv"
|
|
||||||
"strings"
|
|
||||||
"time"
|
|
||||||
)
|
|
||||||
|
|
||||||
// Handler vraca ceo web sloj prijemnika (bez baze, bez spoljnih biblioteka).
|
|
||||||
func (s *Service) Handler() http.Handler {
|
|
||||||
mux := http.NewServeMux()
|
|
||||||
mux.HandleFunc("GET /", s.pageIndex)
|
|
||||||
mux.HandleFunc("GET /uredjaj", s.pageDevice)
|
|
||||||
mux.HandleFunc("GET /dnevnik.txt", s.pageRaw)
|
|
||||||
mux.HandleFunc("GET /api/uredjaji", s.apiDevices)
|
|
||||||
return s.withToken(mux)
|
|
||||||
}
|
|
||||||
|
|
||||||
// withToken je minimalna zastita kad web nije samo na 127.0.0.1. Token se
|
|
||||||
// prihvata iz ?t= ili iz zaglavlja X-Token; posle prvog uspesnog upita pamti se
|
|
||||||
// u kolacicu da linkovi ostanu kratki.
|
|
||||||
//
|
|
||||||
// Ovo NIJE zamena za nginx + TLS + lozinku - dnevnik sadrzi brojeve karata.
|
|
||||||
func (s *Service) withToken(next http.Handler) http.Handler {
|
|
||||||
if s.cfg.Token == "" {
|
|
||||||
return next
|
|
||||||
}
|
|
||||||
return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
|
|
||||||
ok := r.URL.Query().Get("t") == s.cfg.Token || r.Header.Get("X-Token") == s.cfg.Token
|
|
||||||
if !ok {
|
|
||||||
if c, err := r.Cookie("logger_token"); err == nil && c.Value == s.cfg.Token {
|
|
||||||
ok = true
|
|
||||||
}
|
|
||||||
}
|
|
||||||
if !ok {
|
|
||||||
http.Error(w, "Pristup odbijen: nedostaje token.", http.StatusForbidden)
|
|
||||||
return
|
|
||||||
}
|
|
||||||
http.SetCookie(w, &http.Cookie{
|
|
||||||
Name: "logger_token", Value: s.cfg.Token, Path: "/",
|
|
||||||
HttpOnly: true, SameSite: http.SameSiteLaxMode, MaxAge: 12 * 3600,
|
|
||||||
})
|
|
||||||
next.ServeHTTP(w, r)
|
|
||||||
})
|
|
||||||
}
|
|
||||||
|
|
||||||
type deviceView struct {
|
|
||||||
Key string
|
|
||||||
Naziv string
|
|
||||||
MAC string
|
|
||||||
IP string
|
|
||||||
FW string
|
|
||||||
Serijski string
|
|
||||||
Poznat bool
|
|
||||||
Tih bool
|
|
||||||
Vidjen string
|
|
||||||
Heartbeat string
|
|
||||||
Interval int
|
|
||||||
Paketa uint64
|
|
||||||
Linija uint64
|
|
||||||
Poslednja string
|
|
||||||
IzvornaIP string
|
|
||||||
PrviPutStr string
|
|
||||||
}
|
|
||||||
|
|
||||||
type indexData struct {
|
|
||||||
Uredjaji []deviceView
|
|
||||||
Ukupno int
|
|
||||||
Paketa uint64
|
|
||||||
Heartbeata uint64
|
|
||||||
Dnevnika uint64
|
|
||||||
Smece uint64
|
|
||||||
Greske uint64
|
|
||||||
DiskMB string
|
|
||||||
Fajlova int
|
|
||||||
UDP string
|
|
||||||
Port int
|
|
||||||
Dir string
|
|
||||||
Vreme string
|
|
||||||
Token string
|
|
||||||
}
|
|
||||||
|
|
||||||
type deviceData struct {
|
|
||||||
U deviceView
|
|
||||||
Linije []string
|
|
||||||
Q string
|
|
||||||
N int
|
|
||||||
Dani []string
|
|
||||||
Vreme string
|
|
||||||
Token string
|
|
||||||
Nadjen bool
|
|
||||||
}
|
|
||||||
|
|
||||||
func (s *Service) view(d Device, now time.Time) deviceView {
|
|
||||||
naziv := d.Name
|
|
||||||
if naziv == "" {
|
|
||||||
naziv = "(bez naziva)"
|
|
||||||
}
|
|
||||||
hb := "nikad"
|
|
||||||
if !d.LastHeartbeat.IsZero() {
|
|
||||||
hb = humanAgo(now.Sub(d.LastHeartbeat))
|
|
||||||
}
|
|
||||||
return deviceView{
|
|
||||||
Key: d.Key,
|
|
||||||
Naziv: naziv,
|
|
||||||
MAC: d.MAC,
|
|
||||||
IP: d.IP,
|
|
||||||
FW: d.FW,
|
|
||||||
Serijski: d.Serial,
|
|
||||||
Poznat: d.Identified,
|
|
||||||
Tih: s.reg.Stale(&d, now),
|
|
||||||
Vidjen: humanAgo(now.Sub(d.LastSeen)),
|
|
||||||
Heartbeat: hb,
|
|
||||||
Interval: s.reg.Interval(&d),
|
|
||||||
Paketa: d.LogPackets + d.Heartbeats,
|
|
||||||
Linija: d.LogLines,
|
|
||||||
Poslednja: d.LastLine,
|
|
||||||
IzvornaIP: d.SourceIP,
|
|
||||||
PrviPutStr: d.FirstSeen.Format("02.01.2006. 15:04:05"),
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
// humanAgo pise razmak vremena na srpskom, kratko.
|
|
||||||
func humanAgo(d time.Duration) string {
|
|
||||||
switch {
|
|
||||||
case d < 2*time.Second:
|
|
||||||
return "upravo sada"
|
|
||||||
case d < time.Minute:
|
|
||||||
return fmt.Sprintf("pre %d s", int(d.Seconds()))
|
|
||||||
case d < time.Hour:
|
|
||||||
return fmt.Sprintf("pre %d min", int(d.Minutes()))
|
|
||||||
case d < 48*time.Hour:
|
|
||||||
return fmt.Sprintf("pre %d h", int(d.Hours()))
|
|
||||||
default:
|
|
||||||
return fmt.Sprintf("pre %d dana", int(d.Hours()/24))
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
func (s *Service) pageIndex(w http.ResponseWriter, r *http.Request) {
|
|
||||||
if r.URL.Path != "/" {
|
|
||||||
http.NotFound(w, r)
|
|
||||||
return
|
|
||||||
}
|
|
||||||
now := s.now()
|
|
||||||
devs := s.reg.Snapshot(now)
|
|
||||||
views := make([]deviceView, 0, len(devs))
|
|
||||||
for _, d := range devs {
|
|
||||||
views = append(views, s.view(d, now))
|
|
||||||
}
|
|
||||||
bytes, files := s.store.Usage()
|
|
||||||
data := indexData{
|
|
||||||
Uredjaji: views,
|
|
||||||
Ukupno: len(views),
|
|
||||||
Paketa: s.stats.Packets.Load(),
|
|
||||||
Heartbeata: s.stats.Heartbeat.Load(),
|
|
||||||
Dnevnika: s.stats.LogPkts.Load(),
|
|
||||||
Smece: s.stats.Garbage.Load(),
|
|
||||||
Greske: s.stats.WriteErrs.Load(),
|
|
||||||
DiskMB: fmt.Sprintf("%.1f", float64(bytes)/(1<<20)),
|
|
||||||
Fajlova: files,
|
|
||||||
UDP: fmt.Sprintf("%s:%d", orAll(s.cfg.UDPHost), s.cfg.UDPPort),
|
|
||||||
Port: s.cfg.UDPPort,
|
|
||||||
Dir: s.cfg.Dir,
|
|
||||||
Vreme: now.Format("02.01.2006. 15:04:05"),
|
|
||||||
Token: s.cfg.Token,
|
|
||||||
}
|
|
||||||
render(w, tmplIndex, data)
|
|
||||||
}
|
|
||||||
|
|
||||||
func (s *Service) pageDevice(w http.ResponseWriter, r *http.Request) {
|
|
||||||
key := SanitizeSegment(r.URL.Query().Get("k"))
|
|
||||||
q := r.URL.Query().Get("q")
|
|
||||||
if len(q) > 200 {
|
|
||||||
q = q[:200]
|
|
||||||
}
|
|
||||||
n := 200
|
|
||||||
if v := r.URL.Query().Get("n"); v != "" {
|
|
||||||
if x, err := strconv.Atoi(v); err == nil && x > 0 && x <= 5000 {
|
|
||||||
n = x
|
|
||||||
}
|
|
||||||
}
|
|
||||||
now := s.now()
|
|
||||||
data := deviceData{Q: q, N: n, Vreme: now.Format("02.01.2006. 15:04:05"), Token: s.cfg.Token}
|
|
||||||
if d, ok := s.reg.Get(key); ok {
|
|
||||||
data.U = s.view(d, now)
|
|
||||||
data.Nadjen = true
|
|
||||||
} else {
|
|
||||||
// Uredjaj moze postojati samo na disku (posle restarta prijemnika).
|
|
||||||
data.U = deviceView{Key: key, Naziv: "(nije se javio od pokretanja prijemnika)"}
|
|
||||||
}
|
|
||||||
lines, err := s.store.Tail(key, n, q)
|
|
||||||
if err != nil {
|
|
||||||
lines = []string{"Greska pri citanju dnevnika: " + err.Error()}
|
|
||||||
}
|
|
||||||
data.Linije = lines
|
|
||||||
data.Dani = s.store.Days(key)
|
|
||||||
render(w, tmplDevice, data)
|
|
||||||
}
|
|
||||||
|
|
||||||
// pageRaw daje isti sadrzaj kao stranica, ali kao cist tekst - za curl sa
|
|
||||||
// servera i za lepljenje u prepisku.
|
|
||||||
func (s *Service) pageRaw(w http.ResponseWriter, r *http.Request) {
|
|
||||||
key := SanitizeSegment(r.URL.Query().Get("k"))
|
|
||||||
n := 500
|
|
||||||
if v := r.URL.Query().Get("n"); v != "" {
|
|
||||||
if x, err := strconv.Atoi(v); err == nil && x > 0 && x <= 5000 {
|
|
||||||
n = x
|
|
||||||
}
|
|
||||||
}
|
|
||||||
lines, err := s.store.Tail(key, n, r.URL.Query().Get("q"))
|
|
||||||
if err != nil {
|
|
||||||
http.Error(w, "Greska: "+err.Error(), http.StatusInternalServerError)
|
|
||||||
return
|
|
||||||
}
|
|
||||||
w.Header().Set("Content-Type", "text/plain; charset=utf-8")
|
|
||||||
w.Write([]byte(strings.Join(lines, "\n") + "\n"))
|
|
||||||
}
|
|
||||||
|
|
||||||
func (s *Service) apiDevices(w http.ResponseWriter, r *http.Request) {
|
|
||||||
now := s.now()
|
|
||||||
devs := s.reg.Snapshot(now)
|
|
||||||
out := make([]map[string]any, 0, len(devs))
|
|
||||||
for _, d := range devs {
|
|
||||||
out = append(out, map[string]any{
|
|
||||||
"kljuc": d.Key,
|
|
||||||
"naziv": d.Name,
|
|
||||||
"mac": d.MAC,
|
|
||||||
"ip": d.IP,
|
|
||||||
"izvorna_ip": d.SourceIP,
|
|
||||||
"fw": d.FW,
|
|
||||||
"serijski": d.Serial,
|
|
||||||
"identifikovan": d.Identified,
|
|
||||||
"tih": s.reg.Stale(&d, now),
|
|
||||||
"interval_sek": s.reg.Interval(&d),
|
|
||||||
"poslednji_put": d.LastSeen.Format(time.RFC3339),
|
|
||||||
"heartbeata": d.Heartbeats,
|
|
||||||
"paketa_dnevnik": d.LogPackets,
|
|
||||||
"linija": d.LogLines,
|
|
||||||
})
|
|
||||||
}
|
|
||||||
w.Header().Set("Content-Type", "application/json; charset=utf-8")
|
|
||||||
enc := json.NewEncoder(w)
|
|
||||||
enc.SetIndent("", " ")
|
|
||||||
enc.Encode(map[string]any{"uredjaji": out, "vreme": now.Format(time.RFC3339)})
|
|
||||||
}
|
|
||||||
|
|
||||||
func orAll(h string) string {
|
|
||||||
if h == "" {
|
|
||||||
return "0.0.0.0"
|
|
||||||
}
|
|
||||||
return h
|
|
||||||
}
|
|
||||||
|
|
||||||
func render(w http.ResponseWriter, t *template.Template, data any) {
|
|
||||||
w.Header().Set("Content-Type", "text/html; charset=utf-8")
|
|
||||||
if err := t.Execute(w, data); err != nil {
|
|
||||||
http.Error(w, "Greska pri prikazu: "+err.Error(), http.StatusInternalServerError)
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
const cssCommon = `
|
|
||||||
body{font-family:system-ui,Segoe UI,Arial,sans-serif;margin:0;background:#f4f6f8;color:#1c2733}
|
|
||||||
header{background:#12354f;color:#fff;padding:12px 18px;display:flex;gap:16px;align-items:baseline;flex-wrap:wrap}
|
|
||||||
header h1{font-size:18px;margin:0}
|
|
||||||
header a{color:#9fd3ff;text-decoration:none}
|
|
||||||
main{padding:16px 18px;max-width:1200px}
|
|
||||||
table{border-collapse:collapse;width:100%;background:#fff;box-shadow:0 1px 2px rgba(0,0,0,.12)}
|
|
||||||
th,td{padding:7px 10px;text-align:left;border-bottom:1px solid #e3e8ee;font-size:14px;vertical-align:top}
|
|
||||||
th{background:#eef2f6;font-weight:600}
|
|
||||||
tr.tih td{background:#ffe9e9}
|
|
||||||
.znak{display:inline-block;padding:1px 7px;border-radius:9px;font-size:12px;font-weight:600}
|
|
||||||
.ok{background:#d6f5dd;color:#0f6b2b}
|
|
||||||
.lose{background:#ffd2d2;color:#a11}
|
|
||||||
.nepoznat{background:#ffeccc;color:#8a5300}
|
|
||||||
.mali{color:#5a6b7b;font-size:12px}
|
|
||||||
pre{background:#0f1b26;color:#dbe7f0;padding:12px;border-radius:4px;overflow:auto;font-size:13px;line-height:1.45;max-height:70vh}
|
|
||||||
form.pretraga{margin:12px 0;display:flex;gap:8px;flex-wrap:wrap}
|
|
||||||
input,select{padding:6px 8px;border:1px solid #c6d0da;border-radius:4px;font-size:14px}
|
|
||||||
button{padding:6px 14px;border:0;border-radius:4px;background:#12354f;color:#fff;font-size:14px;cursor:pointer}
|
|
||||||
.prazno{padding:24px;background:#fff;color:#5a6b7b}
|
|
||||||
`
|
|
||||||
|
|
||||||
var tmplIndex = template.Must(template.New("index").Parse(`<!doctype html>
|
|
||||||
<html lang="sr"><head><meta charset="utf-8">
|
|
||||||
<meta name="viewport" content="width=device-width,initial-scale=1">
|
|
||||||
<meta http-equiv="refresh" content="10">
|
|
||||||
<title>Prijemnik dijagnostike — TERMINIA</title>
|
|
||||||
<style>` + cssCommon + `</style></head>
|
|
||||||
<body>
|
|
||||||
<header><h1>Prijemnik dijagnostike</h1>
|
|
||||||
<span class="mali">UDP {{.UDP}} · dnevnici: {{.Dir}} ({{.DiskMB}} MB / {{.Fajlova}} fajlova)</span>
|
|
||||||
<span class="mali">osveženo {{.Vreme}}</span></header>
|
|
||||||
<main>
|
|
||||||
<p class="mali">Uređaja: <b>{{.Ukupno}}</b> · primljeno paketa: {{.Paketa}}
|
|
||||||
(heartbeat {{.Heartbeata}}, dnevnik {{.Dnevnika}}, odbačeno {{.Smece}}) · greške upisa: {{.Greske}}</p>
|
|
||||||
{{if .Uredjaji}}
|
|
||||||
<table>
|
|
||||||
<tr><th>Uređaj</th><th>MAC</th><th>IP</th><th>FW</th><th>Stanje</th><th>Poslednji put</th><th>Heartbeat</th><th>Linija</th><th>Poslednja linija</th></tr>
|
|
||||||
{{range .Uredjaji}}
|
|
||||||
<tr {{if .Tih}}class="tih"{{end}}>
|
|
||||||
<td><a href="/uredjaj?k={{.Key}}{{if $.Token}}&t={{$.Token}}{{end}}"><b>{{.Naziv}}</b></a>
|
|
||||||
{{if not .Poznat}}<br><span class="znak nepoznat">nepoznat uređaj</span>
|
|
||||||
<span class="mali">FW stariji od 0.13.4 — prepoznat samo po adresi {{.IzvornaIP}}</span>{{end}}</td>
|
|
||||||
<td>{{if .MAC}}{{.MAC}}{{else}}<span class="mali">—</span>{{end}}</td>
|
|
||||||
<td>{{if .IP}}{{.IP}}{{else}}{{.IzvornaIP}}{{end}}</td>
|
|
||||||
<td>{{if .FW}}{{.FW}}{{else}}<span class="mali">—</span>{{end}}</td>
|
|
||||||
<td>{{if .Tih}}<span class="znak lose">tih</span>{{else}}<span class="znak ok">javlja se</span>{{end}}</td>
|
|
||||||
<td>{{.Vidjen}}</td>
|
|
||||||
<td>{{.Heartbeat}}<br><span class="mali">interval ~{{.Interval}} s</span></td>
|
|
||||||
<td>{{.Linija}}</td>
|
|
||||||
<td class="mali">{{.Poslednja}}</td>
|
|
||||||
</tr>
|
|
||||||
{{end}}
|
|
||||||
</table>
|
|
||||||
<p class="mali">Crveno = uređaj nije poslao ništa duže od 3× svog intervala javljanja.</p>
|
|
||||||
{{else}}
|
|
||||||
<div class="prazno">Nijedan uređaj se još nije javio.<br><br>
|
|
||||||
Na uređaju: <b>Podešavanja → Servis</b> → <code>svcLogHost</code> = <code><IP servera>:{{.Port}}</code>,
|
|
||||||
uključi „Šalji dnevnik rada na server", heartbeat npr. 60 s.</div>
|
|
||||||
{{end}}
|
|
||||||
</main></body></html>`))
|
|
||||||
|
|
||||||
var tmplDevice = template.Must(template.New("device").Parse(`<!doctype html>
|
|
||||||
<html lang="sr"><head><meta charset="utf-8">
|
|
||||||
<meta name="viewport" content="width=device-width,initial-scale=1">
|
|
||||||
<title>{{.U.Naziv}} — dnevnik</title>
|
|
||||||
<style>` + cssCommon + `</style></head>
|
|
||||||
<body>
|
|
||||||
<header><h1>{{.U.Naziv}}</h1>
|
|
||||||
<span class="mali">{{if .U.MAC}}{{.U.MAC}} · {{end}}{{if .U.FW}}FW {{.U.FW}} · {{end}}{{if .U.IP}}{{.U.IP}}{{end}}</span>
|
|
||||||
<a href="/{{if .Token}}?t={{.Token}}{{end}}">← svi uređaji</a>
|
|
||||||
<span class="mali">{{.Vreme}}</span></header>
|
|
||||||
<main>
|
|
||||||
{{if .Nadjen}}
|
|
||||||
<p class="mali">
|
|
||||||
{{if .U.Tih}}<span class="znak lose">tih</span>{{else}}<span class="znak ok">javlja se</span>{{end}}
|
|
||||||
· poslednji paket {{.U.Vidjen}} · heartbeat {{.U.Heartbeat}} (interval ~{{.U.Interval}} s)
|
|
||||||
· linija dnevnika: {{.U.Linija}} · prvi put viđen {{.U.PrviPutStr}}
|
|
||||||
{{if not .U.Poznat}}<br><span class="znak nepoznat">nepoznat uređaj</span>
|
|
||||||
identifikovan samo po izvornoj adresi {{.U.IzvornaIP}} — paket nije imao zaglavlje (FW stariji od 0.13.4){{end}}
|
|
||||||
</p>
|
|
||||||
{{else}}
|
|
||||||
<p class="mali">Uređaj se nije javio od pokretanja prijemnika — prikazano je ono što je ostalo na disku.</p>
|
|
||||||
{{end}}
|
|
||||||
<form class="pretraga" method="get" action="/uredjaj">
|
|
||||||
<input type="hidden" name="k" value="{{.U.Key}}">
|
|
||||||
{{if .Token}}<input type="hidden" name="t" value="{{.Token}}">{{end}}
|
|
||||||
<input type="text" name="q" value="{{.Q}}" placeholder="pretraga po tekstu (npr. stampac)" size="40">
|
|
||||||
<select name="n">
|
|
||||||
<option value="100" {{if eq .N 100}}selected{{end}}>100 linija</option>
|
|
||||||
<option value="200" {{if eq .N 200}}selected{{end}}>200 linija</option>
|
|
||||||
<option value="500" {{if eq .N 500}}selected{{end}}>500 linija</option>
|
|
||||||
<option value="2000" {{if eq .N 2000}}selected{{end}}>2000 linija</option>
|
|
||||||
</select>
|
|
||||||
<button type="submit">Prikaži</button>
|
|
||||||
</form>
|
|
||||||
<p class="mali">Dani sa dnevnikom: {{if .Dani}}{{range .Dani}}{{.}} {{end}}{{else}}nema zapisa{{end}}
|
|
||||||
· <a href="/dnevnik.txt?k={{.U.Key}}&n={{.N}}&q={{.Q}}{{if .Token}}&t={{.Token}}{{end}}">preuzmi kao tekst</a></p>
|
|
||||||
{{if .Linije}}<pre>{{range .Linije}}{{.}}
|
|
||||||
{{end}}</pre>{{else}}<div class="prazno">Nema linija za zadate uslove.</div>{{end}}
|
|
||||||
</main></body></html>`))
|
|
||||||
Loading…
Reference in New Issue
Block a user