Compare commits
1
Commits
next
..
6f3fbf027a
| Author | SHA1 | Date | |
|---|---|---|---|
 clawbot
|
6f3fbf027a |
@@ -10,80 +10,31 @@
|
||||
|
||||
# Status
|
||||
|
||||
RouteWatch is pre-1.0, with no git tags. `main` last took `next` on 2026-10-27,
|
||||
through https://git.eeqj.de/sneak/routewatch/pulls/166.
|
||||
https://git.eeqj.de/sneak/routewatch/pulls/202 carries the commits since then
|
||||
into `main`. It is labelled `merge-ready` and waits for sneak.
|
||||
|
||||
The linter and the tests are phases of the Docker build. The Gitea workflow runs
|
||||
`script/cibuild` on every push. That script runs the two phases and checks the
|
||||
formatting of the Go code and the markdown. Then it builds the image.
|
||||
|
||||
The image sets memory ceilings for a 5 GiB container (README "Memory"). README
|
||||
"Running under upaas" says how to run it.
|
||||
|
||||
A five-day run of `1c65656` on the live feed, from 2026-10-27 to 2026-11-01,
|
||||
found three problems:
|
||||
|
||||
- The prefix handler dropped updates while a peer's session went down
|
||||
(https://git.eeqj.de/sneak/routewatch/issues/216).
|
||||
- The AS handler dropped updates when the feed burst
|
||||
(https://git.eeqj.de/sneak/routewatch/issues/217).
|
||||
- The WHOIS fetcher kept asking a registry that had refused it
|
||||
(https://git.eeqj.de/sneak/routewatch/issues/218).
|
||||
|
||||
All three are fixed on `next`. So is
|
||||
https://git.eeqj.de/sneak/routewatch/issues/222, which the third fix brought up.
|
||||
A run of `26d939a` on the live feed showed the prefix handler still dropping
|
||||
updates while the home page's cards were worked out.
|
||||
https://git.eeqj.de/sneak/routewatch/issues/226 fixed that on `next`.
|
||||
https://git.eeqj.de/sneak/routewatch/issues/225, also on `next`, takes the peers
|
||||
whose sessions go down together out of the table in one walk. A 24-hour run of
|
||||
`9bd0e91` on the live feed is checking whether any handler still drops updates.
|
||||
|
||||
One question waits for sneak: which fields the IP lookup answer gains
|
||||
(https://git.eeqj.de/sneak/routewatch/issues/203).
|
||||
|
||||
The order of the project's remaining work is kept on
|
||||
https://git.eeqj.de/sneak/routewatch/issues/86.
|
||||
pre-1.0. No git tags. `main` last took `next` on 2026-10-06, through
|
||||
https://git.eeqj.de/sneak/routewatch/pulls/6. The linter and the tests are
|
||||
phases of the Docker build, and the Gitea workflow runs `script/cibuild` (the
|
||||
format check of the Go code and the markdown, both phases, then the image) on
|
||||
every push. The image sets memory ceilings for a 5 GiB container (README
|
||||
"Memory") and the README says how to run it under upaas (README "Running under
|
||||
upaas"). A 25-hour run of `a9b6860` on the live feed peaked at about 0.6 GiB
|
||||
(https://git.eeqj.de/sneak/routewatch/issues/3). A run of `825afa2` on the live
|
||||
feed found the prefix handler dropping about a quarter of its updates because
|
||||
its route writes were slower than the feed
|
||||
(https://git.eeqj.de/sneak/routewatch/issues/96); the cheaper writes since then
|
||||
are measured by a benchmark, not yet on the live feed.
|
||||
|
||||
# Next Step
|
||||
|
||||
Post the outcome of the 24-hour run of `9bd0e91` on
|
||||
https://git.eeqj.de/sneak/routewatch/issues/226: whether any handler still drops
|
||||
updates, and the process's peak memory against 5 GiB. File an issue for each
|
||||
problem the run finds.
|
||||
Run `next` on the live feed, as README "Running under upaas" describes, until
|
||||
the routing table stops growing. Post its size and memory figures on
|
||||
https://git.eeqj.de/sneak/routewatch/issues/122. The same run makes the final
|
||||
check https://git.eeqj.de/sneak/routewatch/issues/96 names: whether the prefix
|
||||
handler still drops updates after the first hour. If it does, a new issue
|
||||
follows with the numbers. Then an audit of the code at the commit that run
|
||||
tested.
|
||||
|
||||
# Completed Steps
|
||||
|
||||
- 2026-11-05: the prefix page lists the prefix's origin changes, newest first.
|
||||
The routing table records each change, and the prefix handler writes them to a
|
||||
new `origin_changes` table. The database maintainer prunes each prefix to its
|
||||
newest 500 rows or its rows from the last 72 hours, whichever keeps more. The
|
||||
page shows at most the newest 5,000. Each row shows:
|
||||
- the time
|
||||
- announced or withdrawn
|
||||
- the origin AS
|
||||
- the peer count
|
||||
|
||||
A row's peer count is how many peers carry the prefix just after the change,
|
||||
with any origin AS (closes #161).
|
||||
|
||||
- 2026-11-03: the streamer drops an update for a handler only when that
|
||||
handler's queue is full. It used to drop a random share of the updates once
|
||||
the queue was half full. The prefix handler's queue now holds 100,000
|
||||
messages, about 100 MiB. It used to hold 20,000. While the routing table's
|
||||
`Overview` walks every prefix, the prefix handler applies updates more slowly.
|
||||
In a run on the live feed, the feed paused during such a walk and then sent
|
||||
its backlog. The streamer then dropped about 10,000 of the prefix handler's
|
||||
updates (closes #229)
|
||||
- 2026-11-02: `README.md` is rewritten from scratch, sentence by sentence,
|
||||
against the rules of https://git.eeqj.de/sneak/routewatch/issues/157. Every
|
||||
statement was checked against the code on `next` (closes #157)
|
||||
- 2026-11-02: `TODO.md` is rewritten from scratch, sentence by sentence, against
|
||||
the rules of https://git.eeqj.de/sneak/routewatch/issues/157. Every Completed
|
||||
Steps entry keeps its date, its facts and its issue. Status and Next Step
|
||||
describe the repo as the tracker shows it (part of #157)
|
||||
- 2026-11-02: when the sessions of several peers go down, the prefix handler
|
||||
takes the peers out of the routing table together. The table's `PeersDown`
|
||||
takes several peers out of every prefix in one walk. One walk runs at a time.
|
||||
@@ -98,155 +49,146 @@ problem the run finds.
|
||||
does. It used to take the lock back at once. The prefix handler then applied
|
||||
about one update per 10,000 prefixes walked. During a walk, its queue could
|
||||
fill, and the streamer then dropped updates for it (closes #226)
|
||||
- 2026-11-02: A skipped WHOIS lookup now makes the fetcher wait longer before
|
||||
the next one, as a failed lookup does. A lookup is skipped when its RIR is
|
||||
paused. An RIR is one of the five regional Internet registries. The longest
|
||||
wait is one minute. The status page does not count a skip as a failure. A skip
|
||||
used to leave the wait as it was. Each lookup asks IANA which RIR holds the AS
|
||||
before it finds that RIR paused. So while most stale ASes belonged to a paused
|
||||
RIR, the fetcher could ask IANA every second (closes #222)
|
||||
- 2026-11-02: A peer's session going down no longer stops the prefix handler.
|
||||
The handler runs the routing table's `PeerDown` on a goroutine of its own, one
|
||||
peer at a time. Meanwhile it goes on taking messages. `PeerDown` holds the
|
||||
table's lock for 10,000 prefixes at a time, then lets the lock go for as long
|
||||
again. The handler holds back the down peer's later messages until that peer's
|
||||
`PeerDown` returns. Then the handler applies them in order, one at a time, and
|
||||
takes new messages in between. It holds back at most 20,000 messages. At that
|
||||
number, `HandleMessage` waits until one of them is applied. When `Stop` runs
|
||||
past its deadline, it logs how many held-back messages were not applied
|
||||
(closes #216)
|
||||
- 2026-11-02: like a failed WHOIS lookup, a lookup skipped because its RIR is
|
||||
paused makes the fetcher wait longer before the next lookup. The longest wait
|
||||
is one minute. The status page does not count a skip as a failure. A skip used
|
||||
to leave the wait as it was. Each lookup asks IANA before it finds its RIR
|
||||
paused. So while most stale ASes belonged to a paused RIR, the fetcher could
|
||||
ask IANA every second (closes #222)
|
||||
- 2026-11-02: a peer's session going down no longer stops the prefix handler.
|
||||
The handler runs the table's `PeerDown` on a separate goroutine, one peer at a
|
||||
time, and goes on taking messages. `PeerDown` holds the table's lock for
|
||||
10,000 prefixes at a time, then lets the lock go for as long again. The
|
||||
handler holds back the down peer's later messages until that peer's `PeerDown`
|
||||
returns. Then the handler applies them in order, one at a time, and takes new
|
||||
messages in between. It holds back at most 20,000 messages. At that number,
|
||||
`HandleMessage` waits until one of them is applied. When `Stop` runs past its
|
||||
deadline, it logs how many held-back messages were not applied (closes #216)
|
||||
- 2026-11-02: RouteWatch pauses an RIR's or NIC.br's WHOIS server for an hour
|
||||
after the server refuses a query. NIC.br is Brazil's registry. A refused or
|
||||
reset connection is a refusal. So is an answer with an `%ERROR:201:` or
|
||||
`%ERROR:202:` line. Lookups at the other servers go on. An AS whose RIR is
|
||||
paused is looked up after the pause. While NIC.br is paused, a Brazilian AS
|
||||
gets the details from LACNIC's answer. IANA is never paused, because a pause
|
||||
of IANA would stop every lookup. A refusal by IANA is an ordinary failure.
|
||||
NIC.br is also paused for an hour after it says RouteWatch has passed its
|
||||
query limit. Before, the fetcher asked a server again within seconds of a
|
||||
refusal (closes #218)
|
||||
- 2026-11-02: The AS handler never waits for a database write. Its batch holds
|
||||
after the server refuses a query. A refused or reset connection is a refusal.
|
||||
So is an answer with an `%ERROR:201:` or `%ERROR:202:` line. Lookups at the
|
||||
other servers go on. An AS whose RIR is paused is looked up after the pause.
|
||||
IANA is never paused, because a pause of IANA would stop every lookup. A
|
||||
refusal by IANA is an ordinary failure. NIC.br is also paused for an hour
|
||||
after it says RouteWatch has passed NIC.br's query limit. Before, the fetcher
|
||||
asked a server again within seconds of a refusal (closes #218)
|
||||
- 2026-11-02: the AS handler never waits for a database write. Its batch holds
|
||||
one entry per AS, with the earliest and the latest time of its updates. So the
|
||||
batch no longer grows with the feed's rate. It used to hold one entry for each
|
||||
AS of each path. At 300,000 entries it waited for the write in progress. In a
|
||||
burst of the feed its queue then filled, and the streamer dropped messages for
|
||||
it (closes #217)
|
||||
- 2026-10-27: The tests of `internal/routewatch` no longer fail on a loaded
|
||||
AS of each path and to wait once it held 300,000. In a burst of the feed its
|
||||
queue then filled, and the streamer dropped messages for it (closes #217)
|
||||
- 2026-10-27: the tests of `internal/routewatch` no longer fail on a loaded
|
||||
host. Five of them gave `HandleMessage` two seconds to apply a full prefix
|
||||
batch. Under the race detector that can take longer. A test now waits up to 15
|
||||
seconds for each step it expects. The tests of the handlers' limits now give
|
||||
the handlers small limits. So the package no longer runs past its 90-second
|
||||
batch, which under the race detector can take longer. A test now waits up to
|
||||
15 seconds for each step it expects. The tests of the handlers' limits give
|
||||
the handlers small ones, so the package no longer runs past its 90-second
|
||||
limit (closes #213, #215)
|
||||
- 2026-10-27: The server works out the home page's cards every minute until it
|
||||
stops. It used to work them out only once, at startup. The end of the context
|
||||
given to `Start` stopped the refreshes (closes #211)
|
||||
- 2026-10-27: README "Rationale" says why RouteWatch exists. RouteWatch answers
|
||||
our other services' questions about IP addresses, from its own routing table
|
||||
and the WHOIS details it keeps. The section still says what RIS Live does not
|
||||
give (closes #204)
|
||||
- 2026-10-27: Every JSON answer carries `@meta`. A panic on a JSON route answers
|
||||
- 2026-10-27: the server works out the home page's cards every minute until it
|
||||
stops. It used to work them out only once, at startup: the end of the context
|
||||
that `Start` is given stopped the refreshes (closes #211)
|
||||
- 2026-10-27: README "Rationale" says why RouteWatch exists: to answer our other
|
||||
services' questions about IP addresses, from its own routing table and the
|
||||
WHOIS details it keeps. It still says what RIS Live does not give (closes
|
||||
#204)
|
||||
- 2026-10-27: every JSON answer carries `@meta`. A panic on a JSON route answers
|
||||
500 with the JSON error body. `/status.json` and the health check answer 405
|
||||
with the JSON error body to any method they do not take. The 500 and the 405
|
||||
used to have an empty body. The home page's IP lookup shows the whole JSON
|
||||
answer, `@meta` included. It used to show only the answer's `data`, or only
|
||||
the message of an error answer. A test checks `@meta` on every JSON route, in
|
||||
its successes and its errors (closes #201)
|
||||
- 2026-10-27: Every value with a unit in a JSON answer is a number. The unit is
|
||||
at the end of the field name. `@meta.execution_time` is now
|
||||
`execution_time_ms`. In the stats, `uptime` is now `uptime_seconds`,
|
||||
`connection_duration` is now `connection_duration_seconds`, and `memory_usage`
|
||||
is now `memory_usage_bytes`. `whois_stats.current_interval` is now
|
||||
`whois_stats.current_interval_seconds`. They used to be strings such as "12
|
||||
ms", "1h18m34s" or "1.1 GB". `connection_duration_seconds` is null while the
|
||||
feed is not connected. `API_POLICIES.md` is vendored from `sneak/prompts`, and
|
||||
`REPO_POLICIES.md` is re-vendored (closes #199)
|
||||
- 2026-10-27: Every result of the IP lookup has the same fields. A field without
|
||||
a value is null. It used to be left out. An address with no route in the
|
||||
routing table has every route and AS field set to null. `ptr` is an empty list
|
||||
when there are no PTR names. The new field `num_origins` gives the number of
|
||||
origin ASes of the netblock, and `origin_asns` gives which they are (closes
|
||||
#200)
|
||||
- 2026-10-27: With `TRUSTED_PROXIES` unset, the server trusts reverse proxies at
|
||||
- 2026-10-27: every value in a JSON answer that has a unit is a number, with the
|
||||
unit at the end of its field name. `@meta.execution_time` is now
|
||||
`execution_time_ms`. The stats' `uptime`, `connection_duration` and
|
||||
`memory_usage` are now `uptime_seconds`, `connection_duration_seconds` and
|
||||
`memory_usage_bytes`. `whois_stats.current_interval` is now
|
||||
`current_interval_seconds`. They used to be strings such as "12 ms",
|
||||
"1h18m34s" or "1.1 GB". `connection_duration_seconds` is null while the feed
|
||||
is not connected. `API_POLICIES.md` is vendored from `sneak/prompts`, and
|
||||
`REPO_POLICIES.md` re-vendored (closes #199)
|
||||
- 2026-10-27: every result of the IP lookup has the same fields. A field without
|
||||
a value is null. It used to be left out. An address with no live route has
|
||||
every route and AS field set to null, and `ptr` is an empty list when there
|
||||
are no PTR names. New fields give the number of origin ASes of the netblock,
|
||||
in `num_origins`, and which they are, in `origin_asns` (closes #200)
|
||||
- 2026-10-27: with `TRUSTED_PROXIES` unset, the server trusts reverse proxies at
|
||||
the private addresses of RFC 1918. `/ip/`, the home page's `curl` card and the
|
||||
request log then give the client's address from `X-Forwarded-For`. They used
|
||||
to give the proxy's address. A list in `TRUSTED_PROXIES` replaces the default.
|
||||
`TRUSTED_PROXIES` set but empty trusts no proxy (closes #198)
|
||||
- 2026-10-27: The home page has cards with figures of the routing table. One
|
||||
card shows the newest and the oldest kept route. One shows the newest and the
|
||||
oldest updated AS. One shows the AS with the most prefixes. One shows the ASes
|
||||
with a single prefix. One shows fifteen well-known networks. Two cards count
|
||||
the bogon announcements and the prefixes with more than one origin AS. They
|
||||
link to the new pages `/bogons` and `/multiple-origins`, which list them. A
|
||||
new package, `internal/bogon`, tells which prefixes and AS numbers are
|
||||
reserved. The server works the figures out once a minute (closes #154)
|
||||
- 2026-10-27: The per-peer route tables are gone, with the code that wrote,
|
||||
to give the proxy's address. A list in `TRUSTED_PROXIES` replaces the default,
|
||||
and `TRUSTED_PROXIES` set but empty trusts no proxy (closes #198)
|
||||
- 2026-10-27: the home page has cards with figures of the routing table: the
|
||||
newest and oldest kept route, the newest and oldest updated AS, the AS with
|
||||
the most prefixes, the ASes with a single prefix, and fifteen well-known
|
||||
networks. Two cards count the bogon announcements and the prefixes with more
|
||||
than one origin AS, and link to the new pages `/bogons` and
|
||||
`/multiple-origins` that list them. A new package, `internal/bogon`, tells
|
||||
which prefixes and AS numbers are reserved. The server works the figures out
|
||||
once a minute (closes #154)
|
||||
- 2026-10-27: the per-peer route tables are gone, with the code that wrote,
|
||||
counted and read them. The prefix handler applies each update to the routing
|
||||
table in memory. It writes the table's changes every second. It also stores
|
||||
each new prefix with its first-seen time. The image's memory limits fit a full
|
||||
routing table of about 1 GB. `GOMEMLIMIT` is 2.5 GiB. The writing connection's
|
||||
page cache is 512 MiB. SQLite's soft and hard heap limits are 768 MiB and 1
|
||||
GiB (closes #122)
|
||||
- 2026-10-27: The pages, the API and the stats read every route from the routing
|
||||
table in memory and writes the table's changes every second. It also stores
|
||||
each new prefix with its first-seen time. The image's memory limits are set
|
||||
for a full routing table of about 1 GB: `GOMEMLIMIT` is 2.5 GiB, the writing
|
||||
connection's page cache 512 MiB, and SQLite's heap limits 768 MiB and 1 GiB
|
||||
(closes #122)
|
||||
- 2026-10-27: the pages, the API and the stats read every route from the routing
|
||||
table in memory. For a prefix with several origin ASes, the IP lookup gives
|
||||
the one most peers carry. Its `last_seen` is the newest kept route's time. The
|
||||
prefix page and API list every peer that carries the prefix. Only the kept
|
||||
routes show an AS path, a next hop and a time. The stats count the origins
|
||||
whose kept routes were all withdrawn, in `origins_without_kept_route` (part of
|
||||
prefix page and API list every peer that carries the prefix, with an AS path,
|
||||
next hop and time only for the kept routes. The stats count the origins whose
|
||||
kept routes were all withdrawn, in `origins_without_kept_route` (part of #122)
|
||||
- 2026-10-27: the prefix, AS and peer handlers make a timed write on every tick
|
||||
of their timers, every 1, 2 and 2 seconds. They used to skip every other tick.
|
||||
A full batch's write restarts the timer, so the next timed write comes one
|
||||
interval after that write began (closes #192)
|
||||
- 2026-10-27: once the stop deadline has passed, the AS, peer and peering
|
||||
handlers start no write either. A full batch or a tick of the timer that
|
||||
waited while a write ran past the deadline could still start one. The flush
|
||||
goroutines of the prefix, AS and peer handlers now run the same code (closes
|
||||
#189)
|
||||
- 2026-10-27: once the stop deadline has passed, the prefix handler starts no
|
||||
flush. A batch that filled while a write ran past the deadline could still be
|
||||
written after it (closes #188)
|
||||
- 2026-10-27: the prefix handler applies each update to the routing table in
|
||||
memory, and writes the table's changes to the database every second. A write
|
||||
takes at most 20,000 changed pairs, and the rest follow in the next writes. A
|
||||
failed write is written again later. Startup reads the table before the
|
||||
streamer connects. The pages still read the per-peer route tables (part of
|
||||
#122)
|
||||
- 2026-10-27: The prefix, AS and peer handlers make a timed write on every tick
|
||||
of their timers. The prefix handler's timer ticks every second. The other two
|
||||
tick every two seconds. They used to skip every other tick. A full batch's
|
||||
write restarts the timer. So the next timed write comes one interval after
|
||||
that write began (closes #192)
|
||||
- 2026-10-27: Once the stop deadline has passed, the AS, peer and peering
|
||||
handlers start no write either. Before, a full batch or a timer tick could
|
||||
wait while a write ran past the deadline. Either could then start one more
|
||||
write. The flush goroutines of the prefix, AS and peer handlers now run the
|
||||
same code (closes #189)
|
||||
- 2026-10-27: Once the stop deadline has passed, the prefix handler starts no
|
||||
flush. Before, a batch that filled during a late write could still be written
|
||||
after the deadline (closes #188)
|
||||
- 2026-10-27: The prefix handler applies each update to the routing table in
|
||||
memory. It writes the table's changes to the database every second. A write
|
||||
takes at most 20,000 changed pairs of prefix and origin AS. The rest follow in
|
||||
the next writes. A failed write is written again later. Startup reads the
|
||||
table before the streamer connects. The pages still read the per-peer route
|
||||
tables (part of #122)
|
||||
- 2026-10-27: The database keeps a copy of the whole routing table in a new
|
||||
- 2026-10-27: the database keeps a copy of the whole routing table in a new
|
||||
`routes` table, one row per prefix and origin AS. The peers' numbers are in a
|
||||
new `route_peers` table. One function writes the pairs that changed in memory.
|
||||
Another reads the whole table back into memory at startup. Nothing uses them
|
||||
yet (part of #122)
|
||||
- 2026-10-27: A new package, `internal/routetable`, holds the whole routing
|
||||
new `route_peers` table. One function writes the pairs that changed in memory,
|
||||
and another reads the whole table back into memory at startup. Nothing uses
|
||||
them yet (part of #122)
|
||||
- 2026-10-27: a new package, `internal/routetable`, holds the whole routing
|
||||
table in memory. For each prefix and origin AS it keeps the peers that carry
|
||||
it, one bit per peer. It also keeps the two newest of their routes. Nothing
|
||||
uses it yet (part of #122)
|
||||
- 2026-10-27: Each result of the IP lookup lists the public blocklists the
|
||||
it, one bit per peer, and the two newest of their routes. Nothing uses it yet
|
||||
(part of #122)
|
||||
- 2026-10-27: each result of the IP lookup lists the public blocklists the
|
||||
address is on, in `blocklists`. The lists are DShield, Feodo Tracker, two
|
||||
FireHOL lists, two Spamhaus DROP lists and the Tor exit list. RouteWatch
|
||||
downloads each list on its own schedule and answers from copies in memory. The
|
||||
copies are also kept in the state directory's `blocklists` directory. IP
|
||||
lookup answers carry `Cache-Control`. An address with no route now has a
|
||||
result too, without route fields. So the IP lookup no longer answers 404
|
||||
(closes #158)
|
||||
- 2026-10-27: The home page has an IP information API card. It shows the `curl`
|
||||
command that looks up the visitor's own address at `/ip/{addr}`. It also shows
|
||||
that command's live answer (closes #156)
|
||||
- 2026-10-27: On the AS page, a click on the heading of the IPv4 or the IPv6
|
||||
FireHOL lists, Spamhaus DROP and the Tor exit list. RouteWatch downloads each
|
||||
list on its own schedule and answers from copies in memory. The copies are
|
||||
also kept in the state directory's `blocklists` directory. IP lookup answers
|
||||
carry `Cache-Control`. An address with no live route now has a result too,
|
||||
without route fields, so the IP lookup no longer answers 404 (closes #158)
|
||||
- 2026-10-27: the home page has an IP information API card. It shows the `curl`
|
||||
command that looks up the visitor's own address at `/ip/{addr}`, and that
|
||||
command's live answer (closes #156)
|
||||
- 2026-10-27: on the AS page, a click on the heading of the IPv4 or the IPv6
|
||||
prefix list folds or unfolds the list. Both lists start open (closes #155)
|
||||
- 2026-10-27: The AS page lists its IPv4 and its IPv6 prefixes by mask length,
|
||||
shortest first. Prefixes of one mask length are listed by address. They used
|
||||
to be sorted by address first, then by mask length (closes #153)
|
||||
- 2026-10-27: The connection status on `/` and `/status` gets a spinner. It
|
||||
turns one frame each time the stats show more messages than the time before.
|
||||
After three refreshes with no new messages, the page shows "stale" in red
|
||||
instead. Next to it is the time since the last fresh answer (closes #152)
|
||||
- 2026-10-27: The WHOIS details of a Brazilian AS keep their accented letters.
|
||||
LACNIC's answer for such an AS is NIC.br's answer with each accented letter
|
||||
replaced. NIC.br is Brazil's registry. The details now come from NIC.br's own
|
||||
server, `whois.registro.br`. When that query fails, the details from LACNIC's
|
||||
answer are kept and a warning is logged. RouteWatch stops asking NIC.br for an
|
||||
hour after NIC.br says RouteWatch is over its query limit (closes #174)
|
||||
- 2026-10-27: the AS page lists its IPv4 and its IPv6 prefixes by mask length,
|
||||
shortest first, and prefixes of one mask length by address. They used to be
|
||||
listed by address (closes #153)
|
||||
- 2026-10-27: on `/` and `/status`, a spinner beside the status turns one frame
|
||||
each time the stats show more messages than the time before. A page that has
|
||||
not seen more messages for three refreshes shows "stale" and the time since
|
||||
then instead, in red (closes #152)
|
||||
- 2026-10-27: the WHOIS details of a Brazilian AS keep their accented letters.
|
||||
LACNIC's answer for such an AS comes from NIC.br, Brazil's registry, with each
|
||||
accented letter replaced. The details now come from NIC.br's own server,
|
||||
`whois.registro.br`. When that query fails, the details from LACNIC's answer
|
||||
are kept and a warning is logged. After NIC.br answers that RouteWatch is over
|
||||
its query limit, RouteWatch stops asking NIC.br for an hour (closes #174)
|
||||
- 2026-10-27: `make asupdate` stops with an error when the download of `as.csv`
|
||||
breaks off. The generator used to retry the failed read forever. A record that
|
||||
does not parse is still logged and skipped (closes #177)
|
||||
@@ -255,192 +197,182 @@ problem the run finds.
|
||||
one AS. A failed download used to replace the list with an empty file. The
|
||||
generator reads `as.csv` from `ipverse/as-metadata`, the source's new name
|
||||
(closes #173)
|
||||
- 2026-10-27: The WHOIS details of an AS at RIPE, APNIC or AFRINIC come only
|
||||
- 2026-10-27: the WHOIS details of an AS at RIPE, APNIC or AFRINIC come only
|
||||
from its `aut-num` object and the organisation object it names. RIPE and APNIC
|
||||
start their answer with the `as-block` object of the AS's block. Its dates
|
||||
were stored as the AS's (closes #168)
|
||||
- 2026-10-27: AS names keep their accented letters. The AS list built into
|
||||
RouteWatch is rebuilt from today's `as.csv`, which added a country code
|
||||
column. That file no longer lists AS 0 or the documentation AS numbers. A
|
||||
WHOIS answer that is not valid UTF-8 is decoded as Latin-1 before it is parsed
|
||||
and stored. RIPE and APNIC send Latin-1 (closes #165)
|
||||
- 2026-10-27: The Age column on the AS and prefix pages reads in words, such as
|
||||
"5 minutes ago" or "2 weeks ago". It used to print Go durations such as
|
||||
"360h0m0s ago". An age under a minute reads "now" or in seconds. An age over a
|
||||
month reads in months or years instead of a date (closes #163)
|
||||
- 2026-10-26: A write to a stored AS, peering or peer keeps the earlier of the
|
||||
two first-seen times. It keeps the later of the two last-seen times. An old
|
||||
update from a collector catching up on a backlog no longer moves last seen
|
||||
back (closes #162)
|
||||
- 2026-10-26: The status page shows "Route Churn/min". That is the number of
|
||||
prefix announcements and withdrawals from all peers in the last full clock
|
||||
minute. `/api/v1/stats` reports it as `route_churn_per_min` in `stream`. It
|
||||
WHOIS answer that is not valid UTF-8 is decoded as Latin-1, which RIPE and
|
||||
APNIC send, before it is parsed and stored (closes #165)
|
||||
- 2026-10-27: the Age column on the AS and prefix pages reads in words, such as
|
||||
"5 minutes ago" or "2 weeks ago", instead of Go durations such as "360h0m0s
|
||||
ago". An age under a minute reads in seconds, and one over a month in months
|
||||
or years instead of a date (closes #163)
|
||||
- 2026-10-26: a write to a stored AS, peering or peer keeps the earlier of the
|
||||
two first-seen times and the later of the two last-seen times. An old update
|
||||
from a collector catching up on a backlog no longer moves last seen back
|
||||
(closes #162)
|
||||
- 2026-10-26: the status page shows "Route Churn/min", the number of prefix
|
||||
announcements and withdrawals, from all peers, in the last full clock minute.
|
||||
`/api/v1/stats` reports it as `route_churn_per_min` in `stream`, which
|
||||
replaces the moving average `route_churn_per_sec`. The messages and updates
|
||||
per second on `/` and `/status` are whole numbers (closes #160)
|
||||
- 2026-10-26: The WHOIS fetcher backs off more slowly. A failure makes its wait
|
||||
- 2026-10-26: the WHOIS fetcher backs off more slowly. A failure makes its wait
|
||||
1.5 times as long, up to one minute instead of five. Its queries to RIPE,
|
||||
APNIC and AFRINIC leave out person and role objects. RIPE counts those objects
|
||||
against a daily limit per address. A refused query is logged with the RIR's
|
||||
error line (closes #159)
|
||||
- 2026-10-26: The home page's AS name search works. It lists the ASes whose
|
||||
handle or description holds the text, as links to their pages. The new
|
||||
`/api/v1/search/as` answers it. The search ignores case. When the database has
|
||||
no record of an AS, its page takes the handle and description from the AS list
|
||||
built into RouteWatch. It still lists the AS's prefixes (closes #151)
|
||||
- 2026-10-19: README "HTTP Endpoints" lists every route with what it answers.
|
||||
README "Database Schema" matches `schema.sql`. The rest of the README matches
|
||||
the code. This file is brought up to date (closes #72)
|
||||
- 2026-10-19: Route writes are cheaper. The live route and prefix tables lose
|
||||
their random UUID keys. The prefix tables lose their duplicate index. A route
|
||||
update sets only the columns that change. Every write goes through one
|
||||
APNIC and AFRINIC leave out person and role objects, which RIPE counts against
|
||||
a daily limit per address. A refused query is logged with the RIR's error line
|
||||
(closes #159)
|
||||
- 2026-10-26: the home page's AS name search lists the ASes whose handle or
|
||||
description holds the text, as links to their pages, from the new
|
||||
`/api/v1/search/as`; the search ignores case. When the database has no record
|
||||
of an AS, its page takes the handle and description from the AS list built
|
||||
into RouteWatch and still lists the AS's prefixes (closes #151)
|
||||
- 2026-10-19: README "HTTP Endpoints" lists every route with what it answers,
|
||||
"Database Schema" matches `schema.sql`, and the rest of the README matches the
|
||||
code; this file brought up to date (closes #72)
|
||||
- 2026-10-19: route writes are cheaper: the live route and prefix tables lose
|
||||
their random UUID keys and the prefix tables their duplicate index, a route
|
||||
update sets only the columns that change, and every write goes through one
|
||||
connection with a page cache of 1 GiB (README "Memory"). A benchmark writes
|
||||
the prefix handler's largest batch faster than the feed sends it (closes #96)
|
||||
- 2026-10-19: The checkpoint of the WAL (SQLite's write-ahead log), the
|
||||
incremental vacuum and `ANALYZE` take the database lock that every batch write
|
||||
holds. So a vacuum no longer fails with "database is locked". An `ANALYZE` no
|
||||
longer makes a batch write lose its updates. `ANALYZE` runs as
|
||||
`PRAGMA optimize` with an analysis limit (closes #94)
|
||||
- 2026-10-19: Shutdown stops the streamer first. Each handler then writes
|
||||
everything left on its queue before it stops. So the updates waiting there are
|
||||
- 2026-10-19: the WAL checkpoint, the incremental vacuum and ANALYZE take the
|
||||
database lock every batch write holds, so a vacuum no longer fails with
|
||||
"database is locked" and an ANALYZE no longer makes a batch write lose its
|
||||
updates; ANALYZE runs as `PRAGMA optimize` with an analysis limit (closes #94)
|
||||
- 2026-10-19: shutdown stops the streamer first, and each handler writes
|
||||
everything left on its queue before it stops, so the updates waiting there are
|
||||
no longer lost (closes #69)
|
||||
- 2026-10-19: A path that ends in an AS set of several members has origin AS 0,
|
||||
which means no known origin. It used to have the set's last member as its
|
||||
origin. The set adds no peerings. The pages show such a route as having no
|
||||
known origin (closes #75)
|
||||
- 2026-10-19: a path that ends in an AS set of several members has origin AS 0,
|
||||
no known origin, instead of the set's last member, and the set adds no
|
||||
peerings; the pages show such a route as having no known origin (closes #75)
|
||||
- 2026-10-19: `bgp_peer_count` drops to 0 when the last peer goes down (closes
|
||||
#92)
|
||||
- 2026-10-19: `bgp_peer_count` counts every peer the feed has heard from. It
|
||||
used to count only the peers whose session opened since startup. It drops a
|
||||
peer whose session goes down (closes #74)
|
||||
- 2026-10-19: The shared files are re-vendored from `sneak/prompts` at
|
||||
`0653579`. The linter is `golangci-lint` v2.14.0 with its configuration. Lint
|
||||
and test are `Dockerfile` phases that keep Go's and `golangci-lint`'s caches.
|
||||
`make fmt` also formats the markdown with `prettier`. The agent guidance moves
|
||||
to `AGENTS.md`. The code is fixed for what the new linter configuration finds
|
||||
(closes #52)
|
||||
- 2026-10-19: The streamer reads feed lines up to 1 MiB. A line over 64 KiB used
|
||||
to end the connection (closes #76)
|
||||
- 2026-10-19: A peer's live routes are removed when its BGP session goes down.
|
||||
`STATE` messages are never dropped when a queue is full. One that finds its
|
||||
- 2026-10-19: `bgp_peer_count` counts every peer the feed has heard from, not
|
||||
only those whose session opened since startup, and drops a peer whose session
|
||||
goes down (closes #74)
|
||||
- 2026-10-19: the shared files are re-vendored from `sneak/prompts` at
|
||||
`0653579`: golangci-lint v2.14.0 and its configuration, lint and test as
|
||||
`Dockerfile` phases that keep Go's and golangci-lint's caches, markdown
|
||||
formatted with prettier, agent guidance in `AGENTS.md`; the code is fixed for
|
||||
what the new linter configuration finds (closes #52)
|
||||
- 2026-10-19: the streamer reads feed lines up to 1 MiB, so a line over 64 KiB
|
||||
no longer ends the connection (closes #76)
|
||||
- 2026-10-19: a peer's live routes are removed when its BGP session goes down;
|
||||
`STATE` messages are never dropped for backpressure, and one that finds its
|
||||
queue full waits for room ahead of the handler's other messages (closes #56)
|
||||
- 2026-10-19: The prefix-length pages pick their sample with a bounded number of
|
||||
index lookups. They used to read every route of that length. They list each
|
||||
- 2026-10-19: the prefix-length pages pick their sample with a bounded number of
|
||||
index lookups instead of reading every route of that length, and list each
|
||||
prefix once (closes #66)
|
||||
- 2026-10-19: A request past its time limit answers 504 instead of 408.
|
||||
- 2026-10-19: a request past its time limit answers 504 instead of 408, and
|
||||
`/api/v1/stats` answers 504 instead of 500 when its read runs out of time
|
||||
(closes #70)
|
||||
- 2026-10-19: The AS, peer and prefix handlers write each batch outside the lock
|
||||
their message handling needs. So messages keep coming off their queues during
|
||||
a write. Meanwhile the next batch grows to at most ten batch sizes (closes
|
||||
- 2026-10-19: the AS, peer and prefix handlers write each batch outside the lock
|
||||
their message handling needs, so messages keep coming off their queues during
|
||||
a write; meanwhile the next batch grows to at most ten batch sizes (closes
|
||||
#65)
|
||||
- 2026-10-19: A live route is identified by prefix and peer. So an announcement
|
||||
with a new origin AS replaces the peer's route. A withdrawal removes it
|
||||
- 2026-10-19: a live route is identified by prefix and peer, so an announcement
|
||||
with a new origin AS replaces the peer's route and a withdrawal removes it
|
||||
whatever its origin AS (closes #55)
|
||||
- 2026-10-14: The streamer reconnects when RIS Live ends the stream or sends
|
||||
nothing for 60 seconds. The health check reports the feed disconnected
|
||||
- 2026-10-14: the streamer reconnects when RIS Live ends the stream or sends
|
||||
nothing for 60 seconds, and the health check reports the feed disconnected
|
||||
meanwhile (closes #53)
|
||||
- 2026-10-14: The prefix page takes the names of the origin ASes from the prefix
|
||||
query. It used to read every route of each origin AS (closes #67)
|
||||
- 2026-10-14: The daemon exits with status 1 when its web server cannot listen
|
||||
on its port. It used to run on without a web server (closes #73)
|
||||
- 2026-10-14: The prefix pages parse the prefix before looking it up. One that
|
||||
does not parse answers 400. Any valid way of writing a prefix finds its routes
|
||||
(closes #71)
|
||||
- 2026-10-14: The IP lookup ignores routes shorter than /8 for IPv4 and /16 for
|
||||
IPv6. So a default route is no longer named as an address's owner (closes #57)
|
||||
- 2026-10-14: A prefix batch keeps each peer's last update for a prefix. It used
|
||||
to keep one update per prefix across all peers (closes #54)
|
||||
- 2026-10-14: the prefix page takes the names of the origin ASes from the prefix
|
||||
query instead of reading every route of each origin AS (closes #67)
|
||||
- 2026-10-14: the daemon exits with status 1 when its web server cannot listen
|
||||
on its port, instead of running on without it (closes #73)
|
||||
- 2026-10-14: the prefix pages parse the prefix before looking it up: one that
|
||||
does not parse answers 400, and any valid way of writing a prefix finds its
|
||||
routes (closes #71)
|
||||
- 2026-10-14: the IP lookup ignores routes shorter than /8 for IPv4 and /16 for
|
||||
IPv6, so a default route is no longer named as an address's owner (closes #57)
|
||||
- 2026-10-14: a prefix batch keeps each peer's last update for a prefix, instead
|
||||
of one update per prefix across all peers (closes #54)
|
||||
- 2026-10-14: `reconnect_count` in `/api/v1/stats` counts every reconnect
|
||||
(closes #68)
|
||||
- 2026-10-03: `/api/v1/stats` serves the prefix distribution from memory. The
|
||||
distribution is seeded at startup and adjusted on every live-route write. So a
|
||||
request no longer reads every live route (closes #30)
|
||||
- 2026-10-03: A new database is created with `auto_vacuum` set to incremental.
|
||||
The setting goes in the connection string, so it is set before the file is
|
||||
first written. Each periodic incremental vacuum now returns up to 1000 free
|
||||
pages. The late `PRAGMA auto_vacuum` in `Initialize`, which SQLite ignored, is
|
||||
gone (closes #43)
|
||||
- 2026-10-03: Looking up an IP address no longer reads every IPv6 route. Both
|
||||
- 2026-10-03: `/api/v1/stats` serves the prefix distribution from memory, seeded
|
||||
at startup and adjusted on every live-route write, so a request no longer
|
||||
reads every live route (closes #30)
|
||||
- 2026-10-03: a new database is created with `auto_vacuum` set to incremental,
|
||||
through the connection string so it is set before the file is first written,
|
||||
and each periodic incremental vacuum now returns up to 1000 free pages; the
|
||||
late `PRAGMA auto_vacuum` in `Initialize`, which SQLite ignored, is gone
|
||||
(closes #43)
|
||||
- 2026-10-03: looking up an IP address no longer reads every IPv6 route: both
|
||||
families find the most specific live route with at most 33 or 129 lookups on
|
||||
the prefix index. The IPv4 range columns are gone. Prefixes from the feed are
|
||||
stored in one text form. So an IPv6 withdrawal, which the feed sends
|
||||
the prefix index, and the IPv4 range columns are gone. Prefixes from the feed
|
||||
are stored in one text form, so an IPv6 withdrawal, which the feed sends
|
||||
uncompressed, now removes its route (closes #48)
|
||||
- 2026-10-02: A plain `docker build .` stamps the commit's tag or short commit
|
||||
into the page footer. It used to stamp `unknown`. The value comes from
|
||||
`git describe --tags --always`. `.dockerignore` sends `.git` without
|
||||
`.git/config`. A `VERSION` build argument takes precedence. `make build`
|
||||
stamps the same value (closes #46)
|
||||
- 2026-09-29: The entrypoint creates the data directory if it is missing. It
|
||||
stops the start if a step fails. README "Running under upaas" no longer asks
|
||||
- 2026-10-02: a plain `docker build .` stamps the commit's tag or short commit
|
||||
(`git describe --tags --always`) into the page footer instead of `unknown`:
|
||||
`.dockerignore` sends `.git` without `.git/config`, a `VERSION` build argument
|
||||
takes precedence, and `make build` stamps the same value (closes #46)
|
||||
- 2026-09-29: the entrypoint creates the data directory if it is missing and
|
||||
stops the start if a step fails; README "Running under upaas" no longer asks
|
||||
for the host directory to be created first (closes #42)
|
||||
- 2026-09-29: `.dockerignore` keeps `.git`, local build output, local databases
|
||||
and `.env` out of the Docker build context. So they stay out of the source
|
||||
archive in the image (closes #39)
|
||||
- 2026-09-29: The README's first line names the MIT licence and the author. The
|
||||
License section says MIT and links `LICENSE`. An Author section is added. This
|
||||
file is brought up to date (closes #38)
|
||||
- 2026-09-29: `LICENSE` is added, with the MIT licence (closes #1)
|
||||
- 2026-09-28: Stopping the daemon while the feed is flowing no longer panics
|
||||
with "send on closed channel". The read loop checks for a stop just before
|
||||
handing a message to the handler queues. A second `Stop` no longer closes the
|
||||
queues again (closes #34)
|
||||
and `.env` out of the Docker build context, and so out of the source archive
|
||||
in the image (closes #39)
|
||||
- 2026-09-29: README first line names the MIT license and the author; the
|
||||
License section now says MIT and links `LICENSE`, and an Author section was
|
||||
added; this file brought up to date (closes #38)
|
||||
- 2026-09-29: MIT `LICENSE` (closes #1)
|
||||
- 2026-09-28: stopping the daemon while the feed is flowing no longer panics
|
||||
with "send on closed channel": the read loop checks for a stop just before
|
||||
handing a message to the handler queues, and a second `Stop` no longer closes
|
||||
the queues again (closes #34)
|
||||
- 2026-09-28: `docker stop` no longer kills the daemon 2 seconds after the stop
|
||||
signal. The entrypoint switches to the `routewatch` user with `setpriv`
|
||||
instead of `runuser`. So the daemon receives the signal itself. It gets the
|
||||
signal: the entrypoint switches to the `routewatch` user with `setpriv`
|
||||
instead of `runuser`, so the daemon receives the signal itself and gets the
|
||||
whole wait `docker stop` allows, up to its own 60-second limit (closes #33)
|
||||
- 2026-09-28: RouteWatch is ready to run under upaas. A set but invalid `PORT`,
|
||||
`XDG_DATA_HOME` or `MALLOC_ARENA_MAX` stops the start. The health check
|
||||
follows `PORT`. README gains a "Running under upaas" section (closes #31)
|
||||
- 2026-09-22: The database statistics are kept in memory. The counts are seeded
|
||||
at startup and adjusted on every write. The oldest and newest route times come
|
||||
from a lookup at each end of an index. `/api/v1/stats` no longer scans the
|
||||
tables (closes #27)
|
||||
- 2026-09-21: Batch writes take the write lock when their transaction begins
|
||||
(`_txlock=immediate`). So they wait out a WAL checkpoint instead of failing
|
||||
- 2026-09-28: ready to run under upaas: a set but invalid `PORT`,
|
||||
`XDG_DATA_HOME` or `MALLOC_ARENA_MAX` stops the start, the health check
|
||||
follows `PORT`, README "Running under upaas" section (closes #31)
|
||||
- 2026-09-22: realtime in-memory database statistics: counts seeded at startup
|
||||
and adjusted on every write, oldest/newest route timestamps via index-end
|
||||
lookups; `/api/v1/stats` no longer scans the tables (closes #27)
|
||||
- 2026-09-21: batch writes take the write lock when their transaction begins
|
||||
(`_txlock=immediate`), so they wait out a WAL checkpoint instead of failing
|
||||
with "database is locked" (closes #25)
|
||||
- 2026-09-21: `MALLOC_ARENA_MAX=2` in the image caps the number of glibc malloc
|
||||
arenas. So memory outside the Go runtime no longer grows with the core count
|
||||
(closes #23)
|
||||
- 2026-09-21: The image sets `GOMEMLIMIT=1536MiB`. README "Memory" gives the
|
||||
- 2026-09-21: `MALLOC_ARENA_MAX=2` in the image caps glibc malloc arenas, so
|
||||
memory outside the Go runtime no longer grows with the core count (closes #23)
|
||||
- 2026-09-21: `GOMEMLIMIT=1536MiB` in the image; README Memory section with the
|
||||
memory budget and the 5 GiB container limit (closes #13)
|
||||
- 2026-09-21: The four handler queues hold at most 20,000 messages each, down
|
||||
- 2026-09-21: the four handler queues hold at most 20,000 messages each, down
|
||||
from 100,000 (closes #11)
|
||||
- 2026-09-21: Two goroutine leaks are fixed. The stats handlers leaked after a
|
||||
timeout. The streamer's tickers leaked on every reconnect (closes #12)
|
||||
- 2026-09-21: Parsed RIS messages no longer keep the unused `Community` and
|
||||
- 2026-09-21: two goroutine leaks fixed: the stats handlers after a timeout and
|
||||
the streamer's tickers on every reconnect (closes #12)
|
||||
- 2026-09-21: parsed RIS messages no longer keep the unused `Community` and
|
||||
`Raw` fields (closes #9)
|
||||
- 2026-09-21: `.editorconfig` is added. A Gitea workflow runs `script/cibuild`
|
||||
- 2026-09-21: `.editorconfig`, and a Gitea workflow that runs `script/cibuild`
|
||||
on every push (closes #14)
|
||||
- 2026-09-21: The peering handler's AS-path map holds at most 500,000 paths.
|
||||
Every 30 seconds it is swapped for an empty one instead of copied (closes #10)
|
||||
- 2026-09-21: SQLite's memory is bounded across the whole connection pool. Each
|
||||
connection has a 64 MiB page cache. The heap limits are 1 GiB soft and 1.5 GiB
|
||||
hard (closes #8)
|
||||
- 2026-09-21: The Docker build runs the format check, the linter and the tests.
|
||||
Linting runs in a separate stage on a `golangci-lint` image pinned by digest
|
||||
(closes #5)
|
||||
- 2026-09-21: `make test` skips the live feed test, with `-short`. So
|
||||
- 2026-09-21: the peering handler's AS-path map holds at most 500,000 paths and
|
||||
is swapped for an empty one every 30 seconds instead of copied (closes #10)
|
||||
- 2026-09-21: SQLite memory bounded across the whole connection pool: a 64 MiB
|
||||
page cache on each connection, 1 GiB soft and 1.5 GiB hard heap limits (closes
|
||||
#8)
|
||||
- 2026-09-21: the Docker build runs the format check, the linter and the tests,
|
||||
linting in a separate stage on a golangci-lint image pinned by digest (closes
|
||||
#5)
|
||||
- 2026-09-21: `make test` skips the live-network feed test (`-short`), so
|
||||
`make check` no longer depends on the network (closes #2)
|
||||
- 2026-07-07: The scripts-to-rule-them-all layout is adopted. `script/` holds
|
||||
the entrypoints. The `Makefile` targets `check`, `test`, `lint`, `fmt` and
|
||||
`fmt-check` call them. So do `bootstrap`, `setup`, `docker` and `hooks`.
|
||||
README gains an "Entrypoints" section
|
||||
- 2026-02-22: The repo is brought in line with the repo policies. The required
|
||||
policy files are added. `.gitignore` is updated. The `Makefile` gains
|
||||
`fmt-check`, `check`, `docker` and `hooks` targets. The Go code is formatted
|
||||
with `gofmt`. The work was on the branch `repo-policies-compliance`, unmerged
|
||||
when this entry was written
|
||||
- 2026-01-01: The WAL is checkpointed every 5 seconds, and at startup with a log
|
||||
line. Checkpoints run in `TRUNCATE` mode. This fixed slow queries
|
||||
- 2025-12-31: The pages get a navigation bar and a home page with a search. The
|
||||
status page shows the oldest and newest route times. The WHOIS stats query
|
||||
handles `NULL`. The container runs as the `routewatch` user with the right
|
||||
state directory
|
||||
- 2025-12-30: HTTP requests are logged as structured log lines. The HTTP
|
||||
timeouts are longer. Prefix URLs with a slash in them route correctly. The
|
||||
status page gets more metrics and a footer
|
||||
- 2025-12-29: The `Dockerfile` builds in stages and puts a source archive in the
|
||||
image. SQLite reclaims space with incremental vacuum, which does not block
|
||||
- 2025-07-27: The first commit: RouteWatch, a BGP stream monitor
|
||||
- 2026-07-07 Adopted scripts-to-rule-them-all: `script/` entrypoints, Makefile
|
||||
shims, README Entrypoints section
|
||||
- 2026-02-22: repo policy compliance: required policy files, .gitignore update,
|
||||
Makefile fmt-check/check/docker/hooks targets, gofmt pass
|
||||
(repo-policies-compliance, unmerged)
|
||||
- 2026-01-01: WAL checkpointing: periodic (5s), on startup with logging,
|
||||
TRUNCATE mode; fixed slow queries
|
||||
- 2025-12-31: status page: navbar, home page with search, oldest/newest route
|
||||
timestamps, NULL handling in WHOIS stats; container runs as routewatch user
|
||||
with proper state dir
|
||||
- 2025-12-30: structured HTTP request logging, increased timeouts, CIDR prefix
|
||||
URL routing fixes, status page metrics and footer
|
||||
- 2025-12-29: Dockerfile multi-stage build with source archive; SQLite
|
||||
incremental vacuum for non-blocking space reclamation
|
||||
- 2025-07-27: initial RouteWatch BGP stream monitor
|
||||
|
||||
# Future Steps
|
||||
|
||||
None.
|
||||
|
||||
@@ -1,7 +1,6 @@
|
||||
// Package database provides SQLite storage for BGP routing data: ASNs,
|
||||
// prefixes, announcements, peerings, BGP peers and origin changes. Its routes
|
||||
// table holds a copy of the whole routing table that internal/routetable
|
||||
// keeps in memory.
|
||||
// prefixes, announcements, peerings and BGP peers. Its routes table holds a
|
||||
// copy of the whole routing table that internal/routetable keeps in memory.
|
||||
package database
|
||||
|
||||
import (
|
||||
@@ -56,14 +55,6 @@ type Store interface {
|
||||
WriteRouteChanges(changes []routetable.Change, newPeers map[string]uint) error
|
||||
ReadRouteTable(ctx context.Context) (*routetable.Table, error)
|
||||
|
||||
// Origin change operations: the prefix and origin AS pairs' first and
|
||||
// last peers, as the routing table records them.
|
||||
WriteOriginChanges(changes []routetable.OriginChange) error
|
||||
GetOriginChanges(
|
||||
ctx context.Context, prefix netip.Prefix, limit int,
|
||||
) ([]routetable.OriginChange, error)
|
||||
PruneOriginChanges(ctx context.Context) error
|
||||
|
||||
// ASN WHOIS operations
|
||||
GetNextStaleASN(ctx context.Context, staleThreshold time.Duration) (int, error)
|
||||
UpdateASNWHOIS(ctx context.Context, update *ASNWHOISUpdate) error
|
||||
|
||||
@@ -1,172 +0,0 @@
|
||||
package database
|
||||
|
||||
import (
|
||||
"context"
|
||||
"fmt"
|
||||
"net/netip"
|
||||
"time"
|
||||
|
||||
"git.eeqj.de/sneak/routewatch/internal/routetable"
|
||||
)
|
||||
|
||||
// minOriginChangesPerPrefix is how many of a prefix's newest origin changes
|
||||
// the prune always keeps, whatever their age.
|
||||
const minOriginChangesPerPrefix = 500
|
||||
|
||||
// originChangesRetention is how long the prune keeps an origin change: rows
|
||||
// older than this are deleted, unless they are among the prefix's newest
|
||||
// minOriginChangesPerPrefix.
|
||||
const originChangesRetention = 72 * time.Hour
|
||||
|
||||
// The statements of the origin_changes table (schema.sql).
|
||||
const (
|
||||
insertOriginChangeSQL = `INSERT INTO origin_changes
|
||||
(prefix, origin_asn, announced, peer_count, time)
|
||||
VALUES (?, ?, ?, ?, ?)`
|
||||
originChangesSQL = `SELECT prefix, origin_asn, announced, peer_count, time
|
||||
FROM origin_changes WHERE prefix = ? ORDER BY id DESC LIMIT ?`
|
||||
prunePrefixesSQL = `SELECT prefix FROM origin_changes
|
||||
GROUP BY prefix HAVING COUNT(*) > ?`
|
||||
pruneOriginChangesSQL = `DELETE FROM origin_changes
|
||||
WHERE prefix = ? AND time < ? AND id < (
|
||||
SELECT id FROM origin_changes WHERE prefix = ?
|
||||
ORDER BY id DESC LIMIT 1 OFFSET ?)`
|
||||
)
|
||||
|
||||
// WriteOriginChanges writes, in one transaction, the origin changes the
|
||||
// routing table handed over. When it fails, it writes nothing; the caller then
|
||||
// writes them again.
|
||||
func (d *Database) WriteOriginChanges(changes []routetable.OriginChange) error {
|
||||
if len(changes) == 0 {
|
||||
return nil
|
||||
}
|
||||
|
||||
d.lock("WriteOriginChanges")
|
||||
defer d.unlock()
|
||||
|
||||
tx, err := d.beginTx()
|
||||
if err != nil {
|
||||
return fmt.Errorf("failed to begin transaction: %w", err)
|
||||
}
|
||||
defer d.rollback(tx)
|
||||
|
||||
ctx := context.Background()
|
||||
|
||||
stmt, err := tx.PrepareContext(ctx, insertOriginChangeSQL)
|
||||
if err != nil {
|
||||
return fmt.Errorf("failed to prepare origin change insert: %w", err)
|
||||
}
|
||||
defer func() { _ = stmt.Close() }()
|
||||
|
||||
for _, change := range changes {
|
||||
_, err := stmt.ExecContext(ctx, change.Prefix.String(),
|
||||
change.OriginASN, change.Announced, change.PeerCount,
|
||||
change.Time.Unix())
|
||||
if err != nil {
|
||||
return fmt.Errorf("failed to write origin change %s: %w",
|
||||
change.Prefix, err)
|
||||
}
|
||||
}
|
||||
|
||||
err = tx.Commit()
|
||||
if err != nil {
|
||||
return fmt.Errorf("failed to commit transaction: %w", err)
|
||||
}
|
||||
|
||||
return nil
|
||||
}
|
||||
|
||||
// GetOriginChanges returns at most limit of prefix's origin changes, newest
|
||||
// first.
|
||||
func (d *Database) GetOriginChanges(
|
||||
ctx context.Context, prefix netip.Prefix, limit int,
|
||||
) ([]routetable.OriginChange, error) {
|
||||
rows, err := d.db.QueryContext(ctx, originChangesSQL,
|
||||
prefix.Masked().String(), limit)
|
||||
if err != nil {
|
||||
return nil, fmt.Errorf("failed to read origin changes: %w", err)
|
||||
}
|
||||
defer func() { _ = rows.Close() }()
|
||||
|
||||
var changes []routetable.OriginChange
|
||||
|
||||
for rows.Next() {
|
||||
var (
|
||||
change routetable.OriginChange
|
||||
prefixText string
|
||||
timeSec int64
|
||||
)
|
||||
|
||||
err := rows.Scan(&prefixText, &change.OriginASN, &change.Announced,
|
||||
&change.PeerCount, &timeSec)
|
||||
if err != nil {
|
||||
return nil, fmt.Errorf("failed to read an origin change: %w", err)
|
||||
}
|
||||
|
||||
change.Prefix, err = netip.ParsePrefix(prefixText)
|
||||
if err != nil {
|
||||
return nil, fmt.Errorf("failed to read origin change %s: %w",
|
||||
prefixText, err)
|
||||
}
|
||||
|
||||
change.Time = time.Unix(timeSec, 0).UTC()
|
||||
changes = append(changes, change)
|
||||
}
|
||||
|
||||
err = rows.Err()
|
||||
if err != nil {
|
||||
return nil, fmt.Errorf("failed to read origin changes: %w", err)
|
||||
}
|
||||
|
||||
return changes, nil
|
||||
}
|
||||
|
||||
// PruneOriginChanges deletes, for each prefix with more than
|
||||
// minOriginChangesPerPrefix rows, the rows older than originChangesRetention
|
||||
// that are not among its newest minOriginChangesPerPrefix. It finds those
|
||||
// prefixes on a reading connection and deletes one prefix per write, so no
|
||||
// write holds the lock for long.
|
||||
func (d *Database) PruneOriginChanges(ctx context.Context) error {
|
||||
rows, err := d.db.QueryContext(ctx, prunePrefixesSQL,
|
||||
minOriginChangesPerPrefix)
|
||||
if err != nil {
|
||||
return fmt.Errorf("failed to find prefixes to prune: %w", err)
|
||||
}
|
||||
defer func() { _ = rows.Close() }()
|
||||
|
||||
var prefixes []string
|
||||
|
||||
for rows.Next() {
|
||||
var prefix string
|
||||
|
||||
err := rows.Scan(&prefix)
|
||||
if err != nil {
|
||||
return fmt.Errorf("failed to read a prefix to prune: %w", err)
|
||||
}
|
||||
|
||||
prefixes = append(prefixes, prefix)
|
||||
}
|
||||
|
||||
err = rows.Err()
|
||||
if err != nil {
|
||||
return fmt.Errorf("failed to find prefixes to prune: %w", err)
|
||||
}
|
||||
|
||||
cutoff := time.Now().Add(-originChangesRetention).Unix()
|
||||
|
||||
for _, prefix := range prefixes {
|
||||
d.lock("PruneOriginChanges")
|
||||
|
||||
_, err := d.writer.ExecContext(ctx, pruneOriginChangesSQL,
|
||||
prefix, cutoff, prefix, minOriginChangesPerPrefix-1)
|
||||
|
||||
d.unlock()
|
||||
|
||||
if err != nil {
|
||||
return fmt.Errorf("failed to prune origin changes of %s: %w",
|
||||
prefix, err)
|
||||
}
|
||||
}
|
||||
|
||||
return nil
|
||||
}
|
||||
@@ -1,217 +0,0 @@
|
||||
package database
|
||||
|
||||
import (
|
||||
"net/netip"
|
||||
"reflect"
|
||||
"testing"
|
||||
"time"
|
||||
|
||||
"git.eeqj.de/sneak/routewatch/internal/routetable"
|
||||
)
|
||||
|
||||
// TestOriginChangesWriteThenRead writes three origin changes and reads them
|
||||
// back newest first, honouring the limit.
|
||||
func TestOriginChangesWriteThenRead(t *testing.T) {
|
||||
t.Parallel()
|
||||
|
||||
db := newRoutesTestDatabase(t)
|
||||
prefix := netip.MustParsePrefix(tablePrefixV4)
|
||||
|
||||
changes := []routetable.OriginChange{
|
||||
{Prefix: prefix, OriginASN: asA, Announced: true, PeerCount: 1,
|
||||
Time: tableTime(10)},
|
||||
{Prefix: prefix, OriginASN: asA, Announced: false, PeerCount: 0,
|
||||
Time: tableTime(20)},
|
||||
{Prefix: prefix, OriginASN: asB, Announced: true, PeerCount: 1,
|
||||
Time: tableTime(30)},
|
||||
}
|
||||
|
||||
err := db.WriteOriginChanges(changes)
|
||||
if err != nil {
|
||||
t.Fatalf("WriteOriginChanges: %v", err)
|
||||
}
|
||||
|
||||
got, err := db.GetOriginChanges(t.Context(), prefix, 2)
|
||||
if err != nil {
|
||||
t.Fatalf("GetOriginChanges: %v", err)
|
||||
}
|
||||
|
||||
want := []routetable.OriginChange{
|
||||
{Prefix: prefix, OriginASN: asB, Announced: true, PeerCount: 1,
|
||||
Time: tableTime(30)},
|
||||
{Prefix: prefix, OriginASN: asA, Announced: false, PeerCount: 0,
|
||||
Time: tableTime(20)},
|
||||
}
|
||||
|
||||
if !reflect.DeepEqual(got, want) {
|
||||
t.Errorf("GetOriginChanges = %+v, want %+v", got, want)
|
||||
}
|
||||
}
|
||||
|
||||
// TestOriginChangesPrune checks that the prune keeps, for a prefix with more
|
||||
// than 500 rows, its newest 500 rows and every row newer than 72 hours, and
|
||||
// deletes the rest. It checks which rows survive by their times, not only how
|
||||
// many.
|
||||
func TestOriginChangesPrune(t *testing.T) {
|
||||
t.Parallel()
|
||||
|
||||
db := newRoutesTestDatabase(t)
|
||||
oldPrefix := netip.MustParsePrefix(tablePrefixV4)
|
||||
straddling := netip.MustParsePrefix(tablePrefixShortV4)
|
||||
busy := netip.MustParsePrefix(tablePrefixBusyV4)
|
||||
other := netip.MustParsePrefix("10.20.0.0/16")
|
||||
|
||||
// Whole seconds, so the stored times round-trip exactly.
|
||||
now := time.Now().Truncate(time.Second)
|
||||
|
||||
// 600 rows for oldPrefix, all older than 72 hours, oldest first. The
|
||||
// prune keeps the newest 500 and deletes the oldest 100.
|
||||
changes := rows(oldPrefix, now.Add(-100*time.Hour), 600)
|
||||
// 600 rows for straddling: 400 older than 72 hours, then 200 newer. The
|
||||
// prune keeps all 200 newer and the newest 300 of the 400 older.
|
||||
changes = append(changes, rows(straddling, now.Add(-100*time.Hour), 400)...)
|
||||
changes = append(changes, rows(straddling, now.Add(-71*time.Hour), 200)...)
|
||||
// 100 rows older than 72 hours and minOriginChangesPerPrefix+100 newer
|
||||
// rows for busy. The prune keeps all the newer rows and none of the older,
|
||||
// because the newer rows alone are more than minOriginChangesPerPrefix.
|
||||
changes = append(changes, rows(busy, now.Add(-100*time.Hour), 100)...)
|
||||
changes = append(changes, rows(busy, now.Add(-71*time.Hour),
|
||||
minOriginChangesPerPrefix+100)...)
|
||||
// One row for other, which the prune leaves alone.
|
||||
changes = append(changes, rows(other, now.Add(-100*time.Hour), 1)...)
|
||||
|
||||
err := db.WriteOriginChanges(changes)
|
||||
if err != nil {
|
||||
t.Fatalf("WriteOriginChanges: %v", err)
|
||||
}
|
||||
|
||||
err = db.PruneOriginChanges(t.Context())
|
||||
if err != nil {
|
||||
t.Fatalf("PruneOriginChanges: %v", err)
|
||||
}
|
||||
|
||||
// The newest row survives, and the oldest survivor is the 100th oldest,
|
||||
// so a prune that kept the oldest 500 instead would fail.
|
||||
checkSurvivors(t, db, oldPrefix, 500,
|
||||
now.Add(-100*time.Hour).Add(599*time.Minute),
|
||||
now.Add(-100*time.Hour).Add(100*time.Minute))
|
||||
|
||||
// The newest of the newer-than-72-hours rows survives, and the oldest
|
||||
// survivor is the 100th oldest of the older-than-72-hours rows.
|
||||
checkSurvivors(t, db, straddling, 500,
|
||||
now.Add(-71*time.Hour).Add(199*time.Minute),
|
||||
now.Add(-100*time.Hour).Add(100*time.Minute))
|
||||
|
||||
// Every newer-than-72-hours row survives, so the oldest survivor is the
|
||||
// first of them and the newest is minOriginChangesPerPrefix+99 minutes
|
||||
// after it.
|
||||
checkSurvivors(t, db, busy, minOriginChangesPerPrefix+100,
|
||||
now.Add(-71*time.Hour).
|
||||
Add(time.Duration(minOriginChangesPerPrefix+99)*time.Minute),
|
||||
now.Add(-71*time.Hour))
|
||||
|
||||
gotOther, err := db.GetOriginChanges(t.Context(), other, 10)
|
||||
if err != nil {
|
||||
t.Fatalf("GetOriginChanges: %v", err)
|
||||
}
|
||||
|
||||
if len(gotOther) != 1 {
|
||||
t.Errorf("GetOriginChanges(other) = %d rows, want 1", len(gotOther))
|
||||
}
|
||||
}
|
||||
|
||||
// rows returns n origin changes for prefix, at times from plus one minute per
|
||||
// step, oldest first.
|
||||
func rows(prefix netip.Prefix, from time.Time, n int) []routetable.OriginChange {
|
||||
changes := make([]routetable.OriginChange, 0, n)
|
||||
|
||||
for i := range n {
|
||||
changes = append(changes, routetable.OriginChange{
|
||||
Prefix: prefix, OriginASN: asA, Announced: true, PeerCount: 1,
|
||||
Time: from.Add(time.Duration(i) * time.Minute),
|
||||
})
|
||||
}
|
||||
|
||||
return changes
|
||||
}
|
||||
|
||||
// survivorTimes returns the times of prefix's rows after the prune, newest
|
||||
// first.
|
||||
func survivorTimes(
|
||||
t *testing.T, db *Database, prefix netip.Prefix, limit int,
|
||||
) []time.Time {
|
||||
t.Helper()
|
||||
|
||||
rows, err := db.GetOriginChanges(t.Context(), prefix, limit)
|
||||
if err != nil {
|
||||
t.Fatalf("GetOriginChanges: %v", err)
|
||||
}
|
||||
|
||||
times := make([]time.Time, len(rows))
|
||||
for i, row := range rows {
|
||||
times[i] = row.Time
|
||||
}
|
||||
|
||||
return times
|
||||
}
|
||||
|
||||
// checkSurvivors checks that prefix kept exactly wantCount rows, with the
|
||||
// newest survivor at wantNewest and the oldest at wantOldest.
|
||||
func checkSurvivors(
|
||||
t *testing.T, db *Database, prefix netip.Prefix,
|
||||
wantCount int, wantNewest, wantOldest time.Time,
|
||||
) {
|
||||
t.Helper()
|
||||
|
||||
times := survivorTimes(t, db, prefix, wantCount+1)
|
||||
if len(times) != wantCount {
|
||||
t.Errorf("GetOriginChanges(%s) = %d rows, want %d",
|
||||
prefix, len(times), wantCount)
|
||||
|
||||
return
|
||||
}
|
||||
|
||||
if !times[0].Equal(wantNewest) {
|
||||
t.Errorf("the newest surviving row's time = %v, want %v",
|
||||
times[0], wantNewest)
|
||||
}
|
||||
|
||||
if !times[wantCount-1].Equal(wantOldest) {
|
||||
t.Errorf("the oldest surviving row's time = %v, want %v",
|
||||
times[wantCount-1], wantOldest)
|
||||
}
|
||||
}
|
||||
|
||||
// TestOriginChangesSurviveRouteDeletion checks that deleting a routes row
|
||||
// leaves the prefix's origin_changes rows.
|
||||
func TestOriginChangesSurviveRouteDeletion(t *testing.T) {
|
||||
t.Parallel()
|
||||
|
||||
db := newRoutesTestDatabase(t)
|
||||
prefix := netip.MustParsePrefix(tablePrefixV4)
|
||||
|
||||
err := db.WriteOriginChanges([]routetable.OriginChange{{
|
||||
Prefix: prefix, OriginASN: asA, Announced: true, PeerCount: 1,
|
||||
Time: tableTime(10),
|
||||
}})
|
||||
if err != nil {
|
||||
t.Fatalf("WriteOriginChanges: %v", err)
|
||||
}
|
||||
|
||||
// Write a route, then delete it.
|
||||
table := routetable.New(routetable.Params{})
|
||||
announceTo(table, tablePrefixV4, asA, peerA, 10)
|
||||
writeTableChanges(t, db, table)
|
||||
|
||||
table.Withdraw(prefix, peerA)
|
||||
writeTableChanges(t, db, table)
|
||||
|
||||
got, err := db.GetOriginChanges(t.Context(), prefix, 10)
|
||||
if err != nil {
|
||||
t.Fatalf("GetOriginChanges: %v", err)
|
||||
}
|
||||
|
||||
if len(got) != 1 {
|
||||
t.Errorf("GetOriginChanges = %d rows, want 1", len(got))
|
||||
}
|
||||
}
|
||||
@@ -34,7 +34,6 @@ const (
|
||||
|
||||
tablePrefixV4 = "10.1.2.0/24"
|
||||
tablePrefixShortV4 = "10.9.0.0/16"
|
||||
tablePrefixBusyV4 = "10.10.0.0/16"
|
||||
tablePrefixV6 = "2001:db8:1::/48"
|
||||
)
|
||||
|
||||
|
||||
@@ -119,20 +119,4 @@ CREATE TABLE IF NOT EXISTS routes (
|
||||
CREATE TABLE IF NOT EXISTS route_peers (
|
||||
number INTEGER PRIMARY KEY,
|
||||
address TEXT NOT NULL UNIQUE
|
||||
);
|
||||
|
||||
-- The origin changes of the routing table: each time a prefix and origin AS
|
||||
-- gained its first peer or lost its last. The prefix handler writes them, and
|
||||
-- the database maintainer prunes each prefix to its newest 500 rows or its
|
||||
-- rows from the last 72 hours, whichever keeps more. time is whole seconds
|
||||
-- since 1970, UTC.
|
||||
CREATE TABLE IF NOT EXISTS origin_changes (
|
||||
id INTEGER PRIMARY KEY,
|
||||
prefix TEXT NOT NULL,
|
||||
origin_asn INTEGER NOT NULL,
|
||||
announced BOOLEAN NOT NULL,
|
||||
peer_count INTEGER NOT NULL,
|
||||
time INTEGER NOT NULL
|
||||
);
|
||||
|
||||
CREATE INDEX IF NOT EXISTS idx_origin_changes_prefix ON origin_changes(prefix);
|
||||
);
|
||||
@@ -1,103 +0,0 @@
|
||||
package routetable
|
||||
|
||||
import (
|
||||
"net/netip"
|
||||
"slices"
|
||||
"time"
|
||||
)
|
||||
|
||||
// MaxWaitingOriginChanges is the most origin changes the table keeps waiting
|
||||
// for the prefix handler to write. The oldest change past it is dropped and
|
||||
// counted.
|
||||
const MaxWaitingOriginChanges = 100000
|
||||
|
||||
// OriginChange is one change of a prefix and origin AS pair: the origin AS
|
||||
// gained its first peer, or lost its last.
|
||||
type OriginChange struct {
|
||||
Prefix netip.Prefix
|
||||
OriginASN int
|
||||
// Announced says the origin AS gained its first peer. When false, it
|
||||
// lost its last peer.
|
||||
Announced bool
|
||||
// PeerCount is how many peers carry the prefix just after the change,
|
||||
// counting every origin AS.
|
||||
PeerCount int
|
||||
// Time is when RouteWatch applied the change.
|
||||
Time time.Time
|
||||
}
|
||||
|
||||
// recordOriginChange records that the pair of prefix and asn gained its first
|
||||
// peer, when announced, or lost its last, when not. The caller holds the lock.
|
||||
// peerCount is how many peers carry the prefix just after the change.
|
||||
func (t *Table) recordOriginChange(
|
||||
prefix netip.Prefix, asn int, announced bool, peerCount int,
|
||||
) {
|
||||
change := OriginChange{
|
||||
Prefix: prefix,
|
||||
OriginASN: asn,
|
||||
Announced: announced,
|
||||
PeerCount: peerCount,
|
||||
Time: t.now(),
|
||||
}
|
||||
|
||||
t.originChanges = append(t.originChanges, change)
|
||||
t.trimOriginChanges()
|
||||
}
|
||||
|
||||
// TakeOriginChanges returns at most limit of the origin changes that wait to
|
||||
// be written, oldest first, and how many were dropped since the last call. It
|
||||
// then forgets what it returned.
|
||||
func (t *Table) TakeOriginChanges(limit int) ([]OriginChange, int) {
|
||||
t.mu.Lock()
|
||||
defer t.mu.Unlock()
|
||||
|
||||
n := min(limit, len(t.originChanges))
|
||||
changes := slices.Clone(t.originChanges[:n])
|
||||
t.originChanges = t.originChanges[n:]
|
||||
|
||||
dropped := t.originChangesDropped
|
||||
t.originChangesDropped = 0
|
||||
|
||||
return changes, dropped
|
||||
}
|
||||
|
||||
// PutBackOriginChanges records again what one TakeOriginChanges call returned,
|
||||
// for a caller that could not write it. The next TakeOriginChanges returns
|
||||
// those changes first, before the ones that arrived since. The oldest changes
|
||||
// past the cap are dropped and counted.
|
||||
func (t *Table) PutBackOriginChanges(changes []OriginChange) {
|
||||
t.mu.Lock()
|
||||
defer t.mu.Unlock()
|
||||
|
||||
t.originChanges = append(changes, t.originChanges...)
|
||||
t.trimOriginChanges()
|
||||
}
|
||||
|
||||
// trimOriginChanges drops the oldest origin changes past the cap and counts
|
||||
// them. The caller holds the lock.
|
||||
func (t *Table) trimOriginChanges() {
|
||||
if extra := len(t.originChanges) - MaxWaitingOriginChanges; extra > 0 {
|
||||
t.originChangesDropped += extra
|
||||
t.originChanges = t.originChanges[extra:]
|
||||
}
|
||||
}
|
||||
|
||||
// OriginChangeCount returns how many origin changes wait for TakeOriginChanges.
|
||||
func (t *Table) OriginChangeCount() int {
|
||||
t.mu.RLock()
|
||||
defer t.mu.RUnlock()
|
||||
|
||||
return len(t.originChanges)
|
||||
}
|
||||
|
||||
// prefixPeerCount returns how many peers carry prefix, counting every origin
|
||||
// AS. The caller holds the lock.
|
||||
func (t *Table) prefixPeerCount(prefix netip.Prefix) int {
|
||||
count := 0
|
||||
|
||||
for _, o := range t.origins(prefix) {
|
||||
count += int(o.peers.Count())
|
||||
}
|
||||
|
||||
return count
|
||||
}
|
||||
@@ -1,302 +0,0 @@
|
||||
package routetable_test
|
||||
|
||||
import (
|
||||
"math"
|
||||
"net/netip"
|
||||
"reflect"
|
||||
"testing"
|
||||
"time"
|
||||
|
||||
"github.com/bits-and-blooms/bitset"
|
||||
|
||||
"git.eeqj.de/sneak/routewatch/internal/routetable"
|
||||
)
|
||||
|
||||
// originChange returns the origin change the table records for prefix and asn
|
||||
// at the clock's time, announced or withdrawn, with peerCount peers.
|
||||
func originChange(
|
||||
prefix netip.Prefix, asn int, announced bool, peerCount int, at time.Time,
|
||||
) routetable.OriginChange {
|
||||
return routetable.OriginChange{
|
||||
Prefix: prefix,
|
||||
OriginASN: asn,
|
||||
Announced: announced,
|
||||
PeerCount: peerCount,
|
||||
Time: at,
|
||||
}
|
||||
}
|
||||
|
||||
// TestOriginChangesRecordAnnouncedAndWithdrawn checks that a prefix and origin
|
||||
// AS pair records an announced row when it gains its first peer, nothing for a
|
||||
// second peer, and a withdrawn row when it loses its last peer.
|
||||
func TestOriginChangesRecordAnnouncedAndWithdrawn(t *testing.T) {
|
||||
t.Parallel()
|
||||
|
||||
now := at(0)
|
||||
table := routetable.New(routetable.Params{
|
||||
Now: func() time.Time { return now },
|
||||
})
|
||||
prefix := netip.MustParsePrefix(prefixV4)
|
||||
|
||||
table.Announce(prefix, asA, routeOf(peerA, asA, 10))
|
||||
table.Announce(prefix, asA, routeOf(peerB, asA, 20))
|
||||
|
||||
checkOriginChanges(t, table, []routetable.OriginChange{
|
||||
originChange(prefix, asA, true, 1, now),
|
||||
})
|
||||
|
||||
table.Withdraw(prefix, peerA)
|
||||
table.Withdraw(prefix, peerB)
|
||||
|
||||
checkOriginChanges(t, table, []routetable.OriginChange{
|
||||
originChange(prefix, asA, false, 0, now),
|
||||
})
|
||||
}
|
||||
|
||||
// TestOriginChangesRecordAPeerMovingOrigin checks that a peer moving from one
|
||||
// origin AS to another records a withdrawn row for the old one and an
|
||||
// announced row for the new one.
|
||||
func TestOriginChangesRecordAPeerMovingOrigin(t *testing.T) {
|
||||
t.Parallel()
|
||||
|
||||
now := at(0)
|
||||
table := routetable.New(routetable.Params{
|
||||
Now: func() time.Time { return now },
|
||||
})
|
||||
prefix := netip.MustParsePrefix(prefixV4)
|
||||
|
||||
table.Announce(prefix, asA, routeOf(peerA, asA, 10))
|
||||
table.Announce(prefix, asB, routeOf(peerA, asB, 20))
|
||||
|
||||
checkOriginChanges(t, table, []routetable.OriginChange{
|
||||
originChange(prefix, asA, true, 1, now),
|
||||
originChange(prefix, asA, false, 0, now),
|
||||
originChange(prefix, asB, true, 1, now),
|
||||
})
|
||||
}
|
||||
|
||||
// TestOriginChangesRecordPeersDown checks that PeersDown records a withdrawn
|
||||
// row for each prefix and origin AS pair it empties.
|
||||
func TestOriginChangesRecordPeersDown(t *testing.T) {
|
||||
t.Parallel()
|
||||
|
||||
now := at(0)
|
||||
table := routetable.New(routetable.Params{
|
||||
Now: func() time.Time { return now },
|
||||
})
|
||||
v4 := netip.MustParsePrefix(prefixV4)
|
||||
v6 := netip.MustParsePrefix(prefixV6)
|
||||
|
||||
table.Announce(v4, asA, routeOf(peerA, asA, 10))
|
||||
table.Announce(v6, asA, routeOf(peerA, asA, 10))
|
||||
table.Announce(v4, asB, routeOf(peerB, asB, 20))
|
||||
|
||||
table.PeersDown([]string{peerA})
|
||||
|
||||
// peerA carried v4 and v6 with asA; both pairs are emptied. peerB still
|
||||
// carries v4 with asB, so that pair is not.
|
||||
checkOriginChanges(t, table, []routetable.OriginChange{
|
||||
originChange(v4, asA, true, 1, now),
|
||||
originChange(v6, asA, true, 1, now),
|
||||
originChange(v4, asB, true, 2, now),
|
||||
originChange(v4, asA, false, 1, now),
|
||||
originChange(v6, asA, false, 0, now),
|
||||
})
|
||||
}
|
||||
|
||||
// TestOriginChangesLoadRecordsNothing checks that Load records no origin
|
||||
// change.
|
||||
func TestOriginChangesLoadRecordsNothing(t *testing.T) {
|
||||
t.Parallel()
|
||||
|
||||
table := routetable.New(routetable.Params{
|
||||
PeerNumbers: map[string]uint{peerA: 0},
|
||||
})
|
||||
prefix := netip.MustParsePrefix(prefixV4)
|
||||
|
||||
peers := new(bitset.BitSet)
|
||||
peers.Set(0)
|
||||
|
||||
table.Load(routetable.Change{
|
||||
Prefix: prefix,
|
||||
OriginASN: asA,
|
||||
Peers: peers,
|
||||
Routes: []routetable.Route{routeOf(peerA, asA, 10)},
|
||||
})
|
||||
|
||||
changes, dropped := table.TakeOriginChanges(math.MaxInt)
|
||||
if dropped != 0 || len(changes) != 0 {
|
||||
t.Errorf("TakeOriginChanges = %+v, %d; want none", changes, dropped)
|
||||
}
|
||||
}
|
||||
|
||||
// TestOriginChangesTakeReturnsOldestFirst checks that TakeOriginChanges
|
||||
// returns the changes oldest first and at most max.
|
||||
func TestOriginChangesTakeReturnsOldestFirst(t *testing.T) {
|
||||
t.Parallel()
|
||||
|
||||
table := routetable.New(routetable.Params{})
|
||||
prefix := netip.MustParsePrefix(prefixV4)
|
||||
|
||||
table.Announce(prefix, asA, routeOf(peerA, asA, 10))
|
||||
table.Announce(prefix, asB, routeOf(peerB, asB, 20))
|
||||
table.Announce(prefix, asC, routeOf(peerC, asC, 30))
|
||||
|
||||
first, dropped := table.TakeOriginChanges(2)
|
||||
if dropped != 0 {
|
||||
t.Errorf("dropped = %d, want 0", dropped)
|
||||
}
|
||||
|
||||
if len(first) != 2 || first[0].OriginASN != asA || first[1].OriginASN != asB {
|
||||
t.Errorf("first TakeOriginChanges = %+v, want the first two", first)
|
||||
}
|
||||
|
||||
second, _ := table.TakeOriginChanges(math.MaxInt)
|
||||
if len(second) != 1 || second[0].OriginASN != asC {
|
||||
t.Errorf("second TakeOriginChanges = %+v, want the third", second)
|
||||
}
|
||||
}
|
||||
|
||||
// TestOriginChangesPutBackPutsRowsInFront checks that PutBackOriginChanges
|
||||
// puts rows back in front, so the next TakeOriginChanges returns them first.
|
||||
func TestOriginChangesPutBackPutsRowsInFront(t *testing.T) {
|
||||
t.Parallel()
|
||||
|
||||
table := routetable.New(routetable.Params{})
|
||||
prefix := netip.MustParsePrefix(prefixV4)
|
||||
|
||||
table.Announce(prefix, asA, routeOf(peerA, asA, 10))
|
||||
table.Announce(prefix, asB, routeOf(peerB, asB, 20))
|
||||
|
||||
taken, _ := table.TakeOriginChanges(math.MaxInt)
|
||||
table.Announce(prefix, asC, routeOf(peerC, asC, 30))
|
||||
table.PutBackOriginChanges(taken)
|
||||
|
||||
changes, _ := table.TakeOriginChanges(math.MaxInt)
|
||||
if len(changes) != 3 || changes[0].OriginASN != asA ||
|
||||
changes[1].OriginASN != asB || changes[2].OriginASN != asC {
|
||||
t.Errorf("TakeOriginChanges = %+v, want the put-back rows first", changes)
|
||||
}
|
||||
}
|
||||
|
||||
// TestOriginChangesDropPastTheLimit checks that a change past 100,000 waiting
|
||||
// rows is dropped and counted.
|
||||
func TestOriginChangesDropPastTheLimit(t *testing.T) {
|
||||
t.Parallel()
|
||||
|
||||
table := routetable.New(routetable.Params{})
|
||||
addr := netip.MustParseAddr("10.0.0.0")
|
||||
|
||||
for range routetable.MaxWaitingOriginChanges + 1 {
|
||||
prefix := netip.PrefixFrom(addr, 32)
|
||||
table.Announce(prefix, asA, routeOf(peerA, asA, 10))
|
||||
|
||||
addr = addr.Next()
|
||||
}
|
||||
|
||||
changes, dropped := table.TakeOriginChanges(routetable.MaxWaitingOriginChanges)
|
||||
if dropped != 1 {
|
||||
t.Errorf("dropped = %d, want 1", dropped)
|
||||
}
|
||||
|
||||
if len(changes) != routetable.MaxWaitingOriginChanges {
|
||||
t.Errorf("len(changes) = %d, want %d", len(changes),
|
||||
routetable.MaxWaitingOriginChanges)
|
||||
}
|
||||
}
|
||||
|
||||
// TestOriginChangesTakeResetsTheDroppedCount checks that a TakeOriginChanges
|
||||
// that reports dropped rows leaves the next one reporting none, so each drop
|
||||
// is logged once, not on every later write.
|
||||
func TestOriginChangesTakeResetsTheDroppedCount(t *testing.T) {
|
||||
t.Parallel()
|
||||
|
||||
table := routetable.New(routetable.Params{})
|
||||
addr := netip.MustParseAddr("10.0.0.0")
|
||||
|
||||
for range routetable.MaxWaitingOriginChanges + 1 {
|
||||
table.Announce(netip.PrefixFrom(addr, 32), asA, routeOf(peerA, asA, 10))
|
||||
addr = addr.Next()
|
||||
}
|
||||
|
||||
_, dropped := table.TakeOriginChanges(routetable.MaxWaitingOriginChanges)
|
||||
if dropped != 1 {
|
||||
t.Fatalf("dropped = %d, want 1", dropped)
|
||||
}
|
||||
|
||||
_, dropped = table.TakeOriginChanges(0)
|
||||
if dropped != 0 {
|
||||
t.Errorf("the next take's dropped = %d, want 0", dropped)
|
||||
}
|
||||
}
|
||||
|
||||
// TestOriginChangesPutBackTrimsToTheLimit checks that putting back what a
|
||||
// failed write took, after new changes filled the table again, drops the
|
||||
// oldest changes past the cap and counts them, so the cap still holds. The
|
||||
// clock advances one second per change, so a change's time says its age.
|
||||
func TestOriginChangesPutBackTrimsToTheLimit(t *testing.T) {
|
||||
t.Parallel()
|
||||
|
||||
const (
|
||||
taken = 20000
|
||||
added = 20000
|
||||
)
|
||||
|
||||
now := time.Unix(0, 0)
|
||||
table := routetable.New(routetable.Params{
|
||||
Now: func() time.Time {
|
||||
now = now.Add(time.Second)
|
||||
|
||||
return now
|
||||
},
|
||||
})
|
||||
addr := netip.MustParseAddr("10.0.0.0")
|
||||
|
||||
announce := func(n int) {
|
||||
for range n {
|
||||
table.Announce(netip.PrefixFrom(addr, 32), asA, routeOf(peerA, asA, 10))
|
||||
addr = addr.Next()
|
||||
}
|
||||
}
|
||||
|
||||
announce(routetable.MaxWaitingOriginChanges)
|
||||
|
||||
takenChanges, _ := table.TakeOriginChanges(taken)
|
||||
|
||||
announce(added)
|
||||
|
||||
table.PutBackOriginChanges(takenChanges)
|
||||
|
||||
changes, dropped := table.TakeOriginChanges(math.MaxInt)
|
||||
if dropped != added {
|
||||
t.Errorf("dropped = %d, want %d", dropped, added)
|
||||
}
|
||||
|
||||
if len(changes) != routetable.MaxWaitingOriginChanges {
|
||||
t.Errorf("len(changes) = %d, want %d", len(changes),
|
||||
routetable.MaxWaitingOriginChanges)
|
||||
}
|
||||
|
||||
// The put-back rows are the oldest, so they are the ones dropped. The
|
||||
// first remaining change is the one that followed them.
|
||||
if want := time.Unix(int64(added+1), 0); !changes[0].Time.Equal(want) {
|
||||
t.Errorf("first change's time = %v, want %v", changes[0].Time, want)
|
||||
}
|
||||
}
|
||||
|
||||
// checkOriginChanges checks that TakeOriginChanges, taking every change,
|
||||
// returns want.
|
||||
func checkOriginChanges(
|
||||
t *testing.T, table *routetable.Table, want []routetable.OriginChange,
|
||||
) {
|
||||
t.Helper()
|
||||
|
||||
changes, dropped := table.TakeOriginChanges(math.MaxInt)
|
||||
if dropped != 0 {
|
||||
t.Errorf("dropped = %d, want 0", dropped)
|
||||
}
|
||||
|
||||
if !reflect.DeepEqual(changes, want) {
|
||||
t.Errorf("TakeOriginChanges = %+v, want %+v", changes, want)
|
||||
}
|
||||
}
|
||||
@@ -2,9 +2,7 @@
|
||||
// and origin AS, it keeps the peers whose current route to the prefix has that
|
||||
// origin AS. It also keeps the two newest of those routes in full. It applies
|
||||
// announcements, withdrawals and peers' sessions going down. It answers the
|
||||
// route reads that the pages and the API need. It also records each prefix and
|
||||
// origin AS pair's origin changes: when it gains its first peer and when it
|
||||
// loses its last.
|
||||
// route reads that the pages and the API need.
|
||||
package routetable
|
||||
|
||||
import (
|
||||
@@ -93,9 +91,6 @@ type Params struct {
|
||||
// peer not in it gets the next number above all of them the first time it
|
||||
// announces a route.
|
||||
PeerNumbers map[string]uint
|
||||
// Now returns the time RouteWatch applies a change at. It is time.Now
|
||||
// unless a test gives one.
|
||||
Now func() time.Time
|
||||
}
|
||||
|
||||
// Table is the routing table. Its methods are safe for concurrent use.
|
||||
@@ -131,24 +126,11 @@ type Table struct {
|
||||
// originsWithoutKeptRoute counts the origins that peers carry but that
|
||||
// keep no route.
|
||||
originsWithoutKeptRoute int
|
||||
|
||||
// now returns the time RouteWatch applies a change at.
|
||||
now func() time.Time
|
||||
// originChanges holds the origin changes that wait to be written, oldest
|
||||
// first. originChangesDropped counts those dropped since the last
|
||||
// TakeOriginChanges.
|
||||
originChanges []OriginChange
|
||||
originChangesDropped int
|
||||
}
|
||||
|
||||
// New returns an empty table that numbers new peers on from
|
||||
// params.PeerNumbers.
|
||||
func New(params Params) *Table {
|
||||
now := params.Now
|
||||
if now == nil {
|
||||
now = time.Now
|
||||
}
|
||||
|
||||
t := &Table{
|
||||
ipv4: newFamily(ipv4Bits, minLookupMaskLengthV4),
|
||||
ipv6: newFamily(ipv6Bits, minLookupMaskLengthV6),
|
||||
@@ -157,7 +139,6 @@ func New(params Params) *Table {
|
||||
peerAddresses: make(map[uint]string, len(params.PeerNumbers)),
|
||||
newPeers: make(map[string]uint),
|
||||
changed: make(map[pair]struct{}),
|
||||
now: now,
|
||||
keptTimes: btree.NewG(keptTimesDegree, func(a, b keptTime) bool {
|
||||
return a.time.Before(b.time)
|
||||
}),
|
||||
@@ -287,9 +268,8 @@ func (t *Table) PeersDown(peers []string) {
|
||||
// Load puts one prefix and origin AS pair that the database holds into the
|
||||
// table, as startup does with each row it reads. The change's peers join the
|
||||
// pair's peer set, and its routes are kept as an announcement's would be.
|
||||
// Unlike an update, Load records no change and no origin change, so
|
||||
// TakeChanges does not hand the pair back to be written again. Loading a pair
|
||||
// twice changes nothing.
|
||||
// Unlike an update, Load records no change, so TakeChanges does not hand the
|
||||
// pair back to be written again. Loading a pair twice changes nothing.
|
||||
//
|
||||
// The caller makes sure that every peer change names, in its peer set or in
|
||||
// its routes, has a number in Params.PeerNumbers.
|
||||
@@ -480,7 +460,6 @@ func (t *Table) removeOrigin(prefix netip.Prefix, o *origin) {
|
||||
// r in full when it is one of the two newest routes of o. The peer's earlier
|
||||
// route, if o keeps one, is replaced: it is no longer the peer's current route.
|
||||
// The pair is recorded as changed only when its peer set or kept routes change.
|
||||
// When r is the origin's first peer, an announced origin change is recorded.
|
||||
func (t *Table) join(prefix netip.Prefix, o *origin, r route) {
|
||||
if slices.ContainsFunc(o.routes, r.equal) {
|
||||
// The peer announced its kept route again.
|
||||
@@ -490,8 +469,6 @@ func (t *Table) join(prefix netip.Prefix, o *origin, r route) {
|
||||
wasWithoutKeptRoute := o.withoutKeptRoute()
|
||||
|
||||
joined := !o.peers.Test(r.peer)
|
||||
|
||||
firstPeer := joined && o.peers.None()
|
||||
if joined {
|
||||
o.peers.Set(r.peer)
|
||||
|
||||
@@ -505,10 +482,6 @@ func (t *Table) join(prefix netip.Prefix, o *origin, r route) {
|
||||
if joined || dropped || kept {
|
||||
t.recordChange(prefix, o, wasWithoutKeptRoute)
|
||||
}
|
||||
|
||||
if firstPeer {
|
||||
t.recordOriginChange(prefix, o.asn, true, t.prefixPeerCount(prefix))
|
||||
}
|
||||
}
|
||||
|
||||
// leave takes peer out of the peer set of o, an origin of prefix, and drops
|
||||
@@ -567,8 +540,7 @@ func (t *Table) dropKeptRoute(o *origin, peer uint) bool {
|
||||
// recordChange records that the pair of prefix and the AS of o changed, and
|
||||
// brings the count of origins without a kept route up to date.
|
||||
// wasWithoutKeptRoute says whether o was such an origin before the change. An
|
||||
// origin that no peer carries any more is removed, and a withdrawn origin
|
||||
// change is recorded.
|
||||
// origin that no peer carries any more is removed.
|
||||
func (t *Table) recordChange(
|
||||
prefix netip.Prefix, o *origin, wasWithoutKeptRoute bool,
|
||||
) {
|
||||
@@ -577,7 +549,6 @@ func (t *Table) recordChange(
|
||||
t.countOriginWithoutKeptRoute(o, wasWithoutKeptRoute)
|
||||
|
||||
if o.peers.None() {
|
||||
t.recordOriginChange(prefix, o.asn, false, t.prefixPeerCount(prefix))
|
||||
t.removeOrigin(prefix, o)
|
||||
}
|
||||
}
|
||||
|
||||
@@ -330,23 +330,6 @@ func (m *mockStore) ReadRouteTable(_ context.Context) (*routetable.Table, error)
|
||||
return routetable.New(routetable.Params{}), nil
|
||||
}
|
||||
|
||||
// WriteOriginChanges records nothing: the mock keeps no origin changes.
|
||||
func (m *mockStore) WriteOriginChanges(_ []routetable.OriginChange) error {
|
||||
return nil
|
||||
}
|
||||
|
||||
// GetOriginChanges returns no origin changes.
|
||||
func (m *mockStore) GetOriginChanges(
|
||||
_ context.Context, _ netip.Prefix, _ int,
|
||||
) ([]routetable.OriginChange, error) {
|
||||
return nil, nil
|
||||
}
|
||||
|
||||
// PruneOriginChanges does nothing.
|
||||
func (m *mockStore) PruneOriginChanges(_ context.Context) error {
|
||||
return nil
|
||||
}
|
||||
|
||||
// GetOrCreateASNBatch mock implementation
|
||||
func (m *mockStore) GetOrCreateASNBatch(asns map[int]database.SeenTimes) error {
|
||||
m.mu.Lock()
|
||||
|
||||
@@ -175,13 +175,12 @@ func (s *blockingStore) releaseWrites() {
|
||||
//
|
||||
//nolint:tagliatelle // field names are the keys the handlers log
|
||||
type stopLog struct {
|
||||
Msg string `json:"msg"`
|
||||
Updates int `json:"updates"`
|
||||
TableChanges int `json:"table_changes"`
|
||||
HeldMessages int `json:"held_messages"`
|
||||
OriginChanges int `json:"origin_changes"`
|
||||
Paths int `json:"paths"`
|
||||
BatchEntries int `json:"batch_entries"`
|
||||
Msg string `json:"msg"`
|
||||
Updates int `json:"updates"`
|
||||
TableChanges int `json:"table_changes"`
|
||||
HeldMessages int `json:"held_messages"`
|
||||
Paths int `json:"paths"`
|
||||
BatchEntries int `json:"batch_entries"`
|
||||
}
|
||||
|
||||
// newErrorLogger returns a logger that writes only errors, as JSON lines, to
|
||||
@@ -473,42 +472,6 @@ func (s tableWriteBlockingStore) WriteRouteChanges(
|
||||
return s.mockStore.WriteRouteChanges(changes, newPeers)
|
||||
}
|
||||
|
||||
// stopPrefixHandlerWithBlockedWrite stops the prefix handler, whose store
|
||||
// holds the write that fill starts, after handing it the message extra, and
|
||||
// returns what Stop logged. blocking is the store the write waits on; store is
|
||||
// a blockingStore wrapped for the routing table's changes or the origin
|
||||
// changes.
|
||||
func stopPrefixHandlerWithBlockedWrite(
|
||||
t *testing.T,
|
||||
blocking *blockingStore,
|
||||
store database.Store,
|
||||
logs *bytes.Buffer,
|
||||
fill, extra *ristypes.RISMessage,
|
||||
) stopLog {
|
||||
t.Helper()
|
||||
|
||||
h := NewPrefixHandler(store, newErrorLogger(logs),
|
||||
routetable.New(routetable.Params{}))
|
||||
stopWhileAWriteIsBlocked(t, blocking, h, h.done,
|
||||
[]*ristypes.RISMessage{fill}, extra)
|
||||
|
||||
return lastLogged(t, logs)
|
||||
}
|
||||
|
||||
// originChangesBlockingStore is a blockingStore whose writes of the origin
|
||||
// changes also wait until the test calls releaseWrites.
|
||||
type originChangesBlockingStore struct {
|
||||
*blockingStore
|
||||
}
|
||||
|
||||
func (s originChangesBlockingStore) WriteOriginChanges(
|
||||
changes []routetable.OriginChange,
|
||||
) error {
|
||||
s.waitForRelease()
|
||||
|
||||
return s.mockStore.WriteOriginChanges(changes)
|
||||
}
|
||||
|
||||
// TestPrefixHandlerStopCountsTheTableChangesOfAWriteInProgress holds the write
|
||||
// of the routing table's changes that a full batch starts, then hands the
|
||||
// prefix handler one more prefix and stops it with a deadline that passes
|
||||
@@ -522,67 +485,19 @@ func TestPrefixHandlerStopCountsTheTableChangesOfAWriteInProgress(t *testing.T)
|
||||
var logs bytes.Buffer
|
||||
|
||||
blocking := newBlockingStore()
|
||||
h := NewPrefixHandler(tableWriteBlockingStore{blockingStore: blocking},
|
||||
newErrorLogger(&logs), routetable.New(routetable.Params{}))
|
||||
fill := slices.Repeat([]string{testV4Prefix}, prefixBatchSize)
|
||||
logged := stopPrefixHandlerWithBlockedWrite(t, blocking,
|
||||
tableWriteBlockingStore{blockingStore: blocking}, &logs,
|
||||
prefixAnnouncement(fill), prefixAnnouncement([]string{extraPrefix}))
|
||||
stopWhileAWriteIsBlocked(t, blocking, h, h.done,
|
||||
[]*ristypes.RISMessage{prefixAnnouncement(fill)},
|
||||
prefixAnnouncement([]string{extraPrefix}))
|
||||
|
||||
if logged.TableChanges != 2 {
|
||||
if logged := lastLogged(t, &logs); logged.TableChanges != 2 {
|
||||
t.Errorf("Stop logged %d table changes not written, want 2",
|
||||
logged.TableChanges)
|
||||
}
|
||||
}
|
||||
|
||||
// TestPrefixHandlerStopCountsTheOriginChangesOfAWriteInProgress holds the
|
||||
// write of the origin changes that a full batch starts, then hands the prefix
|
||||
// handler one more prefix and stops it with a deadline that passes meanwhile.
|
||||
// Stop must log as not written both the change the held write took and the one
|
||||
// since.
|
||||
func TestPrefixHandlerStopCountsTheOriginChangesOfAWriteInProgress(t *testing.T) {
|
||||
t.Parallel()
|
||||
|
||||
const extraPrefix = "198.51.100.0/24"
|
||||
|
||||
var logs bytes.Buffer
|
||||
|
||||
blocking := newBlockingStore()
|
||||
fill := slices.Repeat([]string{testV4Prefix}, prefixBatchSize)
|
||||
logged := stopPrefixHandlerWithBlockedWrite(t, blocking,
|
||||
originChangesBlockingStore{blockingStore: blocking}, &logs,
|
||||
prefixAnnouncement(fill), prefixAnnouncement([]string{extraPrefix}))
|
||||
|
||||
if logged.OriginChanges != 2 {
|
||||
t.Errorf("Stop logged %d origin changes not written, want 2",
|
||||
logged.OriginChanges)
|
||||
}
|
||||
}
|
||||
|
||||
// TestPrefixHandlerStopCountsTheWaitingOriginChanges stops the prefix handler
|
||||
// with a deadline that has already passed, so the flush goroutine skips its
|
||||
// last write. The origin changes still waiting in the routing table are then
|
||||
// not written, and Stop must log them.
|
||||
func TestPrefixHandlerStopCountsTheWaitingOriginChanges(t *testing.T) {
|
||||
t.Parallel()
|
||||
|
||||
var logs bytes.Buffer
|
||||
|
||||
store := newMockStore()
|
||||
h := newPrefixHandler(store, newErrorLogger(&logs),
|
||||
routetable.New(routetable.Params{}), longerThanAnyTest,
|
||||
maxTableChangesPerWrite)
|
||||
|
||||
h.HandleMessage(peerAnnouncement(testPeerIP, testV4Prefix, testV6Prefix))
|
||||
|
||||
ctx, cancel := context.WithCancel(t.Context())
|
||||
cancel()
|
||||
h.Stop(ctx)
|
||||
|
||||
if logged := lastLogged(t, &logs); logged.OriginChanges != 2 {
|
||||
t.Errorf("Stop logged %d origin changes not written, want 2",
|
||||
logged.OriginChanges)
|
||||
}
|
||||
}
|
||||
|
||||
// TestASHandlerSkipsItsLastWriteAfterTheStopDeadline also checks what Stop
|
||||
// logs: the asnBatchSize entries of the held write and the entry for testASNB,
|
||||
// handled since, are not written.
|
||||
|
||||
@@ -25,10 +25,6 @@ const (
|
||||
// analyzeInterval is how often to run ANALYZE.
|
||||
analyzeInterval = 1 * time.Hour
|
||||
|
||||
// originChangesPruneInterval is how often to prune the origin_changes
|
||||
// table.
|
||||
originChangesPruneInterval = 1 * time.Hour
|
||||
|
||||
// checkpointTimeout is the max time for WAL checkpoint.
|
||||
checkpointTimeout = 10 * time.Second
|
||||
|
||||
@@ -37,9 +33,6 @@ const (
|
||||
|
||||
// analyzeTimeout is the max time for ANALYZE.
|
||||
analyzeTimeout = 5 * time.Minute
|
||||
|
||||
// originChangesPruneTimeout is the max time for the origin changes prune.
|
||||
originChangesPruneTimeout = 5 * time.Minute
|
||||
)
|
||||
|
||||
// checkpointIncompleteMessage is logged, at debug level like a completed
|
||||
@@ -87,7 +80,6 @@ func (m *DBMaintainer) Start(ctx context.Context) {
|
||||
"checkpoint_interval", checkpointInterval,
|
||||
"vacuum_interval", vacuumInterval,
|
||||
"analyze_interval", analyzeInterval,
|
||||
"origin_changes_prune_interval", originChangesPruneInterval,
|
||||
)
|
||||
}
|
||||
|
||||
@@ -119,9 +111,6 @@ func (m *DBMaintainer) run(ctx context.Context) {
|
||||
analyzeTimer := time.NewTimer(analyzeInterval)
|
||||
defer analyzeTimer.Stop()
|
||||
|
||||
pruneTimer := time.NewTimer(originChangesPruneInterval)
|
||||
defer pruneTimer.Stop()
|
||||
|
||||
for {
|
||||
select {
|
||||
case <-m.stopCh:
|
||||
@@ -138,10 +127,6 @@ func (m *DBMaintainer) run(ctx context.Context) {
|
||||
case <-analyzeTimer.C:
|
||||
m.runAnalyze(ctx)
|
||||
analyzeTimer.Reset(analyzeInterval)
|
||||
|
||||
case <-pruneTimer.C:
|
||||
m.runPruneOriginChanges(ctx)
|
||||
pruneTimer.Reset(originChangesPruneInterval)
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -190,18 +175,6 @@ func (m *DBMaintainer) runAnalyze(ctx context.Context) {
|
||||
}
|
||||
}
|
||||
|
||||
// runPruneOriginChanges prunes the origin_changes table.
|
||||
func (m *DBMaintainer) runPruneOriginChanges(ctx context.Context) {
|
||||
duration, err := runWithTimeout(ctx, originChangesPruneTimeout,
|
||||
m.db.PruneOriginChanges)
|
||||
if err != nil {
|
||||
m.logger.Error("Origin changes prune failed", "error", err,
|
||||
"duration", duration)
|
||||
} else {
|
||||
m.logger.Debug("Origin changes pruned", "duration", duration)
|
||||
}
|
||||
}
|
||||
|
||||
// runWithTimeout runs operation with a context that ends after timeout and
|
||||
// returns how long it took and its error.
|
||||
func runWithTimeout(
|
||||
|
||||
@@ -15,15 +15,12 @@ import (
|
||||
)
|
||||
|
||||
const (
|
||||
// prefixHandlerQueueSize is the most messages the handler's queue holds.
|
||||
// While the routing table's Overview or PeersDown walks every prefix, it
|
||||
// holds the table's lock about half of the time. The handler then applies
|
||||
// updates more slowly. When the feed pauses for some seconds and then
|
||||
// catches up, its backlog can arrive faster than that, and the queue
|
||||
// holds the backlog. The streamer drops an update that finds the queue
|
||||
// full. A message takes about 1 KiB, so a full queue takes about 100 MiB
|
||||
// (README "Memory").
|
||||
prefixHandlerQueueSize = 100000
|
||||
// prefixHandlerQueueSize is the queue capacity for prefix tracking
|
||||
// operations, about 4 seconds of feed at peak. The streamer drops updates
|
||||
// rather than blocks when a queue is full (a STATE message is held until
|
||||
// there is room), so this bounds memory. Batches still flush on a timer
|
||||
// (prefixBatchTimeout).
|
||||
prefixHandlerQueueSize = 20000
|
||||
|
||||
// prefixBatchSize is the number of prefix updates to batch together
|
||||
prefixBatchSize = 25000
|
||||
@@ -48,10 +45,6 @@ const (
|
||||
// going down changes are written in about a minute.
|
||||
maxTableChangesPerWrite = 20000
|
||||
|
||||
// maxOriginChangesPerWrite is the most origin changes of the routing
|
||||
// table that one flush writes; the rest wait for the next flushes.
|
||||
maxOriginChangesPerWrite = 20000
|
||||
|
||||
// maxHeldBackMessages is the most messages the handler holds back from
|
||||
// peers whose session went down. A peer's messages are held back from
|
||||
// the moment its session goes down until peerDown has applied them. If
|
||||
@@ -80,13 +73,12 @@ const (
|
||||
// at a time. The next one takes every peer whose session went down since the
|
||||
// previous one began. PeersDown lets the table's lock go about half of the
|
||||
// time, so the handler applies other peers' messages while PeersDown runs. The
|
||||
// handler holds back a down peer's later messages until peerDown applies them,
|
||||
// as the doc of maxHeldBackMessages describes. It applies them in order, one at
|
||||
// a time, and takes new messages in between. It holds back at most
|
||||
// maxHeldBackMessages messages.
|
||||
// handler holds back a down peer's later messages until the peer has left every
|
||||
// prefix. Then the handler applies them in order, one at a time, and takes new
|
||||
// messages in between. It holds back at most maxHeldBackMessages messages.
|
||||
//
|
||||
// Each flush writes the table's changes and origin changes to the database.
|
||||
// It also stores each prefix the updates name with the time it was first seen.
|
||||
// Each flush writes the table's changes to the database. It also stores each
|
||||
// prefix the updates name with the time it was first seen.
|
||||
type PrefixHandler struct {
|
||||
db database.Store
|
||||
logger *logger.Logger
|
||||
@@ -99,14 +91,11 @@ type PrefixHandler struct {
|
||||
// tableChangesPerWrite is maxTableChangesPerWrite, except in tests that
|
||||
// give a smaller one.
|
||||
tableChangesPerWrite int
|
||||
// originChangesPerWrite is maxOriginChangesPerWrite, except in tests that
|
||||
// give a smaller one.
|
||||
originChangesPerWrite int
|
||||
|
||||
// Batching. mu guards batch, writing, writingTableChanges and
|
||||
// writingOriginChanges: the flush goroutine takes them under mu and
|
||||
// writes them after releasing mu, so HandleMessage waits for a database
|
||||
// write only while batch is at batchMaxSize.
|
||||
// Batching. mu guards batch, writing and writingTableChanges: the
|
||||
// flush goroutine takes them under mu and writes them after releasing
|
||||
// mu, so HandleMessage waits for a database write only while batch is at
|
||||
// batchMaxSize.
|
||||
mu sync.Mutex
|
||||
batch []seenPrefix
|
||||
// writing is how many updates the flush goroutine took and has not
|
||||
@@ -115,9 +104,6 @@ type PrefixHandler struct {
|
||||
// writingTableChanges is how many changes the flush goroutine took from
|
||||
// the routing table and has not finished writing.
|
||||
writingTableChanges int
|
||||
// writingOriginChanges is how many origin changes the flush goroutine
|
||||
// took from the routing table and has not finished writing.
|
||||
writingOriginChanges int
|
||||
// batchTaken is signalled when the flush goroutine takes batch; its L is
|
||||
// &mu.
|
||||
batchTaken sync.Cond
|
||||
@@ -200,18 +186,17 @@ func newPrefixHandler(
|
||||
batchTimeout time.Duration, tableChangesPerWrite int,
|
||||
) *PrefixHandler {
|
||||
h := &PrefixHandler{
|
||||
db: db,
|
||||
logger: logger,
|
||||
table: table,
|
||||
batch: make([]seenPrefix, 0, prefixBatchSize),
|
||||
batchMaxSize: prefixBatchMaxSize,
|
||||
tableChangesPerWrite: tableChangesPerWrite,
|
||||
originChangesPerWrite: maxOriginChangesPerWrite,
|
||||
batchFullCh: make(chan struct{}, 1),
|
||||
stopCh: make(chan context.Context, 1),
|
||||
done: make(chan struct{}),
|
||||
heldBack: make(map[string][]*ristypes.RISMessage),
|
||||
tablePeersDown: table.PeersDown,
|
||||
db: db,
|
||||
logger: logger,
|
||||
table: table,
|
||||
batch: make([]seenPrefix, 0, prefixBatchSize),
|
||||
batchMaxSize: prefixBatchMaxSize,
|
||||
tableChangesPerWrite: tableChangesPerWrite,
|
||||
batchFullCh: make(chan struct{}, 1),
|
||||
stopCh: make(chan context.Context, 1),
|
||||
done: make(chan struct{}),
|
||||
heldBack: make(map[string][]*ristypes.RISMessage),
|
||||
tablePeersDown: table.PeersDown,
|
||||
}
|
||||
h.batchTaken.L = &h.mu
|
||||
h.heldTaken.L = &h.mu
|
||||
@@ -243,7 +228,8 @@ func (h *PrefixHandler) QueueCapacity() int {
|
||||
}
|
||||
|
||||
// HandleMessage processes a message to track prefix information. A message
|
||||
// from a peer whose session went down is held back until peerDown applies it.
|
||||
// from a peer whose session went down is held back until the peer has left
|
||||
// every prefix.
|
||||
func (h *PrefixHandler) HandleMessage(msg *ristypes.RISMessage) {
|
||||
h.mu.Lock()
|
||||
defer h.mu.Unlock()
|
||||
@@ -279,13 +265,13 @@ func (h *PrefixHandler) HeldBackCount() int {
|
||||
// back meanwhile to be applied. It gives up this wait once ctx ends. Then Stop
|
||||
// stops the flush goroutine and waits for it until ctx ends. The flush
|
||||
// goroutine makes one last flush before it returns. That flush writes at most
|
||||
// tableChangesPerWrite of the routing table's changes, originChangesPerWrite of
|
||||
// its origin changes, and the prefixes of the updates the handler holds. Once
|
||||
// ctx has ended the flush goroutine skips that last flush, and a write still
|
||||
// running is lost when the process exits. A failed write of the table's
|
||||
// changes is not retried either. Stop logs how many updates, table changes and
|
||||
// origin changes are not written. It also logs how many held-back messages are
|
||||
// not applied. The caller calls Stop once its last HandleMessage has returned.
|
||||
// tableChangesPerWrite of the routing table's changes, and the prefixes of the
|
||||
// updates the handler holds. Once ctx has ended the flush goroutine skips that
|
||||
// last flush, and a write still running is lost when the process exits. A
|
||||
// failed write of the table's changes is not retried either. Stop logs how
|
||||
// many updates and table changes are not written. It also logs how many
|
||||
// held-back messages are not applied. The caller calls Stop once its last
|
||||
// HandleMessage has returned.
|
||||
func (h *PrefixHandler) Stop(ctx context.Context) {
|
||||
peerDownsDone := make(chan struct{})
|
||||
|
||||
@@ -310,25 +296,23 @@ func (h *PrefixHandler) Stop(ctx context.Context) {
|
||||
unwritten := h.writing + len(h.batch)
|
||||
tableChanges := h.writingTableChanges + h.table.ChangeCount()
|
||||
heldMessages := h.heldCount
|
||||
originChanges := h.writingOriginChanges + h.table.OriginChangeCount()
|
||||
h.mu.Unlock()
|
||||
|
||||
if unwritten == 0 && tableChanges == 0 && heldMessages == 0 &&
|
||||
originChanges == 0 {
|
||||
if unwritten == 0 && tableChanges == 0 && heldMessages == 0 {
|
||||
return
|
||||
}
|
||||
|
||||
if ctx.Err() != nil {
|
||||
h.logger.Error("Stop deadline passed before the prefix handler wrote "+
|
||||
"its updates", "updates", unwritten, "table_changes", tableChanges,
|
||||
"held_messages", heldMessages, "origin_changes", originChanges)
|
||||
"held_messages", heldMessages)
|
||||
|
||||
return
|
||||
}
|
||||
|
||||
h.logger.Error("The prefix handler stopped before it wrote everything",
|
||||
"updates", unwritten, "table_changes", tableChanges,
|
||||
"held_messages", heldMessages, "origin_changes", originChanges)
|
||||
"held_messages", heldMessages)
|
||||
}
|
||||
|
||||
// applyMessage applies msg. The caller holds mu. A peer's session going down
|
||||
@@ -515,12 +499,11 @@ func (h *PrefixHandler) takeBatch() []seenPrefix {
|
||||
return batch
|
||||
}
|
||||
|
||||
// flushBatch writes the routing table's changes and origin changes, then
|
||||
// takes the pending batch and stores the prefixes it names, without holding
|
||||
// the mutex during the writes.
|
||||
// flushBatch writes the routing table's changes, then takes the pending batch
|
||||
// and stores the prefixes it names, without holding the mutex during the
|
||||
// writes.
|
||||
func (h *PrefixHandler) flushBatch() {
|
||||
h.writeTableChanges()
|
||||
h.writeOriginChanges()
|
||||
|
||||
batch := h.takeBatch()
|
||||
if len(batch) == 0 {
|
||||
@@ -622,39 +605,6 @@ func (h *PrefixHandler) writeTableChanges() {
|
||||
}
|
||||
}
|
||||
|
||||
// writeOriginChanges writes at most originChangesPerWrite of the routing
|
||||
// table's origin changes. When the write fails, they go back to the table, so
|
||||
// that a later write writes them again. A dropped change is logged as a
|
||||
// warning.
|
||||
func (h *PrefixHandler) writeOriginChanges() {
|
||||
h.mu.Lock()
|
||||
changes, dropped := h.table.TakeOriginChanges(h.originChangesPerWrite)
|
||||
h.writingOriginChanges = len(changes)
|
||||
h.mu.Unlock()
|
||||
|
||||
if dropped > 0 {
|
||||
h.logger.Warn("Origin changes dropped", "dropped", dropped)
|
||||
}
|
||||
|
||||
if len(changes) == 0 {
|
||||
return
|
||||
}
|
||||
|
||||
err := h.db.WriteOriginChanges(changes)
|
||||
|
||||
h.mu.Lock()
|
||||
defer h.mu.Unlock()
|
||||
|
||||
h.writingOriginChanges = 0
|
||||
|
||||
if err != nil {
|
||||
h.logger.Error("Failed to write the origin changes; the next flush "+
|
||||
"retries", "changes", len(changes), "error", err)
|
||||
|
||||
h.table.PutBackOriginChanges(changes)
|
||||
}
|
||||
}
|
||||
|
||||
// canonicalPrefix returns prefix in the text form net/netip prints, the form
|
||||
// the prefix tables store and the IP lookup reads them in. The feed sends IPv6
|
||||
// announcements compressed ("2001:db8::/32") but IPv6 withdrawals uncompressed
|
||||
|
||||
@@ -327,14 +327,13 @@ func prefixHandlerWithoutTimer(store database.Store) *PrefixHandler {
|
||||
table := routetable.New(routetable.Params{})
|
||||
|
||||
return &PrefixHandler{
|
||||
db: store,
|
||||
logger: logger.New(),
|
||||
table: table,
|
||||
batchMaxSize: prefixBatchMaxSize,
|
||||
tableChangesPerWrite: maxTableChangesPerWrite,
|
||||
originChangesPerWrite: maxOriginChangesPerWrite,
|
||||
heldBack: make(map[string][]*ristypes.RISMessage),
|
||||
tablePeersDown: table.PeersDown,
|
||||
db: store,
|
||||
logger: logger.New(),
|
||||
table: table,
|
||||
batchMaxSize: prefixBatchMaxSize,
|
||||
tableChangesPerWrite: maxTableChangesPerWrite,
|
||||
heldBack: make(map[string][]*ristypes.RISMessage),
|
||||
tablePeersDown: table.PeersDown,
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
@@ -1,181 +0,0 @@
|
||||
package routewatch
|
||||
|
||||
import (
|
||||
"bytes"
|
||||
"encoding/json"
|
||||
"errors"
|
||||
"log/slog"
|
||||
"net/netip"
|
||||
"slices"
|
||||
"testing"
|
||||
|
||||
"git.eeqj.de/sneak/routewatch/internal/database"
|
||||
"git.eeqj.de/sneak/routewatch/internal/logger"
|
||||
"git.eeqj.de/sneak/routewatch/internal/routetable"
|
||||
)
|
||||
|
||||
// TestPrefixHandlerWritesOriginChanges hands a running prefix handler an
|
||||
// announcement and flushes. The flush must write the origin change to the
|
||||
// database.
|
||||
func TestPrefixHandlerWritesOriginChanges(t *testing.T) {
|
||||
t.Parallel()
|
||||
|
||||
db := newTestDatabase(t)
|
||||
h := prefixHandlerWithoutTimer(db)
|
||||
|
||||
h.HandleMessage(peerAnnouncement(testPeerIP, testV4Prefix))
|
||||
h.flushBatch()
|
||||
|
||||
got, err := db.GetOriginChanges(t.Context(),
|
||||
netip.MustParsePrefix(testV4Prefix), 10)
|
||||
if err != nil {
|
||||
t.Fatalf("GetOriginChanges: %v", err)
|
||||
}
|
||||
|
||||
if len(got) != 1 || !got[0].Announced || got[0].OriginASN != testASNB {
|
||||
t.Errorf("GetOriginChanges = %+v, want one announced row for AS%d",
|
||||
got, testASNB)
|
||||
}
|
||||
}
|
||||
|
||||
// errTestOriginChangeWrite is the error a test store's failing write of the
|
||||
// origin changes returns.
|
||||
var errTestOriginChangeWrite = errors.New(
|
||||
"test: the write of the origin changes failed")
|
||||
|
||||
// originChangesFailsStore is a real database whose first write of the origin
|
||||
// changes fails, writing nothing. writes counts the writes asked for.
|
||||
type originChangesFailsStore struct {
|
||||
*database.Database
|
||||
|
||||
writes int
|
||||
}
|
||||
|
||||
func (s *originChangesFailsStore) WriteOriginChanges(
|
||||
changes []routetable.OriginChange,
|
||||
) error {
|
||||
s.writes++
|
||||
if s.writes == 1 {
|
||||
return errTestOriginChangeWrite
|
||||
}
|
||||
|
||||
return s.Database.WriteOriginChanges(changes)
|
||||
}
|
||||
|
||||
// TestPrefixHandlerWritesAFailedOriginChangeWriteAgain runs two flushes into a
|
||||
// database whose first write of the origin changes fails. The second write must
|
||||
// hold the change of the first.
|
||||
func TestPrefixHandlerWritesAFailedOriginChangeWriteAgain(t *testing.T) {
|
||||
t.Parallel()
|
||||
|
||||
db := newTestDatabase(t)
|
||||
store := &originChangesFailsStore{Database: db}
|
||||
h := prefixHandlerWithoutTimer(store)
|
||||
|
||||
h.HandleMessage(peerAnnouncement(testPeerIP, testV4Prefix))
|
||||
h.flushBatch()
|
||||
h.flushBatch()
|
||||
|
||||
got, err := db.GetOriginChanges(t.Context(),
|
||||
netip.MustParsePrefix(testV4Prefix), 10)
|
||||
if err != nil {
|
||||
t.Fatalf("GetOriginChanges: %v", err)
|
||||
}
|
||||
|
||||
if len(got) != 1 || !got[0].Announced || got[0].OriginASN != testASNB {
|
||||
t.Errorf("GetOriginChanges = %+v, want one announced row for AS%d",
|
||||
got, testASNB)
|
||||
}
|
||||
}
|
||||
|
||||
// originChangesWriteSizesStore is a real database that records how many
|
||||
// changes each write of the origin changes holds.
|
||||
type originChangesWriteSizesStore struct {
|
||||
*database.Database
|
||||
|
||||
counts []int
|
||||
}
|
||||
|
||||
func (s *originChangesWriteSizesStore) WriteOriginChanges(
|
||||
changes []routetable.OriginChange,
|
||||
) error {
|
||||
s.counts = append(s.counts, len(changes))
|
||||
|
||||
return s.Database.WriteOriginChanges(changes)
|
||||
}
|
||||
|
||||
// TestPrefixHandlerWritesManyOriginChangesOverSeveralFlushes has more origin
|
||||
// changes than one write takes, then flushes three times. The first write must
|
||||
// hold one write's worth, the second the rest, and the third nothing. The
|
||||
// handler's limit is small.
|
||||
func TestPrefixHandlerWritesManyOriginChangesOverSeveralFlushes(t *testing.T) {
|
||||
t.Parallel()
|
||||
|
||||
const perWrite = 10
|
||||
|
||||
db := newTestDatabase(t)
|
||||
store := &originChangesWriteSizesStore{Database: db}
|
||||
h := prefixHandlerWithoutTimer(store)
|
||||
h.originChangesPerWrite = perWrite
|
||||
|
||||
announceManyPrefixes(h.table, perWrite*3/2)
|
||||
|
||||
h.flushBatch()
|
||||
h.flushBatch()
|
||||
h.flushBatch()
|
||||
|
||||
want := []int{perWrite, perWrite*3/2 - perWrite}
|
||||
if !slices.Equal(store.counts, want) {
|
||||
t.Errorf("WriteOriginChanges held %v changes, want %v", store.counts, want)
|
||||
}
|
||||
}
|
||||
|
||||
// TestPrefixHandlerLogsTheDroppedOriginChanges fills the routing table with
|
||||
// one origin change more than it keeps, then flushes. The warning the flush
|
||||
// logs must carry the dropped count.
|
||||
func TestPrefixHandlerLogsTheDroppedOriginChanges(t *testing.T) {
|
||||
t.Parallel()
|
||||
|
||||
var logs bytes.Buffer
|
||||
|
||||
db := newTestDatabase(t)
|
||||
h := prefixHandlerWithoutTimer(db)
|
||||
h.logger = &logger.Logger{
|
||||
Logger: slog.New(slog.NewJSONHandler(&logs,
|
||||
&slog.HandlerOptions{Level: slog.LevelWarn})),
|
||||
}
|
||||
|
||||
announceManyPrefixes(h.table, routetable.MaxWaitingOriginChanges+1)
|
||||
|
||||
h.flushBatch()
|
||||
|
||||
var warning struct {
|
||||
Msg string `json:"msg"`
|
||||
Dropped *int `json:"dropped"`
|
||||
}
|
||||
|
||||
found := false
|
||||
|
||||
for line := range bytes.SplitSeq(bytes.TrimSpace(logs.Bytes()), []byte("\n")) {
|
||||
warning.Dropped = nil
|
||||
|
||||
err := json.Unmarshal(line, &warning)
|
||||
if err != nil {
|
||||
t.Fatalf("want a JSON log line, got %q: %v", line, err)
|
||||
}
|
||||
|
||||
if warning.Msg != "Origin changes dropped" {
|
||||
continue
|
||||
}
|
||||
|
||||
found = true
|
||||
|
||||
if warning.Dropped == nil || *warning.Dropped != 1 {
|
||||
t.Errorf("the warning's dropped = %v, want 1", warning.Dropped)
|
||||
}
|
||||
}
|
||||
|
||||
if !found {
|
||||
t.Errorf("no warning logged the dropped origin changes")
|
||||
}
|
||||
}
|
||||
+19
-75
@@ -88,10 +88,6 @@ const (
|
||||
ipVersionV6 = 6
|
||||
)
|
||||
|
||||
// maxOriginChangesOnPage is the most origin changes the prefix page shows. A
|
||||
// prefix with more shows the newest ones and says so.
|
||||
const maxOriginChangesOnPage = 5000
|
||||
|
||||
// HealthCheckResponse represents the health check response.
|
||||
type HealthCheckResponse struct {
|
||||
Status string `json:"status"`
|
||||
@@ -1538,23 +1534,26 @@ func (s *Server) handlePrefixDetail() http.HandlerFunc {
|
||||
|
||||
routes := prefixRoutes(parsed, origins)
|
||||
|
||||
changes, moreChanges, err := s.prefixOriginChanges(r.Context(), parsed)
|
||||
if deadlinePassed(r.Context()) {
|
||||
http.Error(w, requestTimeoutMessage, http.StatusGatewayTimeout)
|
||||
|
||||
return
|
||||
}
|
||||
|
||||
if err != nil {
|
||||
s.logger.Error("Failed to get the origin changes", "error", err)
|
||||
http.Error(w, internalErrorMessage, http.StatusInternalServerError)
|
||||
|
||||
return
|
||||
}
|
||||
|
||||
// Prepare template data
|
||||
data := newPrefixDetailData(parsed, routes, originInfos, changes,
|
||||
moreChanges, cspNonce(r.Context()))
|
||||
data := struct {
|
||||
Prefix string
|
||||
MaskLength int
|
||||
IPVersion int
|
||||
Routes []EnhancedRoute
|
||||
Origins []*ASNInfo
|
||||
PeerCount int
|
||||
OriginCount int
|
||||
CSPNonce string
|
||||
}{
|
||||
Prefix: parsed.String(),
|
||||
MaskLength: parsed.Bits(),
|
||||
IPVersion: ipVersionOf(parsed),
|
||||
Routes: routesWithASPathHandles(routes),
|
||||
Origins: originInfos,
|
||||
PeerCount: len(routes),
|
||||
OriginCount: len(originInfos),
|
||||
CSPNonce: cspNonce(r.Context()),
|
||||
}
|
||||
|
||||
// Check if context is still valid before writing response
|
||||
select {
|
||||
@@ -1607,61 +1606,6 @@ func (s *Server) originASNs(
|
||||
return infos, nil
|
||||
}
|
||||
|
||||
// prefixOriginChanges returns prefix's origin changes for the page, newest
|
||||
// first, at most maxOriginChangesOnPage, and whether there are more.
|
||||
func (s *Server) prefixOriginChanges(
|
||||
ctx context.Context, prefix netip.Prefix,
|
||||
) ([]routetable.OriginChange, bool, error) {
|
||||
// One more is read to know whether there are more.
|
||||
changes, err := s.db.GetOriginChanges(ctx, prefix, maxOriginChangesOnPage+1)
|
||||
if err != nil {
|
||||
return nil, false, err
|
||||
}
|
||||
|
||||
more := len(changes) > maxOriginChangesOnPage
|
||||
if more {
|
||||
changes = changes[:maxOriginChangesOnPage]
|
||||
}
|
||||
|
||||
return changes, more, nil
|
||||
}
|
||||
|
||||
// prefixDetailData is what the prefix detail page is rendered with.
|
||||
type prefixDetailData struct {
|
||||
Prefix string
|
||||
MaskLength int
|
||||
IPVersion int
|
||||
Routes []EnhancedRoute
|
||||
Origins []*ASNInfo
|
||||
PeerCount int
|
||||
OriginCount int
|
||||
OriginChanges []routetable.OriginChange
|
||||
MoreOriginChanges bool
|
||||
// MaxOriginChanges is the most origin changes the page shows.
|
||||
MaxOriginChanges int
|
||||
CSPNonce string
|
||||
}
|
||||
|
||||
// newPrefixDetailData builds the prefix detail page's data.
|
||||
func newPrefixDetailData(
|
||||
parsed netip.Prefix, routes []LiveRoute, originInfos []*ASNInfo,
|
||||
changes []routetable.OriginChange, moreChanges bool, nonce string,
|
||||
) prefixDetailData {
|
||||
return prefixDetailData{
|
||||
Prefix: parsed.String(),
|
||||
MaskLength: parsed.Bits(),
|
||||
IPVersion: ipVersionOf(parsed),
|
||||
Routes: routesWithASPathHandles(routes),
|
||||
Origins: originInfos,
|
||||
PeerCount: len(routes),
|
||||
OriginCount: len(originInfos),
|
||||
OriginChanges: changes,
|
||||
MoreOriginChanges: moreChanges,
|
||||
MaxOriginChanges: maxOriginChangesOnPage,
|
||||
CSPNonce: nonce,
|
||||
}
|
||||
}
|
||||
|
||||
// prefixRoutes returns one route for each peer that carries prefix, by origin
|
||||
// AS in the order of origins. Each origin's kept routes come first, newest
|
||||
// first, with their AS path, next hop and time. Its other peers follow without
|
||||
|
||||
@@ -261,7 +261,7 @@ func checkAnswerCarriesMeta(
|
||||
) {
|
||||
t.Helper()
|
||||
|
||||
// The values README "JSON API" gives the two fields that never change.
|
||||
// The values README "API v1" gives the two fields that never change.
|
||||
const (
|
||||
wantTimeZone = "UTC"
|
||||
wantAPIVersion = 1
|
||||
|
||||
@@ -1,230 +0,0 @@
|
||||
package server
|
||||
|
||||
import (
|
||||
"fmt"
|
||||
"net/http"
|
||||
"net/http/httptest"
|
||||
"net/netip"
|
||||
"strings"
|
||||
"testing"
|
||||
|
||||
"git.eeqj.de/sneak/routewatch/internal/config"
|
||||
"git.eeqj.de/sneak/routewatch/internal/database"
|
||||
"git.eeqj.de/sneak/routewatch/internal/logger"
|
||||
"git.eeqj.de/sneak/routewatch/internal/metrics"
|
||||
"git.eeqj.de/sneak/routewatch/internal/ristypes"
|
||||
"git.eeqj.de/sneak/routewatch/internal/routetable"
|
||||
"git.eeqj.de/sneak/routewatch/internal/streamer"
|
||||
)
|
||||
|
||||
// testUncarriedASN is an AS the test's routing table does not carry for the prefix.
|
||||
const testUncarriedASN = 64501
|
||||
|
||||
// newPrefixDetailServer returns a server whose routing table holds testPrefixV4
|
||||
// with origin AS 64500, and whose database holds the given origin changes.
|
||||
func newPrefixDetailServer(
|
||||
t *testing.T, changes []routetable.OriginChange,
|
||||
) *Server {
|
||||
t.Helper()
|
||||
|
||||
db, err := database.New(&config.Config{StateDir: t.TempDir()}, logger.New())
|
||||
if err != nil {
|
||||
t.Fatalf("database.New: %v", err)
|
||||
}
|
||||
|
||||
t.Cleanup(func() { _ = db.Close() })
|
||||
|
||||
table := emptyTable()
|
||||
announce(table, testPrefixV4, 64500, testPeer(1), testRouteTime(0))
|
||||
|
||||
err = db.WriteOriginChanges(changes)
|
||||
if err != nil {
|
||||
t.Fatalf("WriteOriginChanges: %v", err)
|
||||
}
|
||||
|
||||
return New(db, table, streamer.New(logger.New(), metrics.New()),
|
||||
logger.New(), &config.Config{})
|
||||
}
|
||||
|
||||
// TestPrefixDetailShowsOriginChanges checks that the prefix page shows the
|
||||
// origin changes newest first, with the announced and withdrawn rows and the
|
||||
// AS link. The rows use an AS the routing table does not carry for the
|
||||
// prefix, so the link comes from the origin changes table.
|
||||
func TestPrefixDetailShowsOriginChanges(t *testing.T) {
|
||||
t.Parallel()
|
||||
|
||||
prefix := netip.MustParsePrefix(testPrefixV4)
|
||||
|
||||
s := newPrefixDetailServer(t, []routetable.OriginChange{
|
||||
{Prefix: prefix, OriginASN: testUncarriedASN, Announced: true,
|
||||
PeerCount: 1, Time: testRouteTime(1)},
|
||||
{Prefix: prefix, OriginASN: testUncarriedASN, Announced: false,
|
||||
PeerCount: 0, Time: testRouteTime(2)},
|
||||
})
|
||||
|
||||
rec := httptest.NewRecorder()
|
||||
s.router.ServeHTTP(rec, httptest.NewRequestWithContext(
|
||||
t.Context(), http.MethodGet, "/prefix/"+testPrefixV4, nil))
|
||||
|
||||
if rec.Code != http.StatusOK {
|
||||
t.Fatalf("status %d, want %d; body %s", rec.Code, http.StatusOK, rec.Body)
|
||||
}
|
||||
|
||||
page := rec.Body.String()
|
||||
|
||||
withdrawn := strings.Index(page, "Withdrawn")
|
||||
announced := strings.Index(page, "Announced")
|
||||
|
||||
if withdrawn < 0 || announced < 0 {
|
||||
t.Fatalf("page does not show the announced and withdrawn rows")
|
||||
}
|
||||
|
||||
// The withdrawn row is newer, so it comes first.
|
||||
if withdrawn > announced {
|
||||
t.Errorf("the withdrawn row is not shown before the announced row")
|
||||
}
|
||||
|
||||
if !strings.Contains(page, `href="/as/64501"`) {
|
||||
t.Errorf("page does not link to AS64501")
|
||||
}
|
||||
}
|
||||
|
||||
// TestPrefixDetailShowsOriginZeroAsNoKnownOrigin checks that the origin
|
||||
// changes table shows AS 0 as no known origin, without a link to AS0.
|
||||
func TestPrefixDetailShowsOriginZeroAsNoKnownOrigin(t *testing.T) {
|
||||
t.Parallel()
|
||||
|
||||
prefix := netip.MustParsePrefix(testPrefixV4)
|
||||
|
||||
s := newPrefixDetailServer(t, []routetable.OriginChange{
|
||||
{Prefix: prefix, OriginASN: ristypes.NoOrigin, Announced: true,
|
||||
PeerCount: 1, Time: testRouteTime(1)},
|
||||
})
|
||||
|
||||
rec := httptest.NewRecorder()
|
||||
s.router.ServeHTTP(rec, httptest.NewRequestWithContext(
|
||||
t.Context(), http.MethodGet, "/prefix/"+testPrefixV4, nil))
|
||||
|
||||
if rec.Code != http.StatusOK {
|
||||
t.Fatalf("status %d, want %d; body %s", rec.Code, http.StatusOK, rec.Body)
|
||||
}
|
||||
|
||||
page := rec.Body.String()
|
||||
|
||||
if !strings.Contains(page, "No known origin") {
|
||||
t.Errorf("page does not say the origin change has no known origin")
|
||||
}
|
||||
|
||||
if strings.Contains(page, `href="/as/0"`) {
|
||||
t.Errorf("page links to AS0")
|
||||
}
|
||||
}
|
||||
|
||||
// TestPrefixDetailSaysWhenThereAreMoreChangesThanItShows checks that the
|
||||
// prefix page says so when a prefix has more origin changes than the page's
|
||||
// limit.
|
||||
func TestPrefixDetailSaysWhenThereAreMoreChangesThanItShows(t *testing.T) {
|
||||
t.Parallel()
|
||||
|
||||
prefix := netip.MustParsePrefix(testPrefixV4)
|
||||
|
||||
changes := make([]routetable.OriginChange, 0, maxOriginChangesOnPage+1)
|
||||
for i := range maxOriginChangesOnPage + 1 {
|
||||
changes = append(changes, routetable.OriginChange{
|
||||
Prefix: prefix, OriginASN: 64500, Announced: true, PeerCount: 1,
|
||||
Time: testRouteTime(i),
|
||||
})
|
||||
}
|
||||
|
||||
s := newPrefixDetailServer(t, changes)
|
||||
|
||||
rec := httptest.NewRecorder()
|
||||
s.router.ServeHTTP(rec, httptest.NewRequestWithContext(
|
||||
t.Context(), http.MethodGet, "/prefix/"+testPrefixV4, nil))
|
||||
|
||||
if rec.Code != http.StatusOK {
|
||||
t.Fatalf("status %d, want %d; body %s", rec.Code, http.StatusOK, rec.Body)
|
||||
}
|
||||
|
||||
page := rec.Body.String()
|
||||
|
||||
note := fmt.Sprintf("more than %d changes", maxOriginChangesOnPage)
|
||||
if !strings.Contains(page, note) {
|
||||
t.Errorf("page does not say there are more than %d changes",
|
||||
maxOriginChangesOnPage)
|
||||
}
|
||||
|
||||
if got := strings.Count(page, "<td>Announced</td>"); got != maxOriginChangesOnPage {
|
||||
t.Errorf("page shows %d change rows, want %d", got,
|
||||
maxOriginChangesOnPage)
|
||||
}
|
||||
}
|
||||
|
||||
// TestPrefixDetailShowsNoNoteAtTheLimit checks that a prefix with exactly the
|
||||
// page's limit of origin changes shows all of them and no note.
|
||||
func TestPrefixDetailShowsNoNoteAtTheLimit(t *testing.T) {
|
||||
t.Parallel()
|
||||
|
||||
prefix := netip.MustParsePrefix(testPrefixV4)
|
||||
|
||||
changes := make([]routetable.OriginChange, 0, maxOriginChangesOnPage)
|
||||
for i := range maxOriginChangesOnPage {
|
||||
changes = append(changes, routetable.OriginChange{
|
||||
Prefix: prefix, OriginASN: 64500, Announced: true, PeerCount: 1,
|
||||
Time: testRouteTime(i),
|
||||
})
|
||||
}
|
||||
|
||||
s := newPrefixDetailServer(t, changes)
|
||||
|
||||
rec := httptest.NewRecorder()
|
||||
s.router.ServeHTTP(rec, httptest.NewRequestWithContext(
|
||||
t.Context(), http.MethodGet, "/prefix/"+testPrefixV4, nil))
|
||||
|
||||
if rec.Code != http.StatusOK {
|
||||
t.Fatalf("status %d, want %d; body %s", rec.Code, http.StatusOK, rec.Body)
|
||||
}
|
||||
|
||||
page := rec.Body.String()
|
||||
|
||||
if strings.Contains(page, "more than") {
|
||||
t.Errorf("page says there are more changes, but a prefix has %d",
|
||||
maxOriginChangesOnPage)
|
||||
}
|
||||
|
||||
if got := strings.Count(page, "<td>Announced</td>"); got != maxOriginChangesOnPage {
|
||||
t.Errorf("page shows %d change rows, want %d", got,
|
||||
maxOriginChangesOnPage)
|
||||
}
|
||||
}
|
||||
|
||||
// TestPrefixDetailShowsOriginChangeTimeAndPeerCount checks that a row shows
|
||||
// its time and its peer count.
|
||||
func TestPrefixDetailShowsOriginChangeTimeAndPeerCount(t *testing.T) {
|
||||
t.Parallel()
|
||||
|
||||
prefix := netip.MustParsePrefix(testPrefixV4)
|
||||
|
||||
s := newPrefixDetailServer(t, []routetable.OriginChange{
|
||||
{Prefix: prefix, OriginASN: 64500, Announced: true, PeerCount: 7,
|
||||
Time: testRouteTime(5)},
|
||||
})
|
||||
|
||||
rec := httptest.NewRecorder()
|
||||
s.router.ServeHTTP(rec, httptest.NewRequestWithContext(
|
||||
t.Context(), http.MethodGet, "/prefix/"+testPrefixV4, nil))
|
||||
|
||||
if rec.Code != http.StatusOK {
|
||||
t.Fatalf("status %d, want %d; body %s", rec.Code, http.StatusOK, rec.Body)
|
||||
}
|
||||
|
||||
page := rec.Body.String()
|
||||
|
||||
if !strings.Contains(page, "2026-01-02 03:09:05") {
|
||||
t.Errorf("page does not show the origin change's time")
|
||||
}
|
||||
|
||||
if !strings.Contains(page, "<td>7</td>") {
|
||||
t.Errorf("page does not show the origin change's peer count")
|
||||
}
|
||||
}
|
||||
@@ -7,8 +7,8 @@
|
||||
// - the AS name search
|
||||
//
|
||||
// Every route it shows comes from the routing table in memory. AS names,
|
||||
// WHOIS details, the times a prefix and an AS were first seen, and a prefix's
|
||||
// origin changes come from the database.
|
||||
// WHOIS details and the times a prefix and an AS were first seen come from
|
||||
// the database.
|
||||
package server
|
||||
|
||||
import (
|
||||
|
||||
@@ -12,6 +12,7 @@ import (
|
||||
"fmt"
|
||||
"io"
|
||||
"math"
|
||||
"math/rand"
|
||||
"net/http"
|
||||
"sync"
|
||||
"sync/atomic"
|
||||
@@ -57,6 +58,10 @@ const (
|
||||
// Well above an extended BGP message (RFC 8654) in hex plus its prefixes
|
||||
maxLineSize = bytesPerMB
|
||||
maxConcurrentHandlers = 800 // Maximum number of concurrent message handlers
|
||||
|
||||
// Backpressure constants
|
||||
backpressureThreshold = 0.5 // Start dropping at 50% queue utilization
|
||||
backpressureSlope = 2.0 // Slope for linear drop probability increase
|
||||
)
|
||||
|
||||
// messageTypeNotification is the type of a BGP NOTIFICATION message, which ends
|
||||
@@ -88,8 +93,9 @@ type MessageHandler interface {
|
||||
|
||||
// QueueCapacity returns the desired queue capacity for this handler.
|
||||
// Handlers that process quickly can have larger queues to buffer bursts.
|
||||
// While the queue is full, the streamer drops the handler's messages,
|
||||
// except STATE messages, which are held until there is room.
|
||||
// When the queue fills up, messages will be dropped according to the
|
||||
// backpressure algorithm, except STATE messages, which are held until
|
||||
// there is room.
|
||||
QueueCapacity() int
|
||||
}
|
||||
|
||||
@@ -120,8 +126,8 @@ type handlerInfo struct {
|
||||
|
||||
// Streamer manages a connection to the RIPE RIS Live streaming API for receiving
|
||||
// real-time BGP UPDATE messages. It handles automatic reconnection with exponential
|
||||
// backoff and dispatches messages to registered handlers via per-handler queues.
|
||||
// Its read loop never waits for room on a queue (see queueMessage).
|
||||
// backoff, dispatches messages to registered handlers via per-handler queues, and
|
||||
// implements backpressure to prevent queue overflow during high traffic periods.
|
||||
type Streamer struct {
|
||||
logger *logger.Logger
|
||||
client *http.Client
|
||||
@@ -138,6 +144,7 @@ type Streamer struct {
|
||||
workers sync.WaitGroup // the handler workers; Stop waits for them
|
||||
metrics *metrics.Tracker
|
||||
totalDropped atomic.Uint64 // Total dropped messages across all handlers
|
||||
random *rand.Rand // Random number generator for backpressure drops
|
||||
bgpPeers map[string]bool // Track active BGP peers by peer IP
|
||||
bgpPeersMu sync.RWMutex // Protects bgpPeers map
|
||||
}
|
||||
@@ -161,6 +168,8 @@ func New(logger *logger.Logger, metrics *metrics.Tracker) *Streamer {
|
||||
},
|
||||
handlers: make([]*handlerInfo, 0),
|
||||
metrics: metrics,
|
||||
//nolint:gosec // Non-cryptographic randomness is fine for backpressure
|
||||
random: rand.New(rand.NewSource(time.Now().UnixNano())),
|
||||
bgpPeers: make(map[string]bool),
|
||||
}
|
||||
}
|
||||
@@ -399,7 +408,7 @@ func (s *Streamer) GetHandlerStats() []HandlerStats {
|
||||
}
|
||||
|
||||
// GetDroppedMessages returns the total number of messages dropped across all
|
||||
// handlers because their queue was full. This counter is monotonically
|
||||
// handlers due to queue overflow or backpressure. This counter is monotonically
|
||||
// increasing and is safe to call concurrently.
|
||||
func (s *Streamer) GetDroppedMessages() uint64 {
|
||||
return s.totalDropped.Load()
|
||||
@@ -882,13 +891,13 @@ func (s *Streamer) dispatchMessage(
|
||||
// msg instead. It never waits for room, so a full queue does not hold up the
|
||||
// read loop.
|
||||
//
|
||||
// A message that finds the queue full is dropped, except a STATE message. A
|
||||
// STATE message whose state is down is the only notice that all of a peer's
|
||||
// routes are gone. A STATE message that finds the queue full is held in
|
||||
// info.heldState instead. Held messages go into the queue, oldest first, when a
|
||||
// later message for the handler finds room, or when Stop is called. While any
|
||||
// message is held, the handler's other messages are dropped, so none of them
|
||||
// overtakes a held STATE message.
|
||||
// A message is dropped while the queue is filling up (shouldDropForBackpressure)
|
||||
// or full, except a STATE message: one whose state is down is the only notice
|
||||
// that all of a peer's routes are gone. A STATE message skips the random drop,
|
||||
// and one that finds the queue full is held in info.heldState. Held messages
|
||||
// go into the queue, oldest first, before anything else for the handler, as
|
||||
// soon as there is room, or when Stop is called; while any is still held, the
|
||||
// handler's other messages are dropped, so none of them overtakes a held down.
|
||||
//
|
||||
// The held list stays small: a STATE message is a few hundred bytes and the
|
||||
// feed sends about ten a second, so a queue full for a minute holds about 600.
|
||||
@@ -907,7 +916,7 @@ func (s *Streamer) queueMessage(
|
||||
return true
|
||||
}
|
||||
|
||||
if len(info.heldState) > 0 {
|
||||
if len(info.heldState) > 0 || s.shouldDropForBackpressure(info) {
|
||||
return false
|
||||
}
|
||||
|
||||
@@ -923,3 +932,26 @@ func trySend(queue chan *ristypes.RISMessage, msg *ristypes.RISMessage) bool {
|
||||
return false
|
||||
}
|
||||
}
|
||||
|
||||
// shouldDropForBackpressure determines if a message should be dropped based on
|
||||
// queue utilization
|
||||
func (s *Streamer) shouldDropForBackpressure(info *handlerInfo) bool {
|
||||
// Calculate queue utilization
|
||||
queueLen := len(info.queue)
|
||||
queueCap := cap(info.queue)
|
||||
utilization := float64(queueLen) / float64(queueCap)
|
||||
|
||||
// No drops below threshold
|
||||
if utilization < backpressureThreshold {
|
||||
return false
|
||||
}
|
||||
|
||||
// Calculate drop probability (0.0 at threshold, 1.0 at 100% full)
|
||||
dropProbability := (utilization - backpressureThreshold) * backpressureSlope
|
||||
if dropProbability > 1.0 {
|
||||
dropProbability = 1.0
|
||||
}
|
||||
|
||||
// Random drop based on probability
|
||||
return s.random.Float64() < dropProbability
|
||||
}
|
||||
|
||||
@@ -5,7 +5,6 @@ import (
|
||||
"context"
|
||||
"encoding/json"
|
||||
"errors"
|
||||
"fmt"
|
||||
"io"
|
||||
"log/slog"
|
||||
"net/http"
|
||||
@@ -259,65 +258,6 @@ func TestHeldStateMessagesKeepTheirPlaceInTheQueue(t *testing.T) {
|
||||
}
|
||||
}
|
||||
|
||||
// burstQueueCapacity is the size of a burstHandler's queue.
|
||||
const burstQueueCapacity = 1000
|
||||
|
||||
// burstHandler wants UPDATE messages and has a queue of burstQueueCapacity.
|
||||
// Tests read what it is handed from its queue, so HandleMessage does nothing.
|
||||
type burstHandler struct{}
|
||||
|
||||
func (burstHandler) WantsMessage(messageType string) bool {
|
||||
return messageType == ristypes.MessageTypeUpdate
|
||||
}
|
||||
|
||||
func (burstHandler) QueueCapacity() int { return burstQueueCapacity }
|
||||
|
||||
func (burstHandler) HandleMessage(*ristypes.RISMessage) {}
|
||||
|
||||
// TestUpdatesDroppedOnlyWhenTheQueueIsFull has the server send one UPDATE more
|
||||
// than the handler's queue holds, each with its own timestamp. Nothing takes
|
||||
// messages off the queue meanwhile. The streamer must queue the updates in
|
||||
// feed order until the queue is full, and drop only the last one.
|
||||
func TestUpdatesDroppedOnlyWhenTheQueueIsFull(t *testing.T) {
|
||||
t.Parallel()
|
||||
|
||||
const (
|
||||
firstTimestamp = 1700000000
|
||||
lineFormat = `{"type":"ris_message","data":{"type":"UPDATE",` +
|
||||
`"peer":"192.0.2.1","peer_asn":"64496","timestamp":%d}}` + "\n"
|
||||
)
|
||||
|
||||
var lines strings.Builder
|
||||
|
||||
for i := range burstQueueCapacity + 1 {
|
||||
fmt.Fprintf(&lines, lineFormat, firstTimestamp+i)
|
||||
}
|
||||
|
||||
s := New(logger.New(), metrics.New())
|
||||
s.RegisterHandler(burstHandler{})
|
||||
|
||||
streamLines(t, s, lines.String())
|
||||
|
||||
dropped := s.GetHandlerStats()[0].DroppedCount
|
||||
if dropped != 1 {
|
||||
t.Errorf("%d updates dropped, want only the one that found the queue "+
|
||||
"full", dropped)
|
||||
}
|
||||
|
||||
queue := s.handlers[0].queue
|
||||
if len(queue) != burstQueueCapacity {
|
||||
t.Fatalf("%d updates queued, want %d", len(queue), burstQueueCapacity)
|
||||
}
|
||||
|
||||
for i := range burstQueueCapacity {
|
||||
msg := <-queue
|
||||
if msg.Timestamp != float64(firstTimestamp+i) {
|
||||
t.Fatalf("update %d on the queue has timestamp %.0f, want %d",
|
||||
i, msg.Timestamp, firstTimestamp+i)
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
// takeAll takes the messages off queue, as a handler's worker would, and sends
|
||||
// them on the returned channel once queue is closed.
|
||||
func takeAll(queue chan *ristypes.RISMessage) chan []*ristypes.RISMessage {
|
||||
|
||||
@@ -299,41 +299,6 @@
|
||||
</div>
|
||||
{{end}}
|
||||
|
||||
{{if .OriginChanges}}
|
||||
<div class="origins-section">
|
||||
<h3>Origin Changes</h3>
|
||||
{{if .MoreOriginChanges}}
|
||||
<p>There are more than {{.MaxOriginChanges}} changes. Showing the newest {{.MaxOriginChanges}}.</p>
|
||||
{{end}}
|
||||
<table class="route-table">
|
||||
<thead>
|
||||
<tr>
|
||||
<th>Time (UTC)</th>
|
||||
<th>Change</th>
|
||||
<th>Origin AS</th>
|
||||
<th>Peers</th>
|
||||
</tr>
|
||||
</thead>
|
||||
<tbody>
|
||||
{{range .OriginChanges}}
|
||||
<tr>
|
||||
<td>{{.Time.Format "2006-01-02 15:04:05"}}</td>
|
||||
<td>{{if .Announced}}Announced{{else}}Withdrawn{{end}}</td>
|
||||
<td>
|
||||
{{if .OriginASN}}
|
||||
<a href="/as/{{.OriginASN}}" class="as-link">AS{{.OriginASN}}</a>
|
||||
{{else}}
|
||||
No known origin
|
||||
{{end}}
|
||||
</td>
|
||||
<td>{{.PeerCount}}</td>
|
||||
</tr>
|
||||
{{end}}
|
||||
</tbody>
|
||||
</table>
|
||||
</div>
|
||||
{{end}}
|
||||
|
||||
{{if .Routes}}
|
||||
<div class="routes-section">
|
||||
<div class="routes-header">
|
||||
|
||||
Reference in New Issue
Block a user