Dawnline 0.20.0
Build packages / CI (push) Blocked by required conditions
Build packages / Version (push) Waiting to run
CI / Web (format, types, tests, bundles) (push) Blocked by required conditions
CI / ShellCheck (push) Blocked by required conditions
CI / Backend (Go: vet, tests, a real ubusd and uhttpd) (push) Blocked by required conditions
CI / Package files (push) Blocked by required conditions

- **Backend rewritten in Go.** One daemon, `dawnlined`, replaces the whole ucode backend: the rpcd plugin, the agent, the CLI and the updater. The package no longer depends on ucode.
- **Per-architecture builds.** The release carries the backend for arm64, ARMv7, mips, mipsle and amd64; the router fetches its own after the package is installed and checks its sha256. Dawnline does not run on other architectures (older ARM, 32-bit x86, RISC-V).
- **Faster on the router.** A firewall sync takes 0.06 s instead of 0.9 s; a full apply takes about 300 ms. The portal is served by the daemon itself, without a CGI process per request.
- **Live pages.** The admin and the portal follow a live stream from the router instead of re-fetching the whole state every 30 seconds.
- **Admin redesigned in the portal's style.** Three sections (Overview · Log · Settings); a server is a page of its own with People, Places and Settings; a device opens as a dialog over its person.
- **Changes wait for «Apply».** Every setting, and a person's access, is staged in one dock before it reaches the router.
- **Configuration rollout.** After a change that makes devices fetch their configuration again, the admin shows how many have fetched it and who has not. Every setting shows beforehand (⟳N) how many devices it will touch.
- **Waiting for a decision.** Overview and People put first the people who need one (access ended, limit reached, a device that does not connect), each with its one action a tap away.
- **Bulk actions on people.** «Select» (or a long press on a card) picks several people to extend by a month, pause or resume at once.
- **Undo.** An action done from a card or a request is undone from its toast.
- **Update dialogs redesigned.** An update is one view from its question to its result; Dawnline's own update runs in it like every other, and the page reloads itself once the new version answers. Other versions are a list, each with its notes and Install on a page of its own.
- **Site to site: networks behind a router.** A router connected as a device can have networks behind it (up to eight, /16 to /30): the server routes them and applies the router's access to them. A network that shares addresses with a tunnel, the router's own networks or another site is refused by name.
- **Routers from the portal.** People can add a router and name its networks on their own page; the admin accepts or declines with a reason, or lets them through without asking.
- **Check access and Health know the networks behind routers.**
- **Usage limits reworked.** A monthly limit no longer follows the calendar. A person's month starts with their first traffic and ends a month later; the next one starts only when they connect again, so time away uses up none of it. Before, everyone's limit reset on the 1st.
- Extra data lasts until that person's month ends; «Reset usage» starts the month anew.
- A limit is for a month or for the whole term; the admin and the portal show when it resets.
- Charts that said «this month» show the last 30 days.
- After the update nobody loses what was counted: the month that was running becomes the person's first and ends on the 1st.
- **Access by time of day removed.** The Hours limit is gone from the admin, the portal and the backend; saved hours are dropped.
- **Expiry simplified.** An end date always stops access, with a heads-up three days before; the per-person choice is gone.
- **No false disconnects from sleeping phones.** A phone or a tablet stays online through ten minutes of silence.
- **Mobile Safari fixes.** Pressing a control no longer sends the page to its top; tab tracks that do not fit scroll; switches animate after a press.
This commit is contained in:
Aemeath committed 2026-11-13 09:43:50 +03:00
1 parent f8130e39a8
commit ac90575b0b
788 files changed
+139244 -41720

No files matched your search

+140
View File
@@ -0,0 +1,140 @@
package journal
import (
"encoding/json"
"os"
"reflect"
"testing"
"github.com/tickcount/luci-app-dawnline/backend/model"
)
func read(t *testing.T, path string) []Event {
var ev []Event
raw, err := os.ReadFile(path)
if err != nil {
t.Fatal(err)
}
if err := json.Unmarshal(raw, &ev); err != nil {
t.Fatal(err)
}
return ev
}
func names(person, device string) (string, string, string) {
return map[string]string{"anna": "Anna"}[person], map[string]string{"d1": "Phone"}[device], map[string]string{"d1": "phone"}[device]
}
func TestPolicy(t *testing.T) {
for name, c := range map[string]struct {
r model.Retention
want Policy
}{
"nothing set": {model.Retention{}, Policy{30, 2000, Categories, "hourly"}},
"connections off": {model.Retention{LogConnections: "0"}, Policy{30, 2000, []string{"people", "problems"}, "hourly"}},
"a list": {model.Retention{LogCategory: []string{"problems", "devices", "people", "nonsense"}, LogKeepDays: "0", LogMax: "100", LogPersist: "off"}, Policy{0, 100, []string{"problems", "people"}, "off"}},
"one string": {model.Retention{LogCategory: "connections, problems"}, Policy{30, 2000, []string{"connections", "problems"}, "hourly"}},
"out of range, a typo": {model.Retention{LogKeepDays: "99999", LogMax: "50", LogPersist: "daily"}, Policy{30, 2000, Categories, "hourly"}},
} {
if got := PolicyOf(c.r); !reflect.DeepEqual(got, c.want) {
t.Errorf("%s: %+v, want %+v", name, got, c.want)
}
}
}
func TestAddNamesTrimsAndFilters(t *testing.T) {
dir := t.TempDir()
l := Log{Run: dir, Data: dir + "/flash"}
pol := Policy{KeepDays: 1, Max: 3, Categories: []string{"connections"}, Persist: "hourly"}
now := int64(1_000_000)
// what flash holds is the log until the first write
os.MkdirAll(l.Data, 0o700)
os.WriteFile(l.flash(), []byte(`[{"ts":1,"type":"connect","future":"kept as it is"},{"ts":999990,"type":"connect","person":"old"}]`), 0o600)
if err := l.Add([]Event{
{"type": "connect", "person": "anna", "device": "d1", "detail": "203.0.113.7"},
{"type": "paused", "person": "anna"},
{"type": "disconnect", "person": "gone", "device": "d9", "ts": float64(999999)},
}, pol, names, now); err != nil {
t.Fatal(err)
}
got := read(t, l.live())
want := []Event{
{"ts": float64(999990), "type": "connect", "person": "old"},
{"ts": float64(now), "type": "connect", "person": "anna", "device": "d1", "detail": "203.0.113.7", "pname": "Anna", "dname": "Phone", "dkind": "phone"},
{"ts": float64(999999), "type": "disconnect", "person": "gone", "device": "d9"},
}
if !reflect.DeepEqual(got, want) {
t.Fatalf("log: %v", got)
}
if st, _ := os.Stat(l.live()); st.Mode().Perm() != 0o600 {
t.Errorf("mode %v", st.Mode().Perm())
}
for i := 0; i < 5; i++ {
l.Add([]Event{{"type": "roam", "person": "anna", "device": "d1"}}, pol, names, now+int64(i))
}
if got := read(t, l.live()); len(got) != 3 || got[0]["type"] != "roam" {
t.Fatalf("not cut to the newest three: %v", got)
}
// nothing recorded: nothing written
before, _ := os.Stat(l.live())
l.Add([]Event{{"type": "paused"}}, pol, names, now+10)
if after, _ := os.Stat(l.live()); !after.ModTime().Equal(before.ModTime()) {
t.Error("written for an event that is not recorded")
}
}
func TestAddMerged(t *testing.T) {
dir := t.TempDir()
l := Log{Run: dir, Data: dir}
pol := Policy{Max: 100, Categories: Categories}
e := func(detail string) Event {
return Event{"type": "device_failing", "person": "anna", "device": "d1", "detail": detail}
}
l.AddMerged(e("trying"), 3600, pol, names, 1000)
l.AddMerged(e("dropped"), 3600, pol, names, 1500)
l.AddMerged(e("trying"), 3600, pol, names, 2000)
got := read(t, l.live())
if len(got) != 1 || got[0]["detail"] != "trying, dropped" || got[0]["ts"] != float64(2000) || got[0]["pname"] != "Anna" {
t.Fatalf("merged: %v", got)
}
// past the window, or about another device: a line of its own
l.AddMerged(e("unstable"), 3600, pol, names, 2000+3600)
l.AddMerged(Event{"type": "device_failing", "person": "anna", "device": "d2", "detail": "trying"}, 3600, pol, names, 2000+3601)
if got := read(t, l.live()); len(got) != 3 {
t.Fatalf("not merged: %v", got)
}
}
func TestPersist(t *testing.T) {
dir := t.TempDir()
l := Log{Run: dir, Data: dir + "/flash"}
pol := Policy{Max: 100, Categories: Categories, Persist: "hourly"}
l.Add([]Event{{"type": "connect"}}, pol, names, 1000)
if err := l.Persist(pol, 1000); err != nil {
t.Fatal(err)
}
if got := read(t, l.flash()); len(got) != 1 {
t.Fatalf("flash: %v", got)
}
pol.Persist = "off"
l.Persist(pol, 1000)
if _, err := os.Stat(l.flash()); err == nil {
t.Error("the flash copy stays though the log is kept in memory only")
}
}
func TestAnEventInSyslog(t *testing.T) {
for line, e := range map[string]Event{
"info Anna paused (admin)": {"type": "paused", "person": "anna", "pname": "Anna", "by": "admin"},
"info Anna · Phone device changed · kind=phone (portal)": {"type": "device_changed", "person": "anna", "pname": "Anna", "device": "phone", "dname": "Phone", "detail": "kind=phone", "by": "portal"},
"warn portal blocked · 203.0.113.7": {"type": "portal_blocked", "detail": "203.0.113.7"},
"info server up": {"type": "server_up"},
"warn bob unheard of": {"type": "unheard_of", "person": "bob"},
" Anna connect": {"type": "connect", "pname": "Anna"},
" Anna · Phone device failing": {"type": "device_failing", "pname": "Anna", "dname": "Phone"},
} {
if got := Level(e) + " " + Line(e); got != line {
t.Errorf("%q, want %q", got, line)
}
}
}