umnetdb-utils 0.1.4__py3-none-any.whl → 0.2.0__py3-none-any.whl

umnetdb_utils/utils.py

@@ -1,6 +1,26 @@
 import ipaddress
 import re
-def is_ip_address(input_str, version=None):
+
+from dataclasses import dataclass, field
+from copy import copy, deepcopy
+
+from typing import Optional, Union, List, Dict
+
+type IPAddress = Union[ipaddress.IPv4Address, ipaddress.IPv6Address]
+
+LOCAL_PROTOCOLS = [
+    "Access-internal",
+    "am",
+    "connected",
+    "direct",
+    "Direct",
+    "hmm",
+    "local",
+    "VPN",
+    "vrrpv3",
+]
+
+def is_ip_address(input_str:str, version:Optional[int]=None):
     try:
         ip = ipaddress.ip_address(input_str)
     except ValueError:
@@ -11,8 +31,8 @@ def is_ip_address(input_str, version=None):
 
     return True
 
-def is_ip_network(input_str, version=None):
- 
+
+def is_ip_network(input_str:str, version:Optional[int]=None):
     # First check that this is a valid IP or network
     try:
         net = ipaddress.ip_network(input_str)
@@ -21,19 +41,283 @@ def is_ip_network(input_str, version=None):
 
     if version and version != net.version:
         return False
-    
+
     return True
 
-def is_mac_address(input_str):
-    '''
+
+def is_mac_address(input_str:str):
+    """
     Validates the input string as a mac address. Valid formats are
     XX:XX:XX:XX:XX:XX, XX-XX-XX-XX-XX-XX, XXXX.XXXX.XXXX
     where 'X' is a hexadecimal digit (upper or lowercase).
-    '''
+    """
     mac = input_str.lower()
-    if re.match(r'[0-9a-f]{2}([-:])[0-9a-f]{2}(\1[0-9a-f]{2}){4}$', mac):
+    if re.match(r"[0-9a-f]{2}([-:])[0-9a-f]{2}(\1[0-9a-f]{2}){4}$", mac):
         return True
-    if re.match(r'[0-9a-f]{4}\.[0-9a-f]{4}\.[0-9a-f]{4}$', mac):
+    if re.match(r"[0-9a-f]{4}\.[0-9a-f]{4}\.[0-9a-f]{4}$", mac):
         return True
 
     return False
+
+
+@dataclass(order=True)
+class Packet:
+    """
+    Modeling a packet as it traverses the network
+    """
+
+    dst_ip: IPAddress
+    #ttl: int = 255
+    inner_dst_ip: Optional[IPAddress] = None
+    label_stack: Optional[list[int]] = None
+    vni: Optional[int] = None
+
+    def __str__(self):
+        if self.label_stack:
+            return f"MPLS: {self.label_stack}"
+        if self.vni:
+            return f"VXLAN: {self.dst_ip}:{self.vni}"
+        return f"{self.dst_ip}"
+
+    # def decrement_ttl(self):
+    #     new_packet = copy(self)
+    #     new_packet.ttl -= 1
+    #     return new_packet
+
+    def vxlan_encap(self, vni:int, tunnel_destination: ipaddress.IPv4Address) -> "Packet":
+        """
+        Return a copy of the existing packet, but with a vxlan encap
+        """
+        if self.vni or self.inner_dst_ip or self.label_stack:
+            raise ValueError(f"Can't encapsulate an already-encapsulated packet: {self}")
+        
+        # new_packet = deepcopy(self)
+        # new_packet.inner_dst_ip = self.dst_ip
+        # new_packet.vni = vni
+        # new_packet.dst_ip = tunnel_destination
+
+        # return new_packet
+        self.inner_dst_ip = self.dst_ip
+        self.vni = vni
+        self.dst_ip = tunnel_destination
+    
+    def vxlan_decap(self) -> "Packet":
+        """
+        Return a copy of the existing packet, but with a vxlan decap
+        """
+        if not self.vni or not self.inner_dst_ip or self.label_stack:
+            raise ValueError(f"Can't decap a non-VXLAN packet: {self}")
+        
+        # new_packet = deepcopy(self)
+        # new_packet.dst_ip = self.inner_dst_ip
+        # new_packet.vni = None
+        # new_packet.inner_dst_ip = None
+
+        # return new_packet
+        self.dst_ip = self.inner_dst_ip
+        self.vni = None
+        self.inner_dst_ip = None
+
+    def mpls_push(self, label:Union[int,list[int]]) -> "Packet":
+        """
+        Retrun a copy of the existing packet but with MPLS labels pushed on the stack
+        """
+        if self.vni or self.inner_dst_ip:
+            raise ValueError(f"Can't do mpls on a VXLAN packet: {self}")
+        
+        # new_packet = deepcopy(self)
+        # if not new_packet.label_stack:
+        #     new_packet.label_stack = []
+        
+        # if isinstance(label, int):
+        #     new_packet.label_stack.append(label)
+        # else:
+        #     new_packet.label_stack.extend(label)
+
+        # return new_packet
+        if not self.label_stack:
+            self.label_stack = []
+        
+        if isinstance(label, list):
+            self.label_stack.extend(label)
+        else:
+            self.label_stack.append(label)
+
+    def mpls_pop(self, num_pops:int=1) -> "Packet":
+        """
+        Return a copy of the existing packet but with MPLS label(s) popped
+        """
+        if not self.label_stack:
+            raise ValueError(f"Can't pop from an empty label stack!: {self}")
+        if len(self.label_stack) < num_pops:
+            raise ValueError(f"Can't pop {num_pops} labels from packet: {self}")
+        
+        # new_packet = copy(self)
+        # for _ in range(num_pops):
+        #     new_packet.label_stack.pop()
+
+        # return new_packet
+
+        for _ in range(num_pops):
+            self.label_stack.pop()
+
+
+    def mpls_swap(self, label:Union[int,list[int]]) -> "Packet":
+        """
+        Rerturn a copy of the existing packet but with MPLS label swap
+        """
+        if not self.label_stack:
+            raise ValueError(f"Can't pop from an empty label stack!: {self}")   
+
+        # new_packet = copy(self)
+        # new_packet.label_stack.pop()
+        # if isinstance(label, int):
+        #     new_packet.label_stack.append(label)
+
+        # # inconsistency in mpls table where this really should be a 'pop' but
+        # # it shows up as a single blank entry in a list.
+        # elif label == [""]:
+        #     new_packet.label_stack = []
+        # else:
+        #     new_packet.label_stack.extend(label)   
+        
+        # return new_packet
+        self.label_stack.pop()
+        if label == [""]:
+            self.lable_stack = []
+        elif isinstance(label, list):
+            self.label_stack.extend(label)
+        else:
+            self.label_stack.append(label)
+    
+    def is_encapped(self):
+        return bool(self.vni or self.label_stack)
+        
+
+@dataclass(order=True)
+class Hop:
+    """
+    A hop along the path and the corresponding packet at that location
+    """
+    router: str
+    vrf: str
+    interface: str
+    packet: Packet
+
+    _parent: "Hop" = field(init=False, compare=False, default=None)
+    _children: List["Hop"] = field(init=False, compare=False, default_factory=list)
+
+    def __str__(self):
+        vrf = "" if self.vrf == "default" else f" VRF {self.vrf}"
+        return f"{self.router}{vrf} {self.interface}, Packet: {self.packet}"
+
+    def copy(self):
+        return deepcopy(self)
+    
+    @classmethod
+    def unknown(self, packet=Packet):
+        """
+        Returns an "unknown" hop for a specific packet
+        """
+        return Hop("","","", packet)
+    
+    def is_unknown(self):
+        return self.router == ""
+
+    def __hash__(self):
+        return(hash(str(self)))
+    
+    def add_next_hop(self, other:"Hop"):
+        """
+        creates parent/child relationship between this hop and another one
+        """
+        self._children.append(other)
+        other._parent = self
+    
+
+
+class Path:
+    """
+    Keeps track of all our paths
+    """
+    def __init__(self, first_hop:Hop):
+
+        self.first_hop = first_hop
+        self.hops = {str(first_hop): first_hop}
+    
+    def add_hop(self, curr_hop:Hop, next_hop:Hop) -> bool:
+        """
+        Adds a hop to our current hop. If this is a new hop,
+        which means we're on a new path, returns true. Otherwise
+        returns false to indicate we don't have to walk this path
+        since it's a duplicate of another.
+        """
+
+        # if we've seen this hop already we will check for loops.
+        if str(next_hop) in self.hops:
+            new_path = False
+
+            # parent = self.curr_hop._parent
+            # while parent:
+            #     if parent == next_hop:
+            #         raise ValueError(f"Loop detected for {self.curr_hop} -> {next_hop}")
+            #     parent = parent._parent
+
+            self.hops[str(next_hop)]
+
+        else:
+            new_path = True
+            self.hops[str(next_hop)] = next_hop
+            
+        curr_hop.add_next_hop(next_hop)
+        return new_path
+    
+
+
+    def walk_path(self) -> Dict[int, List[Hop]]:
+        """
+        'Flattens' path from first hop to last into a dict
+        of list of hops keyed on hop number.
+        """
+        hop_num = 1
+        result = { hop_num: {self.first_hop}}
+        self._walk_path(self.first_hop, hop_num, result)
+        return result
+        
+            
+    def _walk_path(self, curr_hop, hop_num, result):
+        hop_num +=1
+        for child in curr_hop._children:
+            if hop_num not in result:
+                result[hop_num] = set()
+            result[hop_num].add(child)
+            self._walk_path(child, hop_num, result)
+
+ 
+    def print_path(self):
+        """
+        Prints out the path, hop by hop
+        """
+        for hop_num, hops in self.walk_path().items():
+            hop_list = list(hops)
+            hop_list.sort()
+            print(f"***** hop {hop_num} *****")
+            for hop in hop_list:
+                print(f"\t{hop}")
+
+
+    def get_path(self) -> list[dict]:
+        """
+        Returns hops as a list of dicts - for very basic displaying in
+        a table. In the future want to beef up the cli script
+        so that it can do nested tables, which is really
+        what we need for this.
+        """
+        result = []
+        for hop_num, hops in self.walk_path().items():
+            hop_list = list(hops)
+            hop_list.sort()
+            hop_str = "\n".join([str(h) for h in hop_list]) + "\n"              
+            result.append({'hop_num':hop_num, 'hops': hop_str})
+
+        return result

{umnetdb_utils-0.1.4.dist-info → umnetdb_utils-0.2.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: umnetdb-utils
-Version: 0.1.4
+Version: 0.2.0
 Summary: Helper classes for querying UMnet databases
 License: MIT
 Author: Amy Liebowitz
@@ -16,6 +16,7 @@ Requires-Dist: oracledb (>=3.1.0,<4.0.0)
 Requires-Dist: psycopg[binary] (>=3.2.9,<4.0.0)
 Requires-Dist: python-decouple (>=3.8,<4.0)
 Requires-Dist: sqlalchemy (>=2.0.41,<3.0.0)
+Requires-Dist: typer (>=0.16.0,<0.17.0)
 Description-Content-Type: text/markdown
 
 # umnetdb-utils

umnetdb_utils-0.2.0.dist-info/RECORD

@@ -0,0 +1,12 @@
+umnetdb_utils/__init__.py,sha256=YrT7drJ2MlU287z4--8EQI3fKLQZBlVxaCacU1yoDtg,132
+umnetdb_utils/base.py,sha256=LWVhrbShhuYekXZxwvhhVUkH6DHd_wnJ2QZ_zw3fKqM,6139
+umnetdb_utils/cli.py,sha256=tq_XxGrCWJacP3tzxTULPHeuvbh1AU_GHXHY1jkI4-U,3349
+umnetdb_utils/umnetdb.py,sha256=bzMwItOfCgpKhCGwmghqAyp9gKvckGsUIGvSJC1iUho,17122
+umnetdb_utils/umnetdisco.py,sha256=D9MiF_QrYznYL_ozLUmD1ASzkGDs1jqZ_XksNV7wW3o,8018
+umnetdb_utils/umnetequip.py,sha256=Nnh_YCcqGpYRp2KsS8qbAGJ9AgTeYB4umeYeP9_B-6A,5440
+umnetdb_utils/umnetinfo.py,sha256=vqFvLbIu7Wu650RTqzaELpbKhq6y91fgBXM5Q_elRl4,18443
+umnetdb_utils/utils.py,sha256=kAVLjX4UvN5VdllYPN2t-q386iDjsZZ-Bp8G_ZTchbI,9418
+umnetdb_utils-0.2.0.dist-info/METADATA,sha256=kkv7rHDme5K2VXBfe24KFg6qBOsezgLZc8XYku5dpwU,1595
+umnetdb_utils-0.2.0.dist-info/WHEEL,sha256=b4K_helf-jlQoXBBETfwnf4B04YC67LOev0jo4fX5m8,88
+umnetdb_utils-0.2.0.dist-info/entry_points.txt,sha256=nNmxVRlYLaeepjDKNCyARBF3d8igHtZGTVA_zoglevI,50
+umnetdb_utils-0.2.0.dist-info/RECORD,,

umnetdb_utils-0.2.0.dist-info/entry_points.txt

@@ -0,0 +1,3 @@
+[console_scripts]
+umnetdb=umnetdb_utils.cli:main
+

umnetdb_utils-0.1.4.dist-info/RECORD

@@ -1,10 +0,0 @@
-umnetdb_utils/__init__.py,sha256=QJaytbr4ccKESiwaKjpf1b4b8s2cHNfCDdnCOs1tmoI,131
-umnetdb_utils/base.py,sha256=aC5oKSB5Ox9QtylmHV2uvEUVUx4CRLZTgH6HpQJ6DZo,6064
-umnetdb_utils/umnetdb.py,sha256=IxqpAcPZn71HVV_oL3ryvbKS7cupUsyM6rJSGk6NLaU,4554
-umnetdb_utils/umnetdisco.py,sha256=Z2XwT79jKO_avd3w_z99DDEdAikrfKxYm1JYHRWqvG4,7841
-umnetdb_utils/umnetequip.py,sha256=jOW5kvk0FXtdHv8PA4rYT_PWfLdMiq83Mjwmy-c1DN8,5701
-umnetdb_utils/umnetinfo.py,sha256=MH1YDW4OWtHD46qfYb5Pv40vPSbL0GrMNW5gAhdlihE,18445
-umnetdb_utils/utils.py,sha256=wU6QMYfofj7trX3QeqXty0btbGdhP_RUaSqA7QTflFM,991
-umnetdb_utils-0.1.4.dist-info/METADATA,sha256=JI2hwHkX3B8y-GLwS0yywAiFszcqUlkiWUyga0A2KaY,1555
-umnetdb_utils-0.1.4.dist-info/WHEEL,sha256=b4K_helf-jlQoXBBETfwnf4B04YC67LOev0jo4fX5m8,88
-umnetdb_utils-0.1.4.dist-info/RECORD,,