fix(vpc): bound live firewalld readiness checks

go
codex 3 weeks ago
parent 6eb7b79507
commit 4ace50b406

@ -25,7 +25,10 @@ const (
maximumCommandOutput = 2 << 20
nftFamily = "inet"
nftTable = "virt_cloud_vpc"
availabilityTimeout = 5 * time.Second
// A readiness probe performs bounded permanent and runtime firewalld
// snapshots. Keep this below the panel's 20-second capability request
// deadline while allowing ordinary D-Bus serialization on loaded hosts.
availabilityTimeout = 15 * time.Second
)
type linuxDriver struct {

@ -92,34 +92,104 @@ func (d *linuxDriver) firewalldReadiness(ctx context.Context, current map[string
if err != nil || !active {
return err
}
if err := d.preflightFirewalld(ctx, current, current); err != nil {
return err
}
if len(current) == 0 {
return nil
}
desiredGuest, desiredTransport := firewalldInterfaces(current)
for _, scope := range []firewalldScope{{permanent: true}, {permanent: false}} {
complete, err := d.firewalldDefinitionsComplete(ctx, scope)
err := d.firewalldReadinessScope(
ctx, scope, desiredGuest, desiredTransport, len(current) != 0,
)
if err != nil {
return err
}
if !complete {
return unavailable("vpc_firewalld_apply_unconfirmed", "committed firewalld VPC definitions are incomplete", nil)
}
return nil
}
// firewalldReadinessScope inspects each reserved object once. Capability
// reporting used to run the general mutation preflight, a complete definition
// check, and a final interface check in sequence. On real hosts that meant more
// than fifty firewall-cmd subprocesses under one five-second deadline, so a
// healthy committed projection could be reported unavailable. Keep the same
// fail-closed checks while projecting one immutable snapshot per scope.
func (d *linuxDriver) firewalldReadinessScope(
ctx context.Context,
scope firewalldScope,
desiredGuest, desiredTransport map[string]struct{},
requireComplete bool,
) error {
zones, err := d.firewalldNames(ctx, scope, "--get-zones")
if err != nil {
return err
}
policies, err := d.firewalldNames(ctx, scope, "--get-policies")
if err != nil {
return err
}
for _, zone := range []struct {
name string
forward bool
interfaces map[string]struct{}
}{
{name: firewalldGuestZone, forward: true, interfaces: desiredGuest},
{name: firewalldTransportZone, interfaces: desiredTransport},
} {
if _, exists := zones[zone.name]; !exists {
if requireComplete {
return unavailable("vpc_firewalld_apply_unconfirmed", "committed firewalld VPC definitions are incomplete", nil)
}
continue
}
guest, err := d.inspectFirewalldZone(ctx, scope, firewalldGuestZone)
state, err := d.inspectFirewalldZone(ctx, scope, zone.name)
if err != nil {
return err
}
transport, err := d.inspectFirewalldZone(ctx, scope, firewalldTransportZone)
if err != nil {
if err := validateFirewalldZoneState(scope, zone.name, zone.forward, state); err != nil {
return err
}
if !equalStringSets(guest.interfaces, desiredGuest) ||
!equalStringSets(transport.interfaces, desiredTransport) {
for name := range state.interfaces {
if _, owned := zone.interfaces[name]; !owned {
return firewalldConflict(scope, "zone "+zone.name+" contains an unmanaged interface")
}
}
for _, name := range sortedStringSet(zone.interfaces) {
bound, err := d.firewalldInterfaceZone(ctx, scope, name)
if err != nil {
return err
}
if bound != "" && bound != zone.name {
return firewalldConflict(scope, "interface "+name+" is already bound to zone "+bound)
}
}
if requireComplete && (state.forward != zone.forward || !equalStringSets(state.interfaces, zone.interfaces)) {
return unavailable("vpc_firewalld_apply_unconfirmed", "committed firewalld VPC interface ownership is incomplete", nil)
}
}
for _, policy := range []struct {
name string
ingress string
egress string
}{
{name: firewalldGuestToTransportPolicy, ingress: firewalldGuestZone, egress: firewalldTransportZone},
{name: firewalldTransportToGuestPolicy, ingress: firewalldTransportZone, egress: firewalldGuestZone},
} {
if _, exists := policies[policy.name]; !exists {
if requireComplete {
return unavailable("vpc_firewalld_apply_unconfirmed", "committed firewalld VPC definitions are incomplete", nil)
}
continue
}
state, err := d.inspectFirewalldPolicy(ctx, scope, policy.name)
if err != nil {
return err
}
if err := validateFirewalldPolicyState(scope, policy.name, policy.ingress, policy.egress, state); err != nil {
return err
}
if requireComplete && (!containsExactStrings(state.ingress, policy.ingress) || !containsExactStrings(state.egress, policy.egress)) {
return unavailable("vpc_firewalld_apply_unconfirmed", "committed firewalld VPC definitions are incomplete", nil)
}
}
return nil
}

@ -385,6 +385,9 @@ func TestFirewalldReadinessUsesCommittedProjectionWithoutMutation(t *testing.T)
if err := driver.firewalldReadiness(t.Context(), applied); err != nil {
t.Fatalf("committed firewalld projection was rejected: %v", err)
}
if got, want := len(runner.calls), 25; got != want {
t.Fatalf("readiness command count=%d, want %d single-pass inspections: %v", got, want, runner.calls)
}
for _, call := range runner.calls {
for _, mutation := range []string{"--new-", "--set-", "--add-", "--remove-", "--reload"} {
if strings.Contains(call, mutation) {
@ -413,6 +416,30 @@ func TestFirewalldReadinessUsesCommittedProjectionWithoutMutation(t *testing.T)
}
}
func TestFirewalldReadinessRejectsCommittedInterfaceInForeignZone(t *testing.T) {
runner := newFakeFirewalldRunner(true)
driver := &linuxDriver{
ipPath: "/usr/sbin/ip", nftPath: "/usr/sbin/nft",
firewallCmdPath: "/usr/bin/firewall-cmd", run: runner,
}
network := testNetwork(1)
applied := map[string]Network{network.VPCKey: network}
if err := driver.reconcileFirewalld(t.Context(), nil, applied); err != nil {
t.Fatal(err)
}
bridge, _ := BridgeName(network.VPCKey)
delete(runner.runtime.zones[firewalldGuestZone].interfaces, bridge)
runner.runtime.zones["public"] = &fakeFirewalldZone{
target: "default", interfaces: map[string]struct{}{bridge: {}},
}
err := driver.firewalldReadiness(t.Context(), applied)
var public interface{ PublicCode() string }
if err == nil || !errors.As(err, &public) || public.PublicCode() != "vpc_firewalld_conflict" {
t.Fatalf("foreign interface ownership was not rejected: %v", err)
}
}
func TestReconcileFirewalldRejectsForeignInterfaceBeforeMutation(t *testing.T) {
runner := newFakeFirewalldRunner(true)
runner.runtime.zones[firewalldGuestZone] = &fakeFirewalldZone{

Loading…
Cancel
Save