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 _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 __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)
