faucet.valve_switch_stack module

Manage flooding/learning on stacked datapaths.

class faucet.valve_switch_stack.ValveSwitchStackManagerBase(stack_manager, **kwargs)

Bases: ValveSwitchManager

Base class for dataplane based flooding/learning on stacked dataplanes.

add_drop_spoofed_faucet_mac_rules(vlan)

Install rules to drop spoofed faucet mac

add_port(port)

install flows in response to a new port

del_port(port)

delete flows in response to a port removal

edge_learn_port(other_valves, pkt_meta)

Find a port towards the edge DP where the packet originated from

Parameters:

• other_valves (list) – All Valves other than this one.

• pkt_meta (PacketMeta) – PacketMeta instance for packet received.

Returns:

port to learn host on, or None.

get_lacp_dpid_nomination(lacp_id, valve, other_valves)

Chooses the DP for a given LAG.

The DP will be nominated by the following conditions in order:

1. Number of LAG ports

2. Root DP

3. Lowest DPID

Parameters:

• lacp_id – The LACP LAG ID

• other_valves (list) – list of other valves

Returns:

nominated_dpid, reason

learn_host_from_pkt(valve, now, pkt_meta, other_valves)

Learn host from packet.

class faucet.valve_switch_stack.ValveSwitchStackManagerNoReflection(stack_manager, **kwargs)

Bases: ValveSwitchStackManagerBase

Stacks of size 2 - all switches directly connected to root.

Root switch simply floods to all other switches.

Non-root switches simply flood to the root.

class faucet.valve_switch_stack.ValveSwitchStackManagerReflection(stack_manager, **kwargs)

Bases: ValveSwitchStackManagerBase

Stacks size > 2 reflect floods off of root (selective flooding).

                      Hosts
                       ||||
                       ||||
         +----+       +----+       +----+
      ---+1   |       |1234|       |   1+---
Hosts ---+2   |       |    |       |   2+--- Hosts
      ---+3   |       |    |       |   3+---
      ---+4  5+-------+5  6+-------+5  4+---
         +----+       +----+       +----+

         Root DP

Non-root switches flood only to the root. The root switch reflects incoming floods back out. Non-root switches flood packets from the root locally and to switches further away from the root. Flooding is entirely implemented in the dataplane.

A host connected to a non-root switch can receive a copy of its own flooded packet (because the non-root switch does not know it has seen the packet already).

A host connected to the root switch does not have this problem (because flooding is always away from the root). Therefore, connections to other non-FAUCET stacking networks should only be made to the root.

On the root switch (left), flood destinations are:

1: 2 3 4 5(s) 2: 1 3 4 5(s) 3: 1 2 4 5(s) 4: 1 2 3 5(s) 5: 1 2 3 4 5(s, note reflection)

On the middle switch:

1: 5(s) 2: 5(s) 3: 5(s) 4: 5(s) 5: 1 2 3 4 6(s) 6: 5(s)

On the rightmost switch:

1: 5(s) 2: 5(s) 3: 5(s) 4: 5(s) 5: 1 2 3 4