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

+368
View File
@@ -0,0 +1,368 @@
//go:build e2e
// The whole path a page takes, on a real OpenWrt userland: uhttpd's /ubus,
// rpcd's sessions and access lists (the package's own ACL file), ubusd and the
// backend with its own watcher and topics, over a stand's settings and tunnel.
// scripts/backend-container.sh starts the daemons and runs this.
package daemon
import (
"bufio"
"bytes"
"context"
"encoding/json"
"fmt"
"net/http"
"os"
"os/exec"
"path/filepath"
"reflect"
"strings"
"sync"
"testing"
"time"
"github.com/tickcount/luci-app-dawnline/backend/awg"
"github.com/tickcount/luci-app-dawnline/backend/hub"
"github.com/tickcount/luci-app-dawnline/backend/ubus"
)
const web = "http://127.0.0.1:8099/ubus"
// rpc is a JSON-RPC call through uhttpd, as LuCI's rpc.js makes it. It
// returns ubus's status and the answer.
func rpc(t *testing.T, sid, object, method string, args map[string]any) (int, map[string]any) {
t.Helper()
body, _ := json.Marshal(map[string]any{"jsonrpc": "2.0", "id": 1, "method": "call", "params": []any{sid, object, method, args}})
res, err := http.Post(web, "application/json", bytes.NewReader(body))
if err != nil {
t.Fatal(err)
}
defer res.Body.Close()
var out struct {
Result []json.RawMessage
Error *struct {
Code int
Message string
}
}
if err := json.NewDecoder(res.Body).Decode(&out); err != nil {
t.Fatal(err)
}
if out.Error != nil {
return out.Error.Code, nil
}
var code int
json.Unmarshal(out.Result[0], &code)
var data map[string]any
if len(out.Result) > 1 {
json.Unmarshal(out.Result[1], &data)
}
return code, data
}
func at(v any, path ...string) any {
for _, k := range path {
m, _ := v.(map[string]any)
v = m[k]
}
return v
}
// The stand's settings: one server, one person, one device.
const (
standServerKey = "yAnz5TF+lXXJte14tji3zlMNq+hd2rYUIgJBgB3fBmk="
standServerPub = "xTIBA5rboUvnH4htodjb6e697QjLERt1NAB4mZqp8Dg="
standDeviceKey = "HIgo9xNzJMWLKASShiTqIybxZ0U3wGLiUeJ1PKf8ykw="
)
func standSettings(person string) string {
return `
config settings 'settings'
config server 's1'
option name 'Home'
option ifname 'dawn0'
option subnet '10.77.0.0/24'
option private_key '` + standServerKey + `'
option public_key '` + standServerPub + `'
config person 'p1'
option server 's1'
option name '` + person + `'
config device 'd1'
option person 'p1'
option name 'Phone'
option kind 'phone'
option address '10.77.0.2'
option public_key '` + standDeviceKey + `'
`
}
// tunnel is the stand's one tunnel: its device is there, with the handshake the test gave it.
type tunnel struct {
mu sync.Mutex
handshake int64
}
func (tn *tunnel) reader() *awg.Reader {
return &awg.Reader{
// as `awg show <ifname> dump` prints: the interface's line, then a peer a line
Show: func(string) (string, bool) {
tn.mu.Lock()
defer tn.mu.Unlock()
return standServerKey + "\t" + standServerPub + "\t4500\toff\n" +
fmt.Sprintf("%s\t(none)\t203.0.113.7:41821\t10.77.0.2/32\t%d\t0\t0\toff\n", standDeviceKey, tn.handshake), true
},
Index: func(string) (int, bool) { return 7, true },
}
}
func (tn *tunnel) shake(at int64) {
tn.mu.Lock()
tn.handshake = at
tn.mu.Unlock()
}
// follow asks with wait until the documents satisfy `done`, taking the events into them, and returns the
// number the page is at and the events of the last answer. The topics are the page's whole snapshot.
func follow(t *testing.T, sid, epoch string, seq float64, docs map[string]any, topics []any, what string, done func() bool) (float64, []any) {
t.Helper()
deadline := time.Now().Add(25 * time.Second)
for {
args := map[string]any{"epoch": epoch, "seq": seq, "timeout": 10}
if topics != nil {
args["topics"] = topics
}
code, got := rpc(t, sid, "dawnline", "wait", args)
events, _ := got["events"].([]any)
if code != 0 || got["docs"] != nil || (len(events) == 0 && time.Now().After(deadline)) {
t.Fatalf("wait for %s: %d %v", what, code, got)
}
take(docs, events)
seq = got["seq"].(float64)
if done() {
return seq, events
}
}
}
// take applies events to a page's documents, as a page does.
func take(docs map[string]any, events []any) {
for _, e := range events {
topic, _ := at(e, "topic").(string)
switch at(e, "op") {
case "put":
docs[topic] = at(e, "data")
case "patch":
docs[topic] = hub.Merge(docs[topic], at(e, "data"))
}
}
}
func TestThroughUhttpd(t *testing.T) {
ctx, cancel := context.WithTimeout(context.Background(), 60*time.Second)
defer cancel()
dir := t.TempDir()
config := filepath.Join(dir, "config")
settings := func(person string) {
if err := os.WriteFile(config, []byte(standSettings(person)), 0o600); err != nil {
t.Fatal(err)
}
}
settings("Myata")
// The stand is no router to keep: the minute's work (the access rules, the watchdog) stays away, the
// watcher and the topics are the backend's own.
if err := os.WriteFile(filepath.Join(dir, "backend-off"), nil, 0o600); err != nil {
t.Fatal(err)
}
// A backend that was restarted: its earlier run left who was online, and nobody came or went since, so
// the watcher's first look finds nothing to tell of by itself.
run := filepath.Join(dir, "run")
os.MkdirAll(run, 0o755)
if err := os.WriteFile(filepath.Join(run, "presence.json"), []byte(`{"online":{"d1":false},"endpoint":{"d1":"203.0.113.7"},"rev":1,"people":{"p1":1}}`), 0o600); err != nil {
t.Fatal(err)
}
tn := &tunnel{}
began := time.Now()
// The backend is stopped, and has stopped, before the test ends: it writes into the stand's folders (its beat,
// its presence) and logs through t, and a test that ended under it failed at removing a folder still written to.
stopped := make(chan struct{})
go func() {
defer close(stopped)
Run(ctx, Options{Socket: ubus.Socket, RunDir: run, DataDir: dir, Config: config, Stream: "sse", Watch: true, Tunnels: tn.reader(), Log: t.Logf})
}()
defer func() {
cancel()
select {
case <-stopped:
case <-time.After(10 * time.Second):
t.Error("the backend did not stop")
}
}()
for exec.CommandContext(ctx, "ubus", "list", "dawnline").Run() != nil {
if ctx.Err() != nil {
t.Fatal("the object never appeared on the bus")
}
time.Sleep(20 * time.Millisecond)
}
// Without a session rpcd refuses; with one, the read ACL lets the page in.
if code, _ := rpc(t, "00000000000000000000000000000000", "dawnline", "hello", nil); code == 0 {
t.Fatal("answered without a session")
}
code, login := rpc(t, "00000000000000000000000000000000", "session", "login", map[string]any{"username": "root", "password": ""})
if code != 0 {
t.Fatalf("login: %d", code)
}
sid := login["ubus_rpc_session"].(string)
code, hello := rpc(t, sid, "dawnline", "hello", map[string]any{})
if code != 0 || hello["stream"] != "sse" || hello["epoch"] == "" {
t.Fatalf("hello: %d %v", code, hello)
}
// A page that was open while the backend restarted asks at once, before the watcher's first look: its
// first question starts the bridge, and the documents come with the bridge's next second. (They once
// came only with the next Refresh, half a minute later: the bridge took topics nobody could make yet
// for told.)
asked := time.Now()
code, snap := rpc(t, sid, "dawnline", "sync", map[string]any{})
if code != 0 {
t.Fatalf("sync: %d", code)
}
epoch, seq := snap["epoch"].(string), snap["seq"].(float64)
docs, _ := snap["docs"].(map[string]any)
if docs == nil {
docs = map[string]any{}
}
whole := func() bool {
return at(docs, "people", "items", "p1", "name") == "Myata" && at(docs, "servers", "items", "s1") != nil && at(docs, "backend", "ok") == true
}
if !whole() {
seq, _ = follow(t, sid, epoch, seq, docs, nil, "the first documents", whole)
}
took := time.Since(asked)
t.Logf("the page asked %v after the backend started and had its first documents %v later", asked.Sub(began).Round(time.Millisecond), took.Round(time.Millisecond))
if took > 3*time.Second {
t.Fatalf("the first documents took %v", took)
}
if at(docs, "people", "items", "p1", "devices", "items", "d1", "online") != false || at(docs, "servers", "order").([]any)[0] != "s1" {
t.Fatalf("documents: %v", docs)
}
// An event stream, as a page opens it; on a web server that cannot hold one this part is skipped.
stream, lines := openStream(t, ctx, sid)
// A device comes online: the long poll returns with a patch that says so, and not the people whole.
online := func() bool { return at(docs, "people", "items", "p1", "devices", "items", "d1", "online") == true }
type result struct {
seq float64
events []any
}
waited := make(chan result, 1)
go func() {
s, events := follow(t, sid, epoch, seq, docs, []any{"people"}, "the device to come online", online)
waited <- result{s, events}
}()
time.Sleep(300 * time.Millisecond)
changed := time.Now()
tn.shake(time.Now().Unix())
var r result
select {
case r = <-waited:
case <-time.After(40 * time.Second):
t.Fatal("the device never came online for the page")
}
var patch any
for _, e := range r.events {
if at(e, "op") == "patch" && at(e, "data", "items", "p1", "devices", "items", "d1", "online") == true {
patch = e
}
}
if patch == nil || at(patch, "data", "items", "p1", "name") != nil || at(patch, "data", "order") != nil {
t.Fatalf("patch: %v", r.events)
}
t.Logf("a device that came online reached the page %v later, as %d bytes", time.Since(changed).Round(time.Millisecond), len(fmt.Sprint(at(patch, "data"))))
if stream {
// The same event came down the stream, with the same number.
deadline := time.After(10 * time.Second)
for found := false; !found; {
select {
case l := <-lines:
var e map[string]any
if strings.HasPrefix(l, "data: ") && json.Unmarshal([]byte(l[6:]), &e) == nil && e["seq"] == at(patch, "seq") {
if e["topic"] != "people" || e["op"] != "patch" || e["epoch"] != epoch || !reflect.DeepEqual(e["data"], at(patch, "data")) {
t.Fatalf("the stream's event differs: %v", e)
}
found = true
}
case <-deadline:
t.Fatal("the event never came down the stream")
}
}
}
// The meter's points come as they are made, to a page that names it.
if code, _ := rpc(t, sid, "dawnline", "watch", map[string]any{"topics": []any{"meter"}}); code != 0 {
t.Fatalf("watch: %d", code)
}
code, got := rpc(t, sid, "dawnline", "wait", map[string]any{"epoch": epoch, "seq": r.seq, "topics": []any{"meter"}, "timeout": 10})
events, _ := got["events"].([]any)
appended := false
for _, e := range events {
appended = appended || at(e, "op") == "append"
}
if code != 0 || !appended {
t.Fatalf("meter: %d %v", code, got)
}
// A page reads its own edit: once refresh answers, the stream holds what is on disk, with no waiting
// for the watcher's second.
settings("Mint")
code, stands := rpc(t, sid, "dawnline", "refresh", map[string]any{})
if code != 0 || stands["epoch"] != epoch {
t.Fatalf("refresh: %d %v", code, stands)
}
code, got = rpc(t, sid, "dawnline", "sync", map[string]any{"epoch": epoch, "seq": r.seq, "topics": []any{"people"}})
events, _ = got["events"].([]any)
take(docs, events)
if code != 0 || at(docs, "people", "items", "p1", "name") != "Mint" || got["seq"].(float64) < stands["seq"].(float64) {
t.Fatalf("after refresh: %d %v (the stream stands at %v)", code, got, stands["seq"])
}
// Arguments are checked at the door.
if code, _ := rpc(t, sid, "dawnline", "sync", map[string]any{"seq": -1}); code != int(ubus.StatusInvalidArgument) {
t.Fatalf("a negative number was accepted: %d", code)
}
if code, _ := rpc(t, sid, "dawnline", "sync", map[string]any{"topics": "people"}); code != int(ubus.StatusInvalidArgument) {
t.Fatalf("topics that are no list were accepted: %d", code)
}
}
// openStream subscribes through uhttpd and returns the stream's lines.
func openStream(t *testing.T, ctx context.Context, sid string) (bool, <-chan string) {
req, _ := http.NewRequestWithContext(ctx, "GET", web+"/subscribe/dawnline", nil)
req.Header.Set("Authorization", "Bearer "+sid)
res, err := http.DefaultClient.Do(req)
if err != nil {
t.Fatal(err)
}
if ct := res.Header.Get("Content-Type"); !strings.HasPrefix(ct, "text/event-stream") {
t.Logf("no event stream from this web server (%s): %s", res.Status, ct)
res.Body.Close()
return false, nil
}
lines := make(chan string, 64)
go func() {
defer res.Body.Close()
sc := bufio.NewScanner(res.Body)
sc.Buffer(make([]byte, 0, 64<<10), 2<<20)
for sc.Scan() {
select {
case lines <- sc.Text():
default:
}
}
}()
return true, lines
}