diff --git a/agent/vpcrouting/driver_linux.go b/agent/vpcrouting/driver_linux.go index dfc80a64..b9ba62ba 100644 --- a/agent/vpcrouting/driver_linux.go +++ b/agent/vpcrouting/driver_linux.go @@ -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 { diff --git a/agent/vpcrouting/firewalld_linux.go b/agent/vpcrouting/firewalld_linux.go index f0f80ae0..d8b5cb01 100644 --- a/agent/vpcrouting/firewalld_linux.go +++ b/agent/vpcrouting/firewalld_linux.go @@ -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 } diff --git a/agent/vpcrouting/firewalld_linux_test.go b/agent/vpcrouting/firewalld_linux_test.go index 08b7dfa6..d4dc8cec 100644 --- a/agent/vpcrouting/firewalld_linux_test.go +++ b/agent/vpcrouting/firewalld_linux_test.go @@ -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{