build.managers.flow_builder._build_int_source_flows()

Complexity

Conditions

11

Size

Total Lines	93
Code Lines	51

Duplication

Lines	0
Ratio	0 %

Code Coverage

Tests	1
CRAP Score	122.943

Importance

Changes

0

"""flow_builder module responsible for building and mapping flows."""
def _build_int_source_flows(
    uni_src_key: Literal["uni_a", "uni_z"],
    evc: dict,
    stored_flows: dict[int, list[dict]],
) -> list[dict]:
    """Build INT source flows.

    At the INT source, one flow becomes 3: one for UDP on table 0,
    one for TCP on table 0, and one on table 2
    On table 0, we use just new instructions: push_int and goto_table
    On table 2, we add add_int_metadata before the original actions
    INT flows will have higher priority.
    """
    new_flows = []
    new_int_flow_tbl_0_tcp = {}
    src_uni = evc[uni_src_key]

    # Get the original flows
    dpid = src_uni["switch"]
    for flow in stored_flows[utils.get_cookie(evc["id"], settings.MEF_COOKIE_PREFIX)]:
        if (
            flow["switch"] == dpid
            and flow["flow"]["match"]["in_port"] == src_uni["port_number"]
        ):
            new_int_flow_tbl_0_tcp = copy.deepcopy(flow)
            break

    if not new_int_flow_tbl_0_tcp:
        raise FlowsNotFound(evc["id"])

    utils.set_instructions_from_actions(new_int_flow_tbl_0_tcp)
    utils.set_new_cookie(new_int_flow_tbl_0_tcp)
    utils.set_owner(new_int_flow_tbl_0_tcp)

    # Deepcopy to use for table 2 later
    new_int_flow_tbl_2 = copy.deepcopy(new_int_flow_tbl_0_tcp)

    # Prepare TCP Flow for Table 0
    new_int_flow_tbl_0_tcp["flow"]["match"]["dl_type"] = settings.IPv4
    new_int_flow_tbl_0_tcp["flow"]["match"]["nw_proto"] = settings.TCP
    utils.set_priority(new_int_flow_tbl_0_tcp)

    # The flow_manager has two outputs: instructions and actions.
    instructions = [
        {
            "instruction_type": "apply_actions",
            "actions": [{"action_type": "push_int"}],
        },
        {"instruction_type": "goto_table", "table_id": settings.INT_TABLE},
    ]
    new_int_flow_tbl_0_tcp["flow"]["instructions"] = instructions

    # Prepare UDP Flow for Table 0. Everything the same as TCP except the nw_proto
    new_int_flow_tbl_0_udp = copy.deepcopy(new_int_flow_tbl_0_tcp)
    new_int_flow_tbl_0_udp["flow"]["match"]["nw_proto"] = settings.UDP

    # Prepare Flows for Table 2 - No TCP or UDP specifics
    new_int_flow_tbl_2["flow"]["table_id"] = settings.INT_TABLE
    utils.set_table_group(new_int_flow_tbl_2)

    # if intra-switch EVC, then output port should be the dst UNI's source port
    if utils.is_intra_switch_evc(evc):
        dst_uni = evc["uni_z" if uni_src_key == "uni_a" else "uni_a"]
        proxy_port = dst_uni["proxy_port"]
        for instruction in new_int_flow_tbl_2["flow"]["instructions"]:
            if instruction["instruction_type"] == "apply_actions":
                for action in instruction["actions"]:
                    if action["action_type"] == "output":
                        # Since this is the INT Source, we use source
                        # to avoid worrying about single or multi
                        # home physical loops.
                        # The choice for destination is at the INT Sink.
                        action["port"] = proxy_port.source.port_number

                # remove set_vlan action if it exists, this is for
                # avoding a redundant set_vlan since it'll be set in the egress sink
                instruction["actions"] = utils.modify_actions(
                    instruction["actions"], ["set_vlan"], remove=True
                )

    instructions = utils.add_to_apply_actions(
        new_int_flow_tbl_2["flow"]["instructions"],
        new_instruction={"action_type": "add_int_metadata"},
        position=0,
    )

    new_int_flow_tbl_2["flow"]["instructions"] = instructions

    new_flows.append(new_int_flow_tbl_0_tcp)
    new_flows.append(new_int_flow_tbl_0_udp)
    new_flows.append(new_int_flow_tbl_2)

    return new_flows