def __contains__(self, key): if not isinstance(key, self.__class__): raise_type_exception(key, (self.__class__,), 'test membership of') for side in ('source', 'destination'): if getattr(key, side) not in getattr(self, side): return False return True
def _type_initialization(value, cls): if value is None: value = cls() elif not isinstance(value, cls): value = cls.from_string(value) if not isinstance(value, cls): raise_type_exception(value, (cls, ), 'build from') return value
def _clean_group(cls, value): if value is not None: if isinstance(value, basestring): value = cls._group_from_string(value) if not isinstance(value, cls._group_type): raise_type_exception(value, (cls._group_type,), 'set') else: value = cls._group_type() return value
def __eq__(self, key): if not isinstance(key, self.__class__): raise_type_exception(key, (self.__class__, ), 'test equality of') if key.permit == self.permit: if key.logging == self.logging: if isinstance(key.transport, type(self.transport)) and \ key.transport == self.transport: return key.network == self.network return False
def __contains__(self, key): value = key if not isinstance(key, (basestring, int, LoggingFacility)): raise_type_exception(key, (LoggingFacility), 'test memebership of') if not isinstance(key, LoggingFacility): value = self.from_string(value) if key.level is None and self.level is not None: return False return value.level <= self.level
def from_string(cls, value): if isinstance(value, cls): return value elif isinstance(value, basestring): value = cls._clean_address(value) group = cls() group.add(value) return group raise_type_exception(value, (str, unicode), 'build from')
def __contains__(self, key): if not isinstance(key, self.__class__): raise_type_exception(key, (self.__class__, ), 'test membership of') if key.permit == self.permit: if key.logging in self.logging: if self._transport is None or \ (isinstance(key.transport, type(self.transport)) and key.transport in self.transport): return key.network in self.network return False
def address_builder(value): if isinstance(value, (basestring)): try: value = IPv4Interface(unicode(value)).network except AddressValueError: message = 'Unsupported string initialization format \'{}\'' message = message.format(value) raise ValueError(message) elif not isinstance(value, IPv4Network): raise_type_exception(value, (IPv4Network, ), 'build with') return value
def __eq__(self, key): if isinstance(key, basestring): key = self.from_string(key) if not isinstance(key, self.__class__): raise_type_exception(key, (self.__class__, ), 'test equality of') if len(key) == self.__len__(): for address in self._addresses: if not key.has(address): return False return True return False
def __eq__(self, key): if not isinstance(key, Acl): raise_type_exception(key, (Acl, ), 'test equality of') if len(key) == len(self) and key.default_permit == self.default_permit: for key_ace in key._aces: for self_ace in self._aces: if self_ace == key_ace: break else: return False return True return False
def from_string(cls, value): if isinstance(value, basestring): value = cls._clean_build_string(value) values = value.split() if len(values) == 2: envelope = cls() for index, side in enumerate(('source', 'destination')): address_group = cls._group_from_string(values[index]) setattr(envelope, side, address_group) return envelope message = 'Unsupported string initialization format \'{}\'' message = message.format(value) raise ValueError(message) raise_type_exception(value, (str, unicode), 'build from')
def __contains__(self, key): if isinstance(key, basestring): if key.isdigit(): key = int(key) else: key = self.from_string(key) if isinstance(key, self.__class__): return self.low <= key.low and self.high >= key.high elif issubclass(key.__class__, TransportAddress): return False elif isinstance(key, int): nu.validate._port(key, raise_exception=True) return self.low <= key and self.high >= key raise_type_exception(key, (self.__class__, ), 'test membership of')
def __contains__(self, key): if not isinstance(key, (Acl, Ace)): raise_type_exception(key, (Acl, Ace), 'test membership of') if isinstance(key, Ace): key_aces = (key, ) else: key_aces = key._aces for key_ace in key_aces: for self_ace in self._aces: if key_ace in self_ace: break else: return False return True
def __contains__(self, key): valid_types = self._address_type + (self.__class__, ) if not isinstance(key, valid_types): key = self.address_builder(key) if not isinstance(key, valid_types): raise_type_exception(key, valid_types, 'test membership of') if isinstance(key, self.__class__): return self._contains_address_group(key) elif isinstance(key, self._address_type): for address in self.addresses: if self._is_member(key, address): return True return False else: raise_type_exception(key, valid_types, 'membership') return False
def _test_permission(self, key): if not isinstance(key, (Ace, Acl)): raise_type_exception(key, (Acl, Ace, ), 'test permission of') if isinstance(key, Ace): key_aces = (key, ) else: key_aces = key._aces if len(self._aces) is 0: return self.default_permit for key_ace in key_aces: for self_ace in self._aces: if key_ace in self_ace and self_ace.permit: break else: return self.default_permit return True
def add(self, ace, line_number=None): if not isinstance(ace, Ace): raise_type_exception(ace, (Ace, ), 'add') if not isinstance(line_number, (int, type(None))): raise_type_exception(line_number, (int, ), 'add line number') for existing in self._aces: if ace == existing: return self._current_line += 1 if line_number is None: line_number = self._current_line if (line_number - 1) > len(self._aces): message = 'Line number {} higher than ACEs length {}' message = message.format(line_number, len(self._aces)) raise ValueError(message) ace._line_number = line_number self._aces.insert(line_number, ace)
def add(self, value, ip=None): """ Merges a value with existing host entry values """ if isinstance(value, basestring): value = Hostname(value, ip=ip) if not isinstance(value, Hostname): raise_type_exception(value, (Hostname, ), 'add') if value not in self._host_entries: raise ValueError('Host {} does not belong to {}'.format(value, self)) self._update_hostname_attributes(value) for entry in self._host_entries: if value.fqdn == entry.fqdn: if entry.ip == value.ip: # Full match found. Do nothing return self._add_hostname_new_ip(value) self._add_ip_new_hostname(value)
def add(self, value, ip=None): """ Merges a value with existing host entry values """ if isinstance(value, basestring): value = Hostname(value, ip=ip) if not isinstance(value, Hostname): raise_type_exception(value, (Hostname, ), 'add') if value not in self._host_entries: raise ValueError('Host {} does not belong to {}'.format( value, self)) self._update_hostname_attributes(value) for entry in self._host_entries: if value.fqdn == entry.fqdn: if entry.ip == value.ip: # Full match found. Do nothing return self._add_hostname_new_ip(value) self._add_ip_new_hostname(value)
def level(self, value): original_value = value if value is None: self._level = None return elif isinstance(value, basestring): value = value.strip().lower() if value.isdigit(): value = int(value) else: if value in self._level_names: value = self._level_names.index(value) else: message = 'No logging level name \'{}\''.format(original_value) raise ValueError(message) elif isinstance(value, int) and not isinstance(value, bool): if value not in range(len(self._level_names)): message = 'Invalid logging level {}'.format(original_value) raise ValueError(message) if not isinstance(value, int) or isinstance(value, bool): raise_type_exception(value, (int, str), 'set') self._level = value
def from_string(cls, value): if not isinstance(value, (basestring, int)): raise_type_exception(value, (cls, ), 'build from') return cls(value)
def remove(self, ace): if not isinstance(ace, Ace): raise_type_exception(ace, (Ace, ), 'remove') self._aces.remove(ace) self._current_line -= 1
def name(self, value): if value is None: value = None elif not isinstance(value, basestring): raise_type_exception(value, (str, ), 'set') self._name = value
def _validate_text(text): if not isinstance(text, (basestring, int)) or isinstance(text, bool): raise_type_exception(text, (str, unicode), 'build with') return True
def __eq__(self, key): if not isinstance(key, self.__class__): raise_type_exception(key, (self.__class__, ), 'test equality of') return self.source == key.source and self.destination == key.destination
def line_increment(self, value): if isinstance(value, basestring) and value.strip().isdigit(): value = int(value.strip()) if not isinstance(value, int): raise_type_exception(value, (int, ), 'set') self._line_increment = value
def _clean_port_string(cls, value): if not isinstance(value, basestring): raise_type_exception(value, (str, unicode), 'build with') return value.replace('-', ' ').replace(' ', ' ').strip()
def default_permit(self, value): if not isinstance(value, bool): raise_type_exception(value, (bool, ), 'set') self._default_permit = value
def __ne__(self, key): if not isinstance(key, self.__class__): raise_type_exception(key, (self.__class__, ), 'test equality of') return not self.__eq__(key)