From patchwork Fri Oct 23 23:28:59 2020 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 8bit X-Patchwork-Submitter: Owen Hilyard X-Patchwork-Id: 82028 Return-Path: X-Original-To: patchwork@inbox.dpdk.org Delivered-To: patchwork@inbox.dpdk.org Received: from dpdk.org (dpdk.org [92.243.14.124]) by inbox.dpdk.org (Postfix) with ESMTP id 05851A04B0; Sat, 24 Oct 2020 01:29:24 +0200 (CEST) Received: from [92.243.14.124] (localhost [127.0.0.1]) by dpdk.org (Postfix) with ESMTP id E3BC4688E; Sat, 24 Oct 2020 01:29:22 +0200 (CEST) Received: from mail-qt1-f195.google.com (mail-qt1-f195.google.com [209.85.160.195]) by dpdk.org (Postfix) with ESMTP id 2A3C76889 for ; Sat, 24 Oct 2020 01:29:22 +0200 (CEST) Received: by mail-qt1-f195.google.com with SMTP id i7so1855279qti.6 for ; Fri, 23 Oct 2020 16:29:22 -0700 (PDT) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=iol.unh.edu; s=unh-iol; h=from:to:cc:subject:date:message-id:in-reply-to:references :mime-version:content-transfer-encoding; bh=DGEhvcwESuhTM4/zlky6WGcL72qa9ZvVoL1GDFMMgPk=; b=OjdPkn/cRjkFCXZxyv8RFwzSPi07mkPNl1F4Rgycj2C7l+0a/TUJppnGsrULVaTz5S sXe3L/T3HAhYxr11wpGvtrTKxLVFGGj6wVHtffpu+WQwW1836Zg9eDe4Hgo+CeKMgn2c 9NY1wM4wHF2PZEmJoh8Rhe4v6bYLV8nO6wakY= X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20161025; h=x-gm-message-state:from:to:cc:subject:date:message-id:in-reply-to :references:mime-version:content-transfer-encoding; bh=DGEhvcwESuhTM4/zlky6WGcL72qa9ZvVoL1GDFMMgPk=; b=eBhekk163W94+eihhx/TKDNLJw8nd8rkHAsuoYvCTgn4EKK/CJNDsTEZF2e1WELjaz CwJYKHm3PHdXbEUqI4Wv/Fe7DoO3MZ5xblQsv0I0baURRtx+YiLvL+4rYcZyolxPeQ0Z LuCVJPbPWfg1hh5VPj1D7q+V8O0XdwGNkLNHmUhQ6ZWMGXO12hweLpmtcS9iy3+0YRzh JzMNVLhhfAmb558sD/PYyjKQT6u9At4Er8d3jsMp8POIEK/SCYXkH0MuYyrAZFcODcL7 g/jWlLuKDXbYMZTG9jZ2zdIL56CykDwOJCTSiikxscmTcyMmJ9JL2Mmx5dNGoZZT7QXI XEqQ== X-Gm-Message-State: AOAM5336dEPHo4Qnls3Uv7RAyo014w2VsJXmCx9MKXKUoMcO77Fjjw2L t9Cu0c4/SBOIFH3TTNjZ2UVCFA== X-Google-Smtp-Source: ABdhPJwo7UKhuU/BSt+DEj9d4nuiIlrKiBRS+NFFZhnsoVaxTwvjvPQoBXTaDiqfGBfK9nXKb1pA6g== X-Received: by 2002:aed:22bc:: with SMTP id p57mr4922074qtc.242.1603495760574; Fri, 23 Oct 2020 16:29:20 -0700 (PDT) Received: from ohilyard-Alienware-m17.iol.unh.edu (nt-238-66.w4.unh.edu. [132.177.238.66]) by smtp.googlemail.com with ESMTPSA id j16sm1851673qkg.26.2020.10.23.16.29.19 (version=TLS1_3 cipher=TLS_AES_256_GCM_SHA384 bits=256/256); Fri, 23 Oct 2020 16:29:19 -0700 (PDT) From: Owen Hilyard To: ohilyard@iol.unh.edu, dts@dpdk.org, lijuan.tu@intel.com Cc: shall@iol.unh.edu, lihongx.ma@intel.com, lylavoie@iol.unh.edu, zhaoyan.chen@intel.com, yuan.peng@intel.com Date: Fri, 23 Oct 2020 19:28:59 -0400 Message-Id: <20201023232903.37387-4-ohilyard@iol.unh.edu> X-Mailer: git-send-email 2.25.1 In-Reply-To: <20201023232903.37387-3-ohilyard@iol.unh.edu> References: <20201023232903.37387-1-ohilyard@iol.unh.edu> <20201023232903.37387-2-ohilyard@iol.unh.edu> <20201023232903.37387-3-ohilyard@iol.unh.edu> MIME-Version: 1.0 Subject: [dts] [PATCH v2 4/7] rte flow: add more specifc data structures X-BeenThere: dts@dpdk.org X-Mailman-Version: 2.1.15 Precedence: list List-Id: test suite reviews and discussions List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Errors-To: dts-bounces@dpdk.org Sender: "dts" The reason that all of this is broken off from flow_pattern_items and flow_action_items is that those are both 1000 line+ files. Signed-off-by: Owen Hilyard --- framework/flow/flow_items.py | 116 +++++++++++++++++++++++++++++++++++ framework/flow/flow_rule.py | 64 +++++++++++++++++++ 2 files changed, 180 insertions(+) create mode 100644 framework/flow/flow_items.py create mode 100644 framework/flow/flow_rule.py diff --git a/framework/flow/flow_items.py b/framework/flow/flow_items.py new file mode 100644 index 0000000..d7be345 --- /dev/null +++ b/framework/flow/flow_items.py @@ -0,0 +1,116 @@ +# BSD LICENSE +# +# Copyright(c) 2020 Intel Corporation. All rights reserved. +# Copyright © 2018[, 2019] The University of New Hampshire. All rights reserved. +# All rights reserved. +# +# Redistribution and use in source and binary forms, with or without +# modification, are permitted provided that the following conditions +# are met: +# +# * Redistributions of source code must retain the above copyright +# notice, this list of conditions and the following disclaimer. +# * Redistributions in binary form must reproduce the above copyright +# notice, this list of conditions and the following disclaimer in +# the documentation and/or other materials provided with the +# distribution. +# * Neither the name of Intel Corporation nor the names of its +# contributors may be used to endorse or promote products derived +# from this software without specific prior written permission. +# +# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS +# "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT +# LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR +# A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT +# OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, +# SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT +# LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, +# DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY +# THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +# (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE +# OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + +from __future__ import annotations + +import copy +import itertools +from functools import reduce +from typing import FrozenSet, Union, Any, Set, Dict, Tuple, Iterable, Hashable + +from flow.enums import FlowItemType, FlowActionType +from flow.exceptions import InvalidFlowItemException +from flow import flow_action_items +from flow import flow_pattern_items + +PATTERN_ACTION_ITEMS = {FlowItemType.INVERT, FlowItemType.VOID, FlowItemType.MARK, FlowItemType.META} + + +class FlowItem(object): + type: Union[FlowItemType, FlowActionType] + # Defines what items this may not appear with + allowed_with: FrozenSet[Union[FlowItemType, FlowActionType]] + # OSI Model layer of the protocol + # This should be the lowest layer a protocol is used in, for example + # QUIC would be considered L5 since it needs to go after UDP (L4), + # even though it has capabilities in L6. + layer: int + valid_next_items: FrozenSet[Union[FlowItemType, FlowActionType]] + + # Types subject to change, should only be accessed through + possible_properties: Dict[str, Tuple[str, FrozenSet[str], FrozenSet[str]]] + properties: str + + def get_property_stream(self) -> Iterable[Tuple[FlowItem, FrozenSet[str], FrozenSet[str], str]]: + """ + This function will return a generator that will provide all + configured property combinations. + + This function will not mutate the instance it is called on. + + @return: a generator that will provide all + permutations of possible properties this object has as a flow + item with properties + """ + base_copy = copy.deepcopy(self) + for key, value in self.possible_properties.items(): + new_copy = copy.deepcopy(base_copy) + new_copy.properties = value[0] # The properties string + yield new_copy, *value[1:], f"{self.type.value}_{key}" + + def __init__(self): + self.properties = "" + + def __truediv__(self, other: FlowItem): + """ + Used in a similar way to scapy's packet composition. + @param other: The other flow item. + @return: A Flow containing both items + """ + if type(self) != type(other): + raise InvalidFlowItemException(self, other) + elif other.type in self.valid_next_items: + # This import is in here so there is no circular import + from flow.flow import Flow + if isinstance(self, flow_pattern_items.PatternFlowItem): + return Flow(pattern_items=[self, other]) + elif isinstance(self, flow_action_items.ActionFlowItem): + return Flow(action_items=[self, other]) + else: + raise TypeError( + f"{type(self):s} is not one of {flow_pattern_items.PatternFlowItem:s}, {flow_action_items.ActionFlowItem:s}.") + else: + raise InvalidFlowItemException(self, other) + + def __eq__(self, other) -> bool: + return type(self) == type(other) and \ + self.type == other.type and \ + self.properties == other.properties + + def __str__(self): + if self.properties != "": + return self.properties + else: + return self.type.value + + def __repr__(self): + return str(self) diff --git a/framework/flow/flow_rule.py b/framework/flow/flow_rule.py new file mode 100644 index 0000000..361afae --- /dev/null +++ b/framework/flow/flow_rule.py @@ -0,0 +1,64 @@ +# BSD LICENSE +# +# Copyright(c) 2020 Intel Corporation. All rights reserved. +# Copyright © 2018[, 2019] The University of New Hampshire. All rights reserved. +# All rights reserved. +# +# Redistribution and use in source and binary forms, with or without +# modification, are permitted provided that the following conditions +# are met: +# +# * Redistributions of source code must retain the above copyright +# notice, this list of conditions and the following disclaimer. +# * Redistributions in binary form must reproduce the above copyright +# notice, this list of conditions and the following disclaimer in +# the documentation and/or other materials provided with the +# distribution. +# * Neither the name of Intel Corporation nor the names of its +# contributors may be used to endorse or promote products derived +# from this software without specific prior written permission. +# +# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS +# "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT +# LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR +# A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT +# OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, +# SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT +# LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, +# DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY +# THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +# (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE +# OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + +from typing import Union + +from flow.enums import * +from flow.flow import Flow +import flow.flow_action_items as flow_action_items + + +class FlowPattern(Flow): + entry_points = {FlowItemType.ETH, FlowItemType.FUZZY} + + def __str__(self): + return f"pattern {super(FlowPattern, self).__str__()} / end" + + +class FlowActions(Flow): + entry_points = flow_action_items.ENTRY_POINTS + + def __str__(self): + return f"action {super(FlowActions, self).__str__()} / end" + + +class FlowRule(object): + port: int + group: Union[int, None] + priority: Union[int, None] + + ingress: bool + egress: bool + transfer: bool + + pattern: FlowPattern + actions: FlowActions