def parse(cls, data):
out = {}
iterated = []
for k, v in data.items():
if k == 'apikey':
# API Key is always ignored
continue
elif k not in cls.base_validators:
raise Invalid('Unknown parameter "%s"' % k)
else:
error = None
try:
validator = cls.base_validators[k]
except Invalid as e:
error = str(e)
if error is not None:
raise Invalid('Invalid value for "%s": %s' % (
validator.name, error))
out[validator.name] = validator.validate(v)
iterated.append(k)
for k in [i for i in cls.base_validators if i not in iterated]:
validator = cls.base_validators[k]
if validator.required:
raise Invalid('"%s" is required parameter!' % validator.name)
out[validator.name] = validator.default
return out
def check(self, value):
if not value:
if not self.permit_empty:
raise Invalid('String cannot be empty!')
if self.length != None and len(value) > self.length:
raise Invalid("String is too long!")
if self.chars is not None:
if not all(c in self.chars for c in value):
raise Invalid("String contains non valid characters")
return value
def check(self, value):
if self.positive and value < 0:
raise Invalid("Integer %s is not positive" % value)
if self.max is not None:
if value > self.max:
raise Invalid("Integer %s is too big" % value)
if self.min is not None:
if value < self.min:
raise Invalid("Integer %s is too small" % value)
return value
def select_parser(cls, data):
types = {
'A': ARecordValidator,
'AAAA': AAAARecordValidator,
'MX': MXRecordValidator,
'NS': NSRecordValidator
}
if 'type' not in data:
raise Invalid('DNS-record must have type')
if data['type'] in types:
return types[data['type']]
raise Invalid('Unknown DNS record type %s' % data['type'])
def verify_value(self, value):
if len(value.strip()) == 0:
raise Invalid("Cannot accept zero-length value")
elif all(c in DNSRecordValidator.valid_characters for c in value):
is_ip, addr = cast_ip4addr(value)
if not is_ip: is_ip, addr = cast_ip6addr(value)
if is_ip:
raise Invalid("Cannot have IP address in value of %s" %
self.__class__.__name__)
else:
raise Invalid("Invalid characters in value of %s" %
self.__class__.__name__)
def check(self, value):
value = str(value)
if value.count(':') >= 2 and value.count(':') <= 7:
try:
ip = netaddr.IPAddress(value)
if ip.is_unicast():
return value
else:
raise Invalid("%s value '%s' is not an unicast IPv6-address" %
(self.name, value))
except AddrFormatError:
pass
raise Invalid("%s value '%s' is not valid IPv6-address" % (self.name,
value))
def get_dns_zone(user_id, domain_id, limit=None, offset=None):
if is_positive_numeric(user_id) is not True:
raise Invalid('User id must be positive integer')
elif is_positive_numeric(domain_id) is not True:
raise Invalid('User id must be positive integer')
zonequery = DNSZoneDatabase.query()
zonequery = zonequery.filter(DNSZoneDatabase.domain_id == domain_id)
zonequery = zonequery.filter(
DNSZoneDatabase.domain.has(DomainDatabase.user_id == user_id))
zonequery = do_limits(zonequery, limit, offset)
try:
return zonequery.one()
except NoResultFound:
pass
raise DoesNotExist("DNS entry for domain %s does not exist" % domain_id)
def delete_dns_zone(user_id, domain_id):
"""
Delete dns zone and all it's records
"""
if is_positive_numeric(user_id) is not True:
raise Invalid('User id must be positive integer')
elif is_positive_numeric(domain_id) is not True:
raise Invalid('User id must be positive integer')
zone = get_dns_zone(user_id, domain_id)
records = DNSRecordDatabase.query().filter(
DNSRecordDatabase.dns_zone_id == zone.id).all()
for record in records:
record.delete()
zone.delete()
return
def do_limits(query, limit, offset=None):
"""
Apply limit and offset to query
@raises Invalid: if limit is not None of positive integer
"""
if limit:
if is_positive_numeric(limit) is not True:
raise Invalid('Limit must be positive integer')
query = query.limit(int(limit))
if offset:
if is_positive_numeric(offset) is not True:
raise Invalid('Lower limit must be positive integer')
query = query.offset(int(offset))
return query
def cast(self, value):
if isinstance(value, int):
return value
elif isinstance(value, str):
if value.isnumeric():
return int(value)
raise Invalid("%s is not valid integer" % value)
def get(cls, id_):
if id_:
try:
id_ = int(id_)
except ValueError:
logger.error("Get with invalid database id %s" % id_)
raise Invalid('ID must be integer')
try:
c = dbsession.query(cls).filter(cls.id == id_).one()
except NoResultFound:
raise DoesNotExist('Object with id %d does not exist' % id_)
except SQLAlchemyError as e:
logger.exception(e)
raise DatabaseError('Cannot get object with id %d' % id_)
return c
raise Invalid('ID must be integer')
def validate(self):
"""
Validate this object
@returns true if object is valid
@raises Invalid if object is invalid
"""
raise Invalid("Dummy validator")
def get_domains(user_id=None, limit=None, offset=None):
query = DomainDatabase.query()
if user_id is not None:
if is_positive_numeric(user_id) is not True:
raise Invalid('User id must be positive integer')
query = query.filter(DomainDatabase.user_id == user_id)
query = do_limits(query, limit, offset)
return query.all()
def verify_ttl(self, ttl):
# ttl is either None or in range of [1,86400]
if ttl is not None:
mi = 1
ma = 86400
if not is_numeric_in_range(ttl, 1, 86400):
raise Invalid("Number out of required range for %s ([%i,%i])" %
(self.__class__.__name__, mi, ma))
def get_user_domains(user_id, limit=None, offset=None):
"""
Get user `user_id` domains.
@param user_id: user user_id
@type user_id: positive integer
@param limit: how many entries to return
@type limit: positive integer
@param offset: offset in limit
@type offset: positive integer
"""
if is_positive_numeric(user_id) is not True:
raise Invalid('User id must be positive integer')
return get_domains(user_id=user_id, limit=limit, offset=offset)
def add_user_dns_zone(user_id,
domain_id,
ttl,
retry,
refresh,
rname,
expire,
record_ttl,
comment=''):
if is_positive_numeric(user_id) is not True:
raise Invalid('User id must be positive integer')
elif is_positive_numeric(domain_id) is not True:
raise Invalid('User id must be positive integer')
domain_q = DomainDatabase.query()
domain_q = domain_q.filter(DomainDatabase.user_id == user_id)
domain_q = domain_q.filter(DomainDatabase.id == domain_id)
try:
domain = domain_q.one()
except NoResultFound:
raise DoesNotExist("Domain id=%s does not exist" % domain_id)
try:
get_dns_zone(user_id, domain_id)
raise AlreadyExist("DNS zone already added for domain id=%s" %
domain_id)
except DoesNotExist:
pass
zone = DNSZoneDatabase()
zone.domain_id = domain.id
zone.refresh = refresh
zone.retry = retry
zone.expire = expire
zone.ttl = ttl
zone.rname = rname
zone.record_ttl = record_ttl
zone.comment = comment
zone.save()
return zone
def check(self, value):
value = super().check(value)
value = value.lower()
if len(value) < 3:
raise Invalid("Domain must be at least 3 characters long")
elif '.' not in value:
raise Invalid("Domain must have at least one dot")
elif value.startswith('.'):
raise Invalid("Domain cannot begin with dot")
elif value.endswith('.') and '.' not in value[:-1]:
raise Invalid("Domain must have at least one dot in middle")
try:
value = value.encode("idna").decode("utf-8")
except:
raise Invalid("Domain '%s' contains invalid characters" % value)
allowed = string.ascii_lowercase + string.digits + '-_.'
if value != ''.join([i for i in value if i in allowed]):
raise Invalid("Domain '%s' contains invalid characters" % value)
return value
def verify_value(self, value):
res, ip = cast_ip6addr(value)
if not res or ip.version != 6:
raise Invalid("Invalid IPv6 Address for %s" %
self.__class__.__name__)
def verify_priority(self, priority):
mi = 0
mx = 1024
if not is_numeric_in_range(priority, 0, 1024):
raise Invalid("Invalid priority range [%i,%i] for %s" %
(self.__class__.__name__, mi, mx))
def cast(self, value):
if value is None:
return None
if isinstance(value, str):
return value
raise Invalid('"%s" is not valid string' % value)
def verify_priority(self, priority):
if priority is not None:
raise Invalid("Priority is invalid for %s" %
self.__class__.__name__)
def verify_value(self, value):
raise Invalid("Value check not implemented for %s" %
self.__class__.__name__)
def verify_key(self, key):
if not all(c in DNSRecordValidator.valid_characters
for c in key) or len(key.strip()) == 0:
raise Invalid("Invalid characters in key or zero-length of %s" %
self.__class__.__name__)
def check(self, value):
if value not in self.allowed_values:
raise Invalid("%s value '%s' is not allowed" % (self.name, value))
return value
def get_service_group_id(self):
if 'service_group_id' in self.__table__.columns:
return self.service_group_id
raise Invalid("No service_group_id")
def validate(self):
if len(self.name) > 50:
raise Invalid('Database name too long')
return True
def validate(self):
if len(self.name) > 50:
raise Invalid('Repository name too long')
return True