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

+121
View File
@@ -0,0 +1,121 @@
// Package meter is the live meter: each server's throughput and that of each device moving traffic, one
// point a second over the last two minutes (dawnline.meter in Go, rule for rule).
//
// A point is made from two looks at the tunnels that are about a second apart. Bytes are the peers'
// counters: what was sent includes the disguise (prefixes, padding, junk), what was received is the
// packets without their prefix, so both are close to what is on the wire.
//
// Pure: looks in, points out. Who looks every second, and for whom, is the producer's.
package meter
import (
"github.com/tickcount/luci-app-dawnline/backend/awg"
"github.com/tickcount/luci-app-dawnline/backend/model"
)
// Points is how many are kept: two minutes, one a second.
const Points = 120
// Sample is one look, as the meter needs it.
type Sample struct {
// Mono is a clock that only goes forward, in seconds with their fraction: the gap between two samples.
Mono float64
// TS is the router's clock (unix seconds): the point's name.
TS int64
// Servers are those whose tunnel was read.
Servers []string
// Dev is each device's counters on such a server.
Dev map[string]Counters
}
// Counters are a device's bytes since its tunnel last added it, and the server it is on.
type Counters struct {
Rx, Tx int64
Server string
}
// Point is one second: bytes a second of each server's devices together (rx what came from them, tx what
// went to them), for every server whose tunnel was read, and of each device that moved something (one left
// out moved nothing).
type Point struct {
TS int64 `json:"ts"`
Servers map[string][2]int64 `json:"servers"`
Dev map[string][2]int64 `json:"dev"`
}
// Take makes a sample of a look at the tunnels.
func Take(m *model.Model, d awg.Dump, mono float64, now int64) Sample {
s := Sample{Mono: mono, TS: now, Servers: []string{}, Dev: map[string]Counters{}}
read := map[string]bool{}
for _, id := range m.ServerIDs() {
if d.Reads[m.Servers[id].Ifname] == awg.Read {
read[id] = true
s.Servers = append(s.Servers, id)
}
}
for _, id := range m.DeviceIDs() {
dev := m.Devices[id]
p := m.People[dev.Person]
if p == nil || !read[p.Server] {
continue
}
if peer, there := d.Peers[dev.PublicKey]; there {
s.Dev[id] = Counters{Rx: peer.Rx, Tx: peer.Tx, Server: p.Server}
}
}
return s
}
// delta is a counter's change, 0 when it went down (a tunnel set up again starts from zero).
func delta(a, b int64) int64 {
if b >= a {
return b - a
}
return 0
}
// Between is the point between two samples; ok is false when they are not a second or so apart (the first
// sample, a stalled watcher). A device is counted from its second sample on, on the server it was on in both.
func Between(a, b Sample) (Point, bool) {
dt := b.Mono - a.Mono
if !(dt > 0.2 && dt < 5) {
return Point{}, false
}
sum := map[string][2]int64{}
for _, sid := range b.Servers {
sum[sid] = [2]int64{}
}
p := Point{TS: b.TS, Servers: map[string][2]int64{}, Dev: map[string][2]int64{}}
for id, v := range b.Dev {
o, had := a.Dev[id]
if !had || o.Server != v.Server {
continue
}
rx, tx := delta(o.Rx, v.Rx), delta(o.Tx, v.Tx)
t := sum[v.Server]
sum[v.Server] = [2]int64{t[0] + rx, t[1] + tx}
if rx != 0 || tx != 0 {
p.Dev[id] = [2]int64{int64(float64(rx) / dt), int64(float64(tx) / dt)}
}
}
for sid, v := range sum {
p.Servers[sid] = [2]int64{int64(float64(v[0]) / dt), int64(float64(v[1]) / dt)}
}
return p, true
}
// Keep adds a point to the ring (newest last) and returns it: at most Points of them, none older than
// Points seconds before the new one (the watcher may have stalled in between) and none from its second or
// later (the clock went back). `cut` tells that points were taken from the ring's end, so whoever shows the
// ring must show it anew, not only add the new point.
func Keep(ring []Point, p Point) (out []Point, cut bool) {
for len(ring) > 0 && ring[len(ring)-1].TS >= p.TS {
ring = ring[:len(ring)-1]
cut = true
}
ring = append(ring, p)
for len(ring) > Points || ring[0].TS <= p.TS-Points {
ring = ring[1:]
}
return ring, cut
}
+97
View File
@@ -0,0 +1,97 @@
package meter
import (
"reflect"
"testing"
"github.com/tickcount/luci-app-dawnline/backend/awg"
"github.com/tickcount/luci-app-dawnline/backend/model"
"github.com/tickcount/luci-app-dawnline/backend/uci"
)
const (
keyA = "HIgo9xNzJMWLKASShiTqIybxZ0U3wGLiUeJ1PKf8ykw="
keyB = "TrMvSoP4jYQlY6RIzBgbssQqY3vxI2Pi+y71lOWWXX0="
)
func settings(t *testing.T) *model.Model {
c, err := uci.Parse(`
config server 'home'
option ifname 'dawn0'
config server 'cabin'
option ifname 'dawn1'
config person 'anna'
option server 'home'
config person 'boris'
option server 'cabin'
config device 'a'
option person 'anna'
option public_key '` + keyA + `'
config device 'b'
option person 'boris'
option public_key '` + keyB + `'
`)
if err != nil {
t.Fatal(err)
}
return model.Load(c, nil)
}
func dump(reads map[string]string, peers map[string]awg.Peer) awg.Dump {
return awg.Dump{OK: true, Reads: reads, Peers: peers}
}
func TestPoint(t *testing.T) {
m := settings(t)
both := map[string]string{"dawn0": awg.Read, "dawn1": awg.Read}
a := Take(m, dump(both, map[string]awg.Peer{keyA: {Rx: 1000, Tx: 5000}, keyB: {Rx: 10, Tx: 10}}), 100.0, 1000)
b := Take(m, dump(both, map[string]awg.Peer{keyA: {Rx: 3000, Tx: 9000}, keyB: {Rx: 10, Tx: 10}}), 102.0, 1002)
p, ok := Between(a, b)
want := Point{TS: 1002, Servers: map[string][2]int64{"home": {1000, 2000}, "cabin": {0, 0}}, Dev: map[string][2]int64{"a": {1000, 2000}}}
if !ok || !reflect.DeepEqual(p, want) {
t.Fatalf("point: %+v %v", p, ok)
}
// a tunnel that could not be read is not in the point at all; its device neither
c := Take(m, dump(map[string]string{"dawn0": awg.Read, "dawn1": awg.Failed}, map[string]awg.Peer{keyA: {Rx: 3000, Tx: 9000}, keyB: {Rx: 99, Tx: 99}}), 103.0, 1003)
p, _ = Between(b, c)
if _, has := p.Servers["cabin"]; has || len(p.Dev) != 0 || p.Servers["home"] != [2]int64{0, 0} {
t.Fatalf("an unread tunnel: %+v", p)
}
// counters that went down (the tunnel set up again) count as nothing, not as a negative speed
d := Take(m, dump(both, map[string]awg.Peer{keyA: {Rx: 5, Tx: 5}}), 104.0, 1004)
if p, _ := Between(c, d); p.Servers["home"] != [2]int64{0, 0} {
t.Fatalf("a reset counter: %+v", p)
}
}
func TestNoPointAcrossAGap(t *testing.T) {
m := settings(t)
one := map[string]string{"dawn0": awg.Read}
a := Take(m, dump(one, nil), 100, 1000)
for _, mono := range []float64{100.1, 106} {
if _, ok := Between(a, Take(m, dump(one, nil), mono, 1001)); ok {
t.Errorf("a point over %.1f s", mono-100)
}
}
}
func TestKeep(t *testing.T) {
var ring []Point
for ts := int64(1); ts <= 130; ts++ {
ring, _ = Keep(ring, Point{TS: ts})
}
if len(ring) != Points || ring[0].TS != 11 || ring[len(ring)-1].TS != 130 {
t.Fatalf("ring: %d points, %d to %d", len(ring), ring[0].TS, ring[len(ring)-1].TS)
}
// the watcher stalled: what is older than two minutes before the new point goes
ring, cut := Keep(ring, Point{TS: 300})
if len(ring) != 1 || cut {
t.Fatalf("after a stall: %d points, cut %v", len(ring), cut)
}
// the clock went back: points from that second or later go, and whoever shows the ring is told
ring, _ = Keep(ring, Point{TS: 301})
ring, cut = Keep(ring, Point{TS: 300})
if len(ring) != 1 || ring[0].TS != 300 || !cut {
t.Fatalf("after the clock went back: %+v, cut %v", ring, cut)
}
}