def display_type(self, display=False) -> None: if display is True: self._display() elif display is False: if self.address_type == 0: machine_type = self.lang_dict['addr_types']['net'] elif self.address_type == 1: machine_type = self.lang_dict['addr_types']['mac'] elif self.address_type == 2: machine_type = self.lang_dict['addr_types']['bct'] else: machine_type = None temp = Utils.netr_to_literal(self.network_range) temp['address_type'] = machine_type print(temp)
def __display_subnets(self, advanced=False) -> None: if not self.__activated: return occupied, graph, t = self.__build_graph() literal_ip = Utils.to_literal(self.ip) literal_netr = Utils.netr_to_literal(self.__total_network_range) print(self.lang_dict['network']) if advanced is True: print(self.lang_dict['cidr_adv'].format(literal_ip, self.mask_length)) else: print(self.lang_dict['cidr'].format(literal_ip, self.mask_length)) print("{} - {}".format(literal_netr['start'], literal_netr['end'])) if advanced is True: print(self.lang_dict['addr_avail_advanced'].format(occupied, self.addresses)) else: print(self.lang_dict['addr_avail'].format(self.addresses)) print('') print(self.lang_dict['utils'].format(len(self.__subnets), t)) for i in range(len(self.__subnets)): literal_sub_netr = self.__subnets[i].displayable_network_range if advanced: print(self.lang_dict['sub_addr_advanced'].format(literal_sub_netr['start'], literal_sub_netr['end'], 2 ** self.__submasks_machine_bits[i] - 2, self.__subnets_sizes[i])) else: print(self.lang_dict['sub_addr'].format(literal_sub_netr['start'], literal_sub_netr['end'], 2 ** self.__submasks_machine_bits[i] - 2)) if advanced: print('') print(self.lang_dict['net_usage']) print(graph)
def network_raw_output(self): """ Returns a raw output of the local network """ final = {'subnets': {}, 'routers': {}} for sid in self.subnetworks: subnet = self.subnetworks[sid]['instance'] displayable_connected_routers = subnet.routers.copy() for i in displayable_connected_routers: displayable_connected_routers[i] = str( displayable_connected_routers[i]) final['subnets'][sid] = { 'id': subnet.uid, 'name': subnet.name, 'connected_routers': displayable_connected_routers, 'range': Utils.netr_to_literal(subnet.network_range), 'mask': subnet.mask_length } for rid in self.routers: router = self.routers[rid] displayable_connected_subnets = router.connected_networks.copy() for i in displayable_connected_subnets: displayable_connected_subnets[i] = str( displayable_connected_subnets[i]) final['routers'][rid] = { 'id': router.uid, 'name': router.name, 'connected_subnets': displayable_connected_subnets, 'internet': router.internet } return final
def displayable_network_range(self): return Utils.netr_to_literal(self.__network_range)
def display_range(self, display=False) -> None: if display is True: self._display() else: print(Utils.netr_to_literal(self.network_range))
def create_network(self, ip, mask_length, name=None): """ Creates a virtual subnetwork Args: ip: The given IP mask_length: The network mask length of the subnetwork name: The eventual name of the subnetwork """ uid = len(self.subnetworks) # Name correspondency if name: result = self.is_name_existing('subnet', name) if result: raise NameAlreadyExists(name) else: name = f"<Untitled Network#ID:{uid}>" current = self.Network(ip, mask_length, uid, name) current_netr = Utils.netr_to_literal(current.network_range) if self.ranges: for sid in self.subnetworks: subnet = self.subnetworks[sid]['instance'] subnetr = Utils.netr_to_literal(subnet.network_range) overlap = False if current.mask_length == subnet.mask_length: # Masks are equal if current_netr['start'] == subnetr['start']: overlap = True else: if current.mask_length < subnet.mask_length: # New network mask is bigger, check if the existing subnetwork is inside big = current_netr['start'].split('.') small = subnetr['start'] else: # New network is smaller that existing subnetwork, check if it is inside small = current_netr['start'] big = subnetr['start'].split('.') if current.mask_length <= 8: if int(big[0]) <= int(small.split('.')[0]): overlap = True elif 8 < current.mask_length <= 16: if small.startswith(f"{big[0]}") and int( big[1]) <= int(small.split('.')[1]): overlap = True elif 16 < current.mask_length <= 24: if small.startswith(f"{big[0]}.{big[1]}") and int( big[2]) <= int(small.split('.')[2]): overlap = True elif 24 < current.mask_length <= 32: if int(big[3]) <= int(small.split('.')[3]): overlap = True if overlap: raise OverlappingError(current_netr, subnetr) self.subnetworks[uid] = { 'instance': current, 'range': current.network_range } # adding to network ranges self.ranges.append(current.network_range) # also adding name if defined if name: self.subnets_names.append(name) return uid