Implement cascade deregistering

[avnik]

Description

Implement cascade service deregistering

Checklist

• Summary of the proposed changes in the PR description
• More detailed description in the commit message(s)
• Commits are squashed into relevant entities - avoid a lot of minimal dev time commits in the PR
• Contribution guidelines followed
• Test procedure added to nixos/tests
• Author has run nix flake check --accept-flake-config and it passes
• All automatic Github Action checks pass - see actions
• Author has added reviewers and removed PR draft status

Testing

cargo test for unit tests (one test added)
run-vm-test admin for integration test

[slakkala]

LGTM; added a comment for the hashmap handling, but there's currently not any clean solution.

[slakkala]

Annoyingly there's a nightly feature providing .extract_if() that would provide exactly what we'd need here; I guess the closest would be to rebuild the hashmap:

                *state = state
                    .drain()
                    .filter_map(|(k, v)| {
                        if matches!(v.placement, Placement::Managed(ref within) if within == name) {
                            info!("Cascade deregistering {:#?}", v);
                            self.send_event(Event::UnitShutdown(v.into()));
                            None
                        } else {
                            Some((k, v))
                        }
                    })
                    .collect();

But I'm guessing the number of cascaded services should normally be rather small, so probably the current way is better. As a chaining over-user, I would write this as:

                for entry in state
                    .values()
                    .filter_map(|re| {
                        matches!(&re.placement, Placement::Managed(within) if within == name)
                            .then(|| re.name.clone())
                    })
                    .collect::<Vec<_>>()
                    .into_iter()
                    .filter_map(|re| state.remove(&re))
                {
                    info!("Cascade deregistering {entry:#?}");
                    self.send_event(Event::UnitShutdown(entry.into()))
                }

Third option; shortest, but involves cloning the whole entry:

                state.retain(|_, val| if matches!(&val.placement, Placement::Managed(within) if within == name) {
                    info!("Cascade deregistering {entry:#?}");
                    self.send_event(Event::UnitShutdown(val.clone().into()));
                    false
                } else {
                    true
                });