illumio-pylo 0.2.5__py3-none-any.whl

illumio_pylo/Service.py

@@ -0,0 +1,256 @@
+import illumio_pylo as pylo
+from .API.JsonPayloadTypes import ServiceHrefRef
+from illumio_pylo import log
+from .Helpers import *
+from typing import *
+
+
+class PortMap:
+    def __init__(self):
+        self._tcp_map = []
+        self._udp_map = []
+        self._protocol_map = {}
+
+    def add(self, protocol, start_port: int, end_port: int = None, skip_recalculation=False):
+
+        proto = None
+
+        if type(protocol) is str:
+            lower = protocol.lower()
+            if lower == 'tcp':
+                proto = 6
+            elif lower == 'udp':
+                proto = 17
+            else:
+                raise pylo.PyloEx("Unsupported protocol name '{}'".format(protocol))
+        else:
+            proto = protocol
+
+        if proto != 6 and proto != 17:
+            self._protocol_map[proto] = True
+            return
+
+        if start_port is None:
+            end_port = start_port
+
+        new_entry = [start_port, end_port]
+
+        if not skip_recalculation:
+            self.merge_overlapping_maps()
+
+    def merge_overlapping_maps(self):
+        self._sort_maps()
+
+        new_map = []
+
+        cur_entry = None
+
+        for original_entry in self._tcp_map:
+            if cur_entry is None:
+                cur_entry = original_entry
+                continue
+
+            cur_start = cur_entry[0]
+            cur_end = cur_entry[1]
+            new_start = original_entry[0]
+            new_end = original_entry[1]
+
+            if new_start > cur_end + 1:
+                new_map.append(cur_entry)
+                continue
+
+            if new_end > cur_end:
+                cur_entry[1] = new_end
+
+        if cur_entry is not None:
+            self._tcp_map = []
+        else:
+            new_map.append(cur_entry)
+            self._tcp_map = new_map
+
+        new_map = []
+
+        for original_entry in self._udp_map:
+            if cur_entry is None:
+                cur_entry = original_entry
+                continue
+
+            cur_start = cur_entry[0]
+            cur_end = cur_entry[1]
+            new_start = original_entry[0]
+            new_end = original_entry[1]
+
+            if new_start > cur_end + 1:
+                new_map.append(cur_entry)
+                continue
+
+            if new_end > cur_end:
+                cur_entry[1] = new_end
+
+        if cur_entry is not None:
+            self._udp_map = []
+        else:
+            new_map.append(cur_entry)
+            self._udp_map = new_map
+
+    def _sort_maps(self):
+        def first_entry(my_list):
+            return my_list[0]
+
+        self._tcp_map.sort(key=first_entry)
+        self._udp_map.sort(key=first_entry)
+
+
+class ServiceEntry:
+    def __init__(self, protocol: int, port: int = None, to_port: Optional[int] = None, icmp_code: Optional[int] = None,
+                 icmp_type: Optional[int] = None):
+        self.protocol = protocol
+        self.port: int = port
+        self.to_port: Optional[int] = to_port
+        self.icmp_type: Optional[int] = icmp_type
+        self.icmp_code: Optional[int] = icmp_code
+
+    @staticmethod
+    def create_from_json(data: Dict):
+        protocol = data['proto']
+        if protocol == 1:
+            icmp_code = data['icmp_code']
+            icmp_type = data['icmp_type']
+            entry = ServiceEntry(protocol, icmp_code=icmp_code, icmp_type=icmp_type)
+        elif protocol == 17 or protocol == 6:
+            port = data['port']
+            to_port = data.get('to_port')
+            entry = ServiceEntry(protocol, port=port, to_port=to_port)
+        else:
+            entry = ServiceEntry(protocol)
+
+        return entry
+
+    def is_tcp(self) -> bool:
+        return self.protocol == 6
+
+    def is_udp(self) -> bool:
+        return self.protocol == 17
+
+    def to_string_standard(self, protocol_first=True) -> str:
+
+        if self.protocol == -1:
+            return 'All Services'
+
+        if protocol_first:
+            if self.protocol == 17:
+                if self.to_port is None:
+                    return 'udp/' + str(self.port)
+                return 'udp/' + str(self.port) + '-' + str(self.to_port)
+            elif self.protocol == 6:
+                if self.to_port is None:
+                    return 'tcp/' + str(self.port)
+                return 'tcp/' + str(self.port) + '-' + str(self.to_port)
+
+            return 'proto/' + str(self.protocol)
+
+        if self.protocol == 17:
+            if self.to_port is None:
+                return str(self.port) + '/udp'
+            return str(self.port) + '-' + str(self.to_port) + '/udp'
+        elif self.protocol == 6:
+            if self.to_port is None:
+                return str(self.port) + '/tcp'
+            return str(self.port) + '-' + str(self.to_port) + '/tcp'
+
+        return str(self.protocol) + '/proto'
+
+
+class Service(pylo.ReferenceTracker):
+
+    def __init__(self, name: str, href: str, owner: 'pylo.ServiceStore'):
+        pylo.ReferenceTracker.__init__(self)
+
+        self.owner: 'pylo.ServiceStore' = owner
+        self.name: str = name
+        self.href: str = href
+
+        self.entries: List['pylo.ServiceEntry'] = []
+
+        self.description: Optional[str] = None
+        self.processName: Optional[str] = None
+
+        self.deleted: bool = False
+
+        self.raw_json = None
+
+    def load_from_json(self, data):
+        self.raw_json = data
+        self.description = data['description']
+
+        self.processName = data['process_name']
+
+        service_ports = data.get('service_ports')
+        if service_ports is not None:
+            for entry_data in data['service_ports']:
+                entry = ServiceEntry.create_from_json(entry_data)
+                self.entries.append(entry)
+
+        if data['deleted_at'] is not None:
+            self.deleted = True
+
+    def get_api_reference_json(self) -> ServiceHrefRef:
+        return {'service': {'href': self.href}}
+
+    def get_entries_str_list(self, protocol_first=True) -> List[str]:
+        result: List[str] = []
+        for entry in self.entries:
+            result.append(entry.to_string_standard(protocol_first=protocol_first))
+        return result
+
+
+class ServiceStore(pylo.Referencer):
+    itemsByName: Dict[str, Service]
+    itemsByHRef: Dict[str, Service]
+
+    def __init__(self, owner):
+        """:type owner: pylo.Organization"""
+        pylo.Referencer.__init__(self)
+        self.owner = owner
+        self.itemsByHRef = {}
+        self.itemsByName = {}
+
+        self.special_allservices = pylo.Service('All Services', '/api/v1/orgs/1/sec_policy/draft/services/1', self)
+
+    def load_services_from_json(self, json_list):
+        for json_item in json_list:
+            if 'name' not in json_item or 'href' not in json_item:
+                raise Exception("Cannot find 'value'/name or href for service in JSON:\n" + nice_json(json_item))
+            new_item_name = json_item['name']
+            new_item_href = json_item['href']
+
+            new_item = pylo.Service(new_item_name, new_item_href, self)
+            new_item.load_from_json(json_item)
+
+            if new_item_href in self.itemsByHRef:
+                raise Exception("A service with href '%s' already exists in the table", new_item_href)
+
+            self.itemsByHRef[new_item_href] = new_item
+            self.itemsByName[new_item_name] = new_item
+
+            log.debug("Found service '%s' with href '%s'", new_item_name, new_item_href)
+            
+    @property
+    def services(self) -> List[Service]:
+        return list(self.itemsByHRef.values())
+    
+    def services_dict_by_href(self) -> Dict[str, Service]:
+        return self.itemsByHRef.copy()
+    
+    def find_by_name(self, name: str, case_sensitive=True) -> Optional[Service]:
+        if not case_sensitive:
+            name = name.lower()
+            for item in self.itemsByName:
+                if item.lower() == name:
+                    return self.itemsByName[item]
+            return None
+        else:
+            return self.itemsByName.get(name)
+        
+    def find_by_href(self, href: str) -> Optional[Service]:
+        return self.itemsByHRef.get(href)

illumio_pylo/SoftwareVersion.py

@@ -0,0 +1,125 @@
+from .Helpers import *
+import re
+
+version_regex = re.compile(r"^(?P<major>[0-9]+)\.(?P<middle>[0-9]+)\.(?P<minor>[0-9]+)(-(?P<build>[0-9]+))?(.*)?$")
+
+
+class SoftwareVersion:
+
+    """
+    :type version_string: str
+    """
+
+    def __init__(self, version_string: str):
+        self.version_string = version_string
+
+        self.is_unknown = False
+        self.major = 0
+        self.middle = 0
+        self.minor = 0
+        self.build = 0
+
+        if version_string.lower() == 'unknown':
+            self.is_unknown = True
+            return
+
+        match = version_regex.match(version_string)
+
+        if match is None:
+            raise pylo.PyloEx("version_string has invalid version format: {}".format(version_string))
+
+        self.major = int(match.group("major"))
+        self.middle = int(match.group("middle"))
+        self.minor = int(match.group("minor"))
+        build = match.group("build")
+        if build is None:
+            self.build = 0
+        else:
+            self.build = int(match.group("build"))
+
+    def is_greater_than(self, target_version: 'pylo.SoftwareVersion'):
+        if self.major > target_version.major:
+            return True
+        if target_version.major == self.major:
+            if self.middle > target_version.middle:
+                return True
+            if target_version.middle == self.middle:
+                if self.minor > target_version.minor:
+                    return True
+                if target_version.minor == self.minor:
+                    if self.build > target_version.build:
+                        return True
+
+        return False
+
+    def is_greater_or_equal_than(self, target_version: 'pylo.SoftwareVersion'):
+        if self.major > target_version.major:
+            return True
+        if target_version.major == self.major:
+            if self.middle > target_version.middle:
+                return True
+            if target_version.middle == self.middle:
+                if self.minor > target_version.minor:
+                    return True
+                if target_version.minor == self.minor:
+                    if self.build >= target_version.build:
+                        return True
+
+        return False
+
+    def is_lower_than(self, target_version: 'pylo.SoftwareVersion'):
+        if self.major < target_version.major:
+            return True
+        if target_version.major == self.major:
+            if self.middle < target_version.middle:
+                return True
+            if target_version.middle == self.middle:
+                if self.minor < target_version.minor:
+                    return True
+                if target_version.minor == self.minor:
+                    if self.build < target_version.build:
+                        return True
+        return False
+
+    def is_lower_or_equal_than(self, target_version: 'pylo.SoftwareVersion'):
+        if self.major < target_version.major:
+            return True
+        if target_version.major == self.major:
+            if self.middle < target_version.middle:
+                return True
+            if target_version.middle == self.middle:
+                if self.minor < target_version.minor:
+                    return True
+                if target_version.minor == self.minor:
+                    if self.build <= target_version.build:
+                        return True
+        return False
+
+    def equals(self, target_version: 'pylo.SoftwareVersion'):
+        if target_version.major == self.major and target_version.middle == self.middle and \
+                target_version.minor == self.minor and target_version.build == self.build:
+            return True
+        return False
+
+    def __lt__(self, other):
+        return self.is_lower_than(other)
+
+    def __le__(self, other):
+        return self.is_lower_or_equal_than(other)
+
+    def __gt__(self, other):
+        return self.is_greater_than(other)
+
+    def __ge__(self, other):
+        return self.is_greater_or_equal_than(other)
+
+    def __eq__(self, target_version):
+        if target_version.major == self.major and target_version.middle == self.middle and \
+                target_version.minor == self.minor and target_version.build == self.build:
+            return True
+        return False
+
+    def generate_str_from_numbers(self):
+        return "{}.{}.{}-{}".format(self.major, self.middle, self.minor, self.build)
+
+

illumio_pylo/VirtualService.py

@@ -0,0 +1,17 @@
+from typing import Optional
+from .API.JsonPayloadTypes import VirtualServiceObjectJsonStructure
+import illumio_pylo as pylo
+
+
+class VirtualService(pylo.ReferenceTracker):
+    def __init__(self, name: str, href: str, owner: 'pylo.VirtualServiceStore'):
+        pylo.ReferenceTracker.__init__(self)
+        self.owner = owner
+        self.name: str = name
+        self.href: str = href
+
+        self.raw_json: Optional[VirtualServiceObjectJsonStructure] = None
+
+    def load_from_json(self, data: VirtualServiceObjectJsonStructure):
+        self.raw_json = data
+

illumio_pylo/VirtualServiceStore.py

@@ -0,0 +1,75 @@
+from typing import Dict, List, Optional
+import illumio_pylo as pylo
+from illumio_pylo import log
+from .API.JsonPayloadTypes import VirtualServiceObjectJsonStructure
+
+
+class VirtualServiceStore:
+
+    def __init__(self, owner: 'pylo.Organization'):
+        self.owner: 'pylo.Organization' = owner
+        self.items_by_href: Dict[str, 'pylo.VirtualService'] = {}
+        self.itemsByName: Dict[str, 'pylo.VirtualService'] = {}
+
+    def load_virtualservices_from_json(self, json_list: List[VirtualServiceObjectJsonStructure]):
+        for json_item in json_list:
+            if 'name' not in json_item or 'href' not in json_item:
+                raise pylo.PyloEx(
+                    "Cannot find 'value'/name or href for VirtualService in JSON:\n" + pylo.nice_json(json_item))
+
+            new_item_name = json_item['name']
+            new_item_href = json_item['href']
+
+            new_item = pylo.VirtualService(new_item_name, new_item_href, self)
+            new_item.load_from_json(json_item)
+
+            if new_item_href in self.items_by_href:
+                raise pylo.PyloEx("A VirtualService with href '%s' already exists in the table", new_item_href)
+
+            if new_item_name in self.itemsByName:
+                raise pylo.PyloEx(
+                    "A VirtualService with name '%s' already exists in the table. This UID:%s vs other UID:%s" % (
+                        new_item_name, new_item_href, self.itemsByName[new_item_name].href)
+                )
+
+            self.items_by_href[new_item_href] = new_item
+            self.itemsByName[new_item_name] = new_item
+
+            log.debug("Found VirtualService '%s' with href '%s'", new_item_name, new_item_href)
+            
+    @property
+    def virtual_services(self) -> List['pylo.VirtualService']:
+        return list(self.items_by_href.values())
+    
+    @property
+    def virtual_services_by_href(self) -> Dict[str, 'pylo.VirtualService']:
+        return self.items_by_href.copy()
+            
+    def find_by_href(self, href: str) -> Optional['pylo.VirtualService']:
+        return self.items_by_href.get(href)
+    
+    def find_by_name(self, name: str, case_sensitive: bool = True) -> Optional['pylo.VirtualService']:
+        if case_sensitive:
+            return self.itemsByName.get(name)
+        else:
+            for item in self.itemsByName.values():
+                if item.name.lower() == name.lower():
+                    return item
+            return None
+
+    def find_by_href_or_create_tmp(self, href: str, tmp_name: str) -> 'pylo.VirtualService':
+        """
+        Mostly used for deleted objects/developers speficic use cases when load imcomplete or partial PCE objects
+        """
+        find_object = self.find_by_href(href)
+        if find_object is not None:
+            return find_object
+
+        new_tmp_item = pylo.VirtualService(tmp_name, href, self)
+        new_tmp_item.deleted = True
+        new_tmp_item.temporary = True
+
+        self.items_by_href[href] = new_tmp_item
+        self.itemsByName[tmp_name] = new_tmp_item
+
+        return new_tmp_item