def obj_create(self, bundle, request=None, **kwargs):
"""
A generic version of creating a dns object. The strategy is simple: get
bundle.data to the point where we call Class(**bundle.data) which
creates an object. We then clean it and then save it. Finally we save
any views that were in bundle.
"""
Klass = self._meta.object_class
kv = self.extract_kv(bundle)
# KV pairs should be saved after the object has been created
if bundle.errors:
self.error_response(bundle.errors, request)
views = self.extract_views(bundle)
# views should be saved after the object has been created
if bundle.errors:
self.error_response(bundle.errors, request)
bundle = self.full_hydrate(bundle)
if bundle.errors:
self.error_response(bundle.errors, request)
# Create the Object
try:
self.apply_commit(bundle.obj, bundle.data)
except ValueError, e:
if 'domain' in bundle.data:
prune_tree(bundle.data['domain'])
bundle.errors['error_messages'] = e.message
self.error_response(bundle.errors, request)
def _clean_domain_tree(domain):
if not domain.master_domain:
# They tried to create a TLD, prune_tree will not delete it.
domain.delete()
else:
domain.purgeable = True
prune_tree(domain) # prune_tree will delete this domain
def _clean_domain_tree(domain):
if not domain.master_domain:
# They tried to create a TLD, prune_tree will not delete it.
domain.delete()
else:
domain.purgeable = True
prune_tree(domain) # prune_tree will delete this domain
def save(self, *args, **kwargs):
self.full_clean()
if self.pk:
# We need to get the domain from the db. If it's not our current
# domain, call prune_tree on the domain in the db later.
db_domain = self.__class__.objects.get(pk=self.pk).domain
if self.domain == db_domain:
db_domain = None
else:
db_domain = None
no_build = kwargs.pop("no_build", False)
super(CydnsRecord, self).save(*args, **kwargs)
if no_build:
pass
else:
# Mark the soa
if self.domain.soa:
self.domain.soa.schedule_rebuild()
if db_domain:
from cyder.cydns.utils import prune_tree
prune_tree(db_domain)
def obj_create(self, bundle, request=None, **kwargs):
"""
A generic version of creating a dns object. The strategy is simple: get
bundle.data to the point where we call Class(**bundle.data) which
creates an object. We then clean it and then save it. Finally we save
any views that were in bundle.
"""
kv = self.extract_kv(bundle)
# KV pairs should be saved after the object has been created
if bundle.errors:
self.error_response(bundle.errors, request)
views = bundle.data.pop('views', [])
comment = bundle.data.pop('comment', '')
# views should be saved after the object has been created
if bundle.errors:
self.error_response(bundle.errors, request)
bundle = self.full_hydrate(bundle)
if bundle.errors:
self.error_response(bundle.errors, request)
# Create the Object
try:
self.apply_commit(bundle.obj, bundle.data)
except ValueError, e:
if 'domain' in bundle.data:
prune_tree(bundle.data['domain'])
bundle.errors['error_messages'] = e.message
self.error_response(bundle.errors, request)
def save(self, *args, **kwargs):
self.full_clean()
if self.pk:
# We need to get the domain from the db. If it's not our current
# domain, call prune_tree on the domain in the db later.
db_domain = self.__class__.objects.get(pk=self.pk).domain
if self.domain == db_domain:
db_domain = None
else:
db_domain = None
no_build = kwargs.pop("no_build", False)
super(CydnsRecord, self).save(*args, **kwargs)
if no_build:
pass
else:
# Mark the soa
if self.domain.soa:
self.domain.soa.schedule_rebuild()
if db_domain:
from cyder.cydns.utils import prune_tree
prune_tree(db_domain)
def test_basic_add_remove2(self):
# Make sure that if a domain is set to not purgeable the prune stops at
# that domain.
c = Domain.objects.create(name='edu')
self.assertFalse(c.purgeable)
f_c = Domain.objects.create(name='foo.edu')
s = SOA.objects.create(
primary="foo", contact="foo", root_domain=f_c,
description="foo.edu")
f_c = f_c.reload()
self.assertFalse(f_c.purgeable)
fqdn = "bar.x.y.z.foo.edu"
label, the_domain = ensure_label_domain(fqdn)
self.ctnr.domains.add(the_domain)
self.assertEqual(label, "bar")
self.assertEqual(the_domain.name, "x.y.z.foo.edu")
self.assertTrue(the_domain.purgeable)
self.assertEqual(the_domain.master_domain.name, "y.z.foo.edu")
self.assertTrue(the_domain.master_domain.purgeable)
self.assertEqual(
the_domain.master_domain.master_domain.name, "z.foo.edu")
self.assertTrue(the_domain.master_domain.master_domain.purgeable)
self.assertEqual(
the_domain.master_domain.master_domain.master_domain.name,
"foo.edu"
)
self.assertFalse(
the_domain.master_domain.master_domain.master_domain.purgeable)
# See if purgeable stops prune.
the_domain.purgeable = False
the_domain.save()
self.assertFalse(prune_tree(the_domain))
the_domain.purgeable = True
the_domain.save()
# OK, reset.
y_z = Domain.objects.get(name="y.z.foo.edu")
y_z.purgeable = False
y_z.save()
# Reload the domain.
the_domain = the_domain.reload()
# This should delete up to and stop at the domain "y.z.foo.edu".
self.assertTrue(prune_tree(the_domain))
self.assertFalse(Domain.objects.filter(name="x.y.z.foo.edu"))
self.assertTrue(Domain.objects.filter(name="y.z.foo.edu"))
self.assertTrue(Domain.objects.filter(name="z.foo.edu"))
self.assertTrue(Domain.objects.filter(name="foo.edu"))
# If we delete y.z.foo.com and then call prune on z.foo.com is should
# delete z.foo.com.
Domain.objects.get(name="y.z.foo.edu").delete()
self.assertTrue(prune_tree(Domain.objects.get(name="z.foo.edu")))
self.assertFalse(Domain.objects.filter(name="z.foo.edu"))
self.assertTrue(Domain.objects.filter(name="foo.edu"))
def test_basic_add_remove2(self):
# Make sure that if a domain is set to not purgeable the prune stops at
# that domain.
c = Domain.objects.create(name='edu')
self.assertFalse(c.purgeable)
f_c = Domain.objects.create(name='foo.edu')
s = SOA.objects.create(
primary="foo", contact="foo", root_domain=f_c,
description="foo.edu")
f_c = f_c.reload()
self.assertFalse(f_c.purgeable)
fqdn = "bar.x.y.z.foo.edu"
label, the_domain = ensure_label_domain(fqdn)
self.ctnr.domains.add(the_domain)
self.assertEqual(label, "bar")
self.assertEqual(the_domain.name, "x.y.z.foo.edu")
self.assertTrue(the_domain.purgeable)
self.assertEqual(the_domain.master_domain.name, "y.z.foo.edu")
self.assertTrue(the_domain.master_domain.purgeable)
self.assertEqual(
the_domain.master_domain.master_domain.name, "z.foo.edu")
self.assertTrue(the_domain.master_domain.master_domain.purgeable)
self.assertEqual(
the_domain.master_domain.master_domain.master_domain.name,
"foo.edu"
)
self.assertFalse(
the_domain.master_domain.master_domain.master_domain.purgeable)
# See if purgeable stops prune.
the_domain.purgeable = False
the_domain.save()
self.assertFalse(prune_tree(the_domain))
the_domain.purgeable = True
the_domain.save()
# OK, reset.
y_z = Domain.objects.get(name="y.z.foo.edu")
y_z.purgeable = False
y_z.save()
# Reload the domain.
the_domain = the_domain.reload()
# This should delete up to and stop at the domain "y.z.foo.edu".
self.assertTrue(prune_tree(the_domain))
self.assertFalse(Domain.objects.filter(name="x.y.z.foo.edu"))
self.assertTrue(Domain.objects.filter(name="y.z.foo.edu"))
self.assertTrue(Domain.objects.filter(name="z.foo.edu"))
self.assertTrue(Domain.objects.filter(name="foo.edu"))
# If we delete y.z.foo.com and then call prune on z.foo.com is should
# delete z.foo.com.
Domain.objects.get(name="y.z.foo.edu").delete()
self.assertTrue(prune_tree(Domain.objects.get(name="z.foo.edu")))
self.assertFalse(Domain.objects.filter(name="z.foo.edu"))
self.assertTrue(Domain.objects.filter(name="foo.edu"))
def test_basic_add_remove2(self):
# MAke sure that if a domain is set to not purgeable the prune stops at
# that domain.
c = Domain(name='edu')
c.save()
self.assertFalse(c.purgeable)
f_c = Domain(name='foo.edu')
s, _ = SOA.objects.get_or_create(primary="foo", contact="foo",
description="foo.edu")
f_c.soa = s
f_c.save()
self.assertFalse(f_c.purgeable)
fqdn = "bar.x.y.z.foo.edu"
label, the_domain = ensure_label_domain(fqdn)
self.assertEqual(label, "bar")
self.assertEqual(the_domain.name, "x.y.z.foo.edu")
self.assertTrue(the_domain.purgeable)
self.assertEqual(the_domain.master_domain.name, "y.z.foo.edu")
self.assertTrue(the_domain.master_domain.purgeable)
self.assertEqual(
the_domain.master_domain.master_domain.name, "z.foo.edu")
self.assertTrue(the_domain.master_domain.master_domain.purgeable)
self.assertEqual(
the_domain.master_domain.master_domain.master_domain.name,
"foo.edu"
)
self.assertFalse(
the_domain.master_domain.master_domain.master_domain.purgeable)
# See if purgeable stops prune
the_domain.purgeable = False
the_domain.save()
self.assertFalse(prune_tree(the_domain))
the_domain.purgeable = True
the_domain.save()
# Ok, reset
y_z = Domain.objects.get(name="y.z.foo.edu")
y_z.purgeable = False
y_z.save()
# Refresh the domain
the_domain = Domain.objects.get(pk=the_domain.pk)
# This should delete up to and stop at the domain "y.z.foo.edu"
self.assertTrue(prune_tree(the_domain))
self.assertFalse(Domain.objects.filter(name="x.y.z.foo.edu"))
self.assertTrue(Domain.objects.filter(name="y.z.foo.edu"))
self.assertTrue(Domain.objects.filter(name="z.foo.edu"))
self.assertTrue(Domain.objects.filter(name="foo.edu"))
# If we delete y.z.foo.com and then call prune on z.foo.com is should
# delete z.foo.com
Domain.objects.get(name="y.z.foo.edu").delete()
self.assertTrue(prune_tree(Domain.objects.get(name="z.foo.edu")))
self.assertFalse(Domain.objects.filter(name="z.foo.edu"))
self.assertTrue(Domain.objects.filter(name="foo.edu"))
def save_commit(self, request, bundle, views, kv):
try:
bundle.obj.full_clean()
bundle.obj.save()
except ValidationError, e:
if 'domain' in bundle.data:
prune_tree(bundle.data['domain'])
bundle.errors['error_messages'] = json.dumps(e.message_dict)
self.error_response(bundle.errors, request)
def save_commit(self, request, bundle, views, kv):
try:
bundle.obj.full_clean()
bundle.obj.save()
except ValidationError, e:
if 'domain' in bundle.data:
prune_tree(bundle.data['domain'])
bundle.errors['error_messages'] = json.dumps(e.message_dict)
self.error_response(bundle.errors, request)
def delete(self, *args, **kwargs):
self.schedule_zone_rebuild()
from cyder.cydns.utils import prune_tree
call_prune_tree = kwargs.pop('call_prune_tree', True)
objs_domain = self.domain
super(CydnsRecord, self).delete(*args, **kwargs)
if call_prune_tree:
prune_tree(objs_domain)
def delete(self, *args, **kwargs):
self.schedule_zone_rebuild()
from cyder.cydns.utils import prune_tree
call_prune_tree = kwargs.pop('call_prune_tree', True)
objs_domain = self.domain
super(CydnsRecord, self).delete(*args, **kwargs)
if call_prune_tree:
prune_tree(objs_domain)
def test_basic_add_remove5(self):
# Make sure all record types block
Domain.objects.create(name='foo22')
f_c = create_zone('foo.foo22')
self.assertFalse(f_c.purgeable)
fqdn = "bar.x.y.z.foo.foo22"
label, the_domain = ensure_label_domain(fqdn)
self.ctnr.domains.add(the_domain)
txt = TXT.objects.create(label=label,
ctnr=self.ctnr,
domain=the_domain,
txt_data="Nothing")
self.assertFalse(prune_tree(the_domain))
txt.delete()
label, the_domain = ensure_label_domain(fqdn)
self.ctnr.domains.add(the_domain)
addr = AddressRecord.objects.create(label=label,
ctnr=self.ctnr,
domain=the_domain,
ip_type='4',
ip_str="10.2.3.4")
self.assertFalse(prune_tree(the_domain))
addr.delete()
label, the_domain = ensure_label_domain(fqdn)
self.ctnr.domains.add(the_domain)
mx = MX.objects.create(label=label,
ctnr=self.ctnr,
domain=the_domain,
server="foo",
priority=4)
self.assertFalse(prune_tree(the_domain))
mx.delete()
label, the_domain = ensure_label_domain(fqdn)
self.ctnr.domains.add(the_domain)
ns = Nameserver.objects.create(domain=the_domain, server="asdfasffoo")
self.assertFalse(prune_tree(the_domain))
ns.delete()
label, the_domain = ensure_label_domain(fqdn)
self.ctnr.domains.add(the_domain)
srv = SRV.objects.create(label='_' + label,
ctnr=self.ctnr,
domain=the_domain,
target="foo",
priority=4,
weight=4,
port=34)
self.assertFalse(prune_tree(the_domain))
srv.delete()
def test_basic_add_remove5(self):
# Make sure all record types block
c = Domain(name='foo22')
c.save()
self.assertFalse(c.purgeable)
f_c = Domain(name='foo.foo22')
s, _ = SOA.objects.get_or_create(primary="foo",
contact="foo",
comment="foo.foo22")
f_c.soa = s
f_c.save()
self.assertFalse(f_c.purgeable)
fqdn = "bar.x.y.z.foo.foo22"
label, the_domain = ensure_label_domain(fqdn)
txt = TXT(label=label, domain=the_domain, txt_data="Nthing")
txt.save()
self.assertFalse(prune_tree(the_domain))
txt.delete()
label, the_domain = ensure_label_domain(fqdn)
addr = AddressRecord(label=label,
domain=the_domain,
ip_type='4',
ip_str="10.2.3.4")
addr.save()
self.assertFalse(prune_tree(the_domain))
addr.delete()
label, the_domain = ensure_label_domain(fqdn)
mx = MX(label=label, domain=the_domain, server="foo", priority=4)
mx.save()
self.assertFalse(prune_tree(the_domain))
mx.delete()
label, the_domain = ensure_label_domain(fqdn)
ns = Nameserver(domain=the_domain, server="asdfasffoo")
ns.save()
self.assertFalse(prune_tree(the_domain))
ns.delete()
label, the_domain = ensure_label_domain(fqdn)
srv = SRV(label='_' + label,
domain=the_domain,
target="foo",
priority=4,
weight=4,
port=34)
srv.save()
self.assertFalse(prune_tree(the_domain))
srv.delete()
def test_basic_add_remove4(self):
# Move a record down the tree testing prune's ability to not delete
# stuff.
c = Domain(name='goo')
c.save()
self.assertFalse(c.purgeable)
f_c = Domain(name='foo.goo')
s, _ = SOA.objects.get_or_create(primary="foo",
contact="foo",
comment="foo.goo")
f_c.soa = s
f_c.save()
self.assertFalse(f_c.purgeable)
fqdn = "bar.x.y.z.foo.goo"
label, the_domain = ensure_label_domain(fqdn)
txt = TXT(label=label, domain=the_domain, txt_data="Nthing")
txt.save()
self.assertTrue(the_domain.purgeable)
# txt makes the domain un-purgeable.
self.assertFalse(prune_tree(the_domain))
txt.domain = the_domain.master_domain
the_next_domain = the_domain.master_domain
txt.save()
self.assertFalse(Domain.objects.filter(pk=the_domain.pk))
# We should be able to delete now.
self.assertTrue(prune_tree(the_domain))
the_domain = the_next_domain
# txt makes the domain un-purgeable. y.z.foo.com
self.assertFalse(prune_tree(the_domain))
txt.domain = the_domain.master_domain
the_next_domain = the_domain.master_domain
txt.save()
self.assertFalse(Domain.objects.filter(pk=the_domain.pk))
# We should be able to delete now.
the_domain = the_next_domain
# txt makes the domain un-purgeable. z.foo.com
self.assertFalse(prune_tree(the_domain))
txt.domain = the_domain.master_domain
the_next_domain = the_domain.master_domain
txt.save()
self.assertFalse(Domain.objects.filter(pk=the_domain.pk))
# We should be able to delete now.
the_domain = the_next_domain
# txt makes the domain un-purgeable. foo.com
self.assertFalse(prune_tree(the_domain))
def test_basic_add_remove4(self):
# Move a record down the tree testing prune's ability to not delete
# stuff.
Domain.objects.create(name='goo')
f_c = create_zone('foo.goo')
self.assertFalse(f_c.purgeable)
fqdn = "bar.x.y.z.foo.goo"
label, the_domain = ensure_label_domain(fqdn)
self.ctnr.domains.add(the_domain)
txt = TXT.objects.create(label=label,
ctnr=self.ctnr,
domain=the_domain,
txt_data="Nothing")
self.assertTrue(the_domain.purgeable)
# txt makes the domain un-purgeable.
self.assertFalse(prune_tree(the_domain))
the_next_domain = the_domain.master_domain
txt.domain = the_next_domain
self.ctnr.domains.add(the_next_domain)
txt.save()
self.assertFalse(Domain.objects.filter(pk=the_domain.pk).exists())
# We should be able to delete now.
self.assertTrue(prune_tree(the_domain))
the_domain = the_next_domain
# txt makes the domain un-purgeable. y.z.foo.com
self.assertFalse(prune_tree(the_domain))
the_next_domain = the_domain.master_domain
txt.domain = the_next_domain
self.ctnr.domains.add(the_next_domain)
txt.save()
self.assertFalse(Domain.objects.filter(pk=the_domain.pk))
# We should be able to delete now.
the_domain = the_next_domain
# txt makes the domain un-purgeable. z.foo.com
self.assertFalse(prune_tree(the_domain))
the_next_domain = the_domain.master_domain
txt.domain = the_next_domain
self.ctnr.domains.add(the_next_domain)
txt.save()
self.assertFalse(Domain.objects.filter(pk=the_domain.pk).exists())
# We should be able to delete now.
the_domain = the_next_domain
# txt makes the domain un-purgeable. foo.com
self.assertFalse(prune_tree(the_domain))
def test_basic_add_remove4(self):
# Move a record down the tree testing prune's ability to not delete
# stuff.
c = Domain(name='goo')
c.save()
self.assertFalse(c.purgeable)
f_c = Domain(name='foo.goo')
s, _ = SOA.objects.get_or_create(primary="foo", contact="foo",
comment="foo.goo")
f_c.soa = s
f_c.save()
self.assertFalse(f_c.purgeable)
fqdn = "bar.x.y.z.foo.goo"
label, the_domain = ensure_label_domain(fqdn)
txt = TXT(label=label, domain=the_domain, txt_data="Nthing")
txt.save()
self.assertTrue(the_domain.purgeable)
# txt makes the domain un-purgeable.
self.assertFalse(prune_tree(the_domain))
txt.domain = the_domain.master_domain
the_next_domain = the_domain.master_domain
txt.save()
self.assertFalse(Domain.objects.filter(pk=the_domain.pk))
# We should be able to delete now.
self.assertTrue(prune_tree(the_domain))
the_domain = the_next_domain
# txt makes the domain un-purgeable. y.z.foo.com
self.assertFalse(prune_tree(the_domain))
txt.domain = the_domain.master_domain
the_next_domain = the_domain.master_domain
txt.save()
self.assertFalse(Domain.objects.filter(pk=the_domain.pk))
# We should be able to delete now.
the_domain = the_next_domain
# txt makes the domain un-purgeable. z.foo.com
self.assertFalse(prune_tree(the_domain))
txt.domain = the_domain.master_domain
the_next_domain = the_domain.master_domain
txt.save()
self.assertFalse(Domain.objects.filter(pk=the_domain.pk))
# We should be able to delete now.
the_domain = the_next_domain
# txt makes the domain un-purgeable. foo.com
self.assertFalse(prune_tree(the_domain))
def save(self, *args, **kwargs):
self.full_clean()
update_soa(self)
if self.pk:
# We need to get the domain from the db. If it's not our current
# domain, call prune_tree on the domain in the db later.
db_domain = self.__class__.objects.get(pk=self.pk).domain
if self.domain == db_domain:
db_domain = None
else:
db_domain = None
super(Nameserver, self).save(*args, **kwargs)
if db_domain:
from cyder.cydns.utils import prune_tree
prune_tree(db_domain)
def save(self, *args, **kwargs):
self.full_clean()
update_soa(self)
if self.pk:
# We need to get the domain from the db. If it's not our current
# domain, call prune_tree on the domain in the db later.
db_domain = self.__class__.objects.get(pk=self.pk).domain
if self.domain == db_domain:
db_domain = None
else:
db_domain = None
super(Nameserver, self).save(*args, **kwargs)
if db_domain:
from cyder.cydns.utils import prune_tree
prune_tree(db_domain)
def test_basic_add_remove4(self):
# Move a record down the tree testing prune's ability to not delete
# stuff.
Domain.objects.create(name='goo')
f_c = create_zone('foo.goo')
self.assertFalse(f_c.purgeable)
fqdn = "bar.x.y.z.foo.goo"
label, the_domain = ensure_label_domain(fqdn)
self.ctnr.domains.add(the_domain)
txt = TXT.objects.create(
label=label, ctnr=self.ctnr, domain=the_domain, txt_data="Nothing")
self.assertTrue(the_domain.purgeable)
# txt makes the domain un-purgeable.
self.assertFalse(prune_tree(the_domain))
the_next_domain = the_domain.master_domain
txt.domain = the_next_domain
self.ctnr.domains.add(the_next_domain)
txt.save()
self.assertFalse(Domain.objects.filter(pk=the_domain.pk).exists())
# We should be able to delete now.
self.assertTrue(prune_tree(the_domain))
the_domain = the_next_domain
# txt makes the domain un-purgeable. y.z.foo.com
self.assertFalse(prune_tree(the_domain))
the_next_domain = the_domain.master_domain
txt.domain = the_next_domain
self.ctnr.domains.add(the_next_domain)
txt.save()
self.assertFalse(Domain.objects.filter(pk=the_domain.pk))
# We should be able to delete now.
the_domain = the_next_domain
# txt makes the domain un-purgeable. z.foo.com
self.assertFalse(prune_tree(the_domain))
the_next_domain = the_domain.master_domain
txt.domain = the_next_domain
self.ctnr.domains.add(the_next_domain)
txt.save()
self.assertFalse(Domain.objects.filter(pk=the_domain.pk).exists())
# We should be able to delete now.
the_domain = the_next_domain
# txt makes the domain un-purgeable. foo.com
self.assertFalse(prune_tree(the_domain))
def test_cleanup_cname(self):
# Make sure CNAME record block
c = Domain.objects.create(name='foo1')
self.assertFalse(c.purgeable)
f_c = create_zone('foo.foo1')
self.ctnr.domains.add(f_c)
self.assertEqual(f_c.name, 'foo.foo1')
self.assertFalse(Domain.objects.filter(name="x.y.z.foo.foo1").exists())
self.assertFalse(Domain.objects.filter(name="y.z.foo.foo1").exists())
self.assertFalse(Domain.objects.filter(name="z.foo.foo1").exists())
self.assertTrue(Domain.objects.filter(name="foo.foo1").exists())
self.assertFalse(f_c.purgeable)
fqdn = "cname.x.y.z.foo.foo1"
label, the_domain = ensure_label_domain(fqdn)
self.ctnr.domains.add(the_domain)
cname = CNAME.objects.create(label=label,
ctnr=self.ctnr,
domain=the_domain,
target="foo")
self.assertFalse(prune_tree(the_domain))
cname.delete()
self.assertFalse(Domain.objects.filter(name="x.y.z.foo.foo1").exists())
self.assertFalse(Domain.objects.filter(name="y.z.foo.foo1").exists())
self.assertFalse(Domain.objects.filter(name="z.foo.foo1").exists())
fqdn = "bar.x.y.z.foo.poo"
self.assertTrue(Domain.objects.filter(name="foo.foo1").exists())
def test_cleanup_intr(self):
self.assertFalse(Domain.objects.filter(name="x.y.z.foo.poo"))
self.assertFalse(Domain.objects.filter(name="y.z.foo.poo"))
self.assertFalse(Domain.objects.filter(name="z.foo.poo"))
self.assertTrue(Domain.objects.filter(name="foo.poo"))
Domain.objects.get_or_create(name="arpa")
Domain.objects.get_or_create(name="in-addr.arpa")
Domain.objects.get_or_create(name="10.in-addr.arpa")
fqdn = "bar.x.y.z.foo.poo"
label, the_domain = ensure_label_domain(fqdn)
system = System()
addr = StaticInterface(
label=label, domain=the_domain, ip_type='4', ip_str="10.2.3.4",
mac="00:11:22:33:44:55", system=system
)
addr.save()
self.assertFalse(prune_tree(the_domain))
addr.delete()
self.assertFalse(Domain.objects.filter(name="x.y.z.foo.poo"))
self.assertFalse(Domain.objects.filter(name="y.z.foo.poo"))
self.assertFalse(Domain.objects.filter(name="z.foo.poo"))
self.assertTrue(Domain.objects.filter(name="foo.poo"))
def test_basic_add_remove3(self):
# MAke sure that if a domain is set to not purgeable the prune stops at
# that domain when a record exists in a domain
c = Domain(name='foo')
c.save()
self.assertFalse(c.purgeable)
f_c = Domain(name='foo.foo')
s, _ = SOA.objects.get_or_create(primary="foo",
contact="foo",
comment="foo.foo")
f_c.soa = s
f_c.save()
self.assertFalse(f_c.purgeable)
fqdn = "bar.x.y.z.foo.foo"
label, the_domain = ensure_label_domain(fqdn)
txt = TXT(label=label, domain=the_domain, txt_data="Nthing")
txt.save()
self.assertTrue(the_domain.purgeable)
# txt makes the domain un-purgeable.
self.assertFalse(prune_tree(the_domain))
txt.delete()
# The tree should have pruned itself
# Make sure stuff was deleted.
self.assertFalse(Domain.objects.filter(name="x.y.z.foo.foo"))
self.assertFalse(Domain.objects.filter(name="y.z.foo.foo"))
self.assertFalse(Domain.objects.filter(name="z.foo.foo"))
self.assertTrue(Domain.objects.filter(name="foo.foo"))
def test_cleanup_cname(self):
# Make sure CNAME record block
c = Domain(name='foo1')
c.save()
self.assertFalse(c.purgeable)
s, _ = SOA.objects.get_or_create(primary="foo",
contact="Foo",
comment="dddfoo")
f_c = Domain(name='foo.foo1')
f_c.soa = s
f_c.save()
self.assertFalse(Domain.objects.filter(name="x.y.z.foo.foo1"))
self.assertFalse(Domain.objects.filter(name="y.z.foo.foo1"))
self.assertFalse(Domain.objects.filter(name="z.foo.foo1"))
self.assertTrue(Domain.objects.filter(name="foo.foo1"))
self.assertFalse(f_c.purgeable)
fqdn = "cname.x.y.z.foo.foo1"
label, the_domain = ensure_label_domain(fqdn)
cname = CNAME(label=label, domain=the_domain, target="foo")
cname.save()
self.assertFalse(prune_tree(the_domain))
cname.delete()
self.assertFalse(Domain.objects.filter(name="x.y.z.foo.foo1"))
self.assertFalse(Domain.objects.filter(name="y.z.foo.foo1"))
self.assertFalse(Domain.objects.filter(name="z.foo.foo1"))
fqdn = "bar.x.y.z.foo.poo"
self.assertTrue(Domain.objects.filter(name="foo.foo1"))
def test_cleanup_cname(self):
# Make sure CNAME record block
c = Domain(name='foo1')
c.save()
self.assertFalse(c.purgeable)
s, _ = SOA.objects.get_or_create(primary="foo", contact="Foo",
comment="dddfoo")
f_c = Domain(name='foo.foo1')
f_c.soa = s
f_c.save()
self.assertFalse(Domain.objects.filter(name="x.y.z.foo.foo1"))
self.assertFalse(Domain.objects.filter(name="y.z.foo.foo1"))
self.assertFalse(Domain.objects.filter(name="z.foo.foo1"))
self.assertTrue(Domain.objects.filter(name="foo.foo1"))
self.assertFalse(f_c.purgeable)
fqdn = "cname.x.y.z.foo.foo1"
label, the_domain = ensure_label_domain(fqdn)
cname = CNAME(label=label, domain=the_domain, target="foo")
cname.save()
self.assertFalse(prune_tree(the_domain))
cname.delete()
self.assertFalse(Domain.objects.filter(name="x.y.z.foo.foo1"))
self.assertFalse(Domain.objects.filter(name="y.z.foo.foo1"))
self.assertFalse(Domain.objects.filter(name="z.foo.foo1"))
fqdn = "bar.x.y.z.foo.poo"
self.assertTrue(Domain.objects.filter(name="foo.foo1"))
def test_basic_add_remove3(self):
# Make sure that if a domain is set to not purgeable the prune stops at
# that domain when a record exists in a domain.
Domain.objects.create(name='foo')
f_c = create_zone('foo.foo')
self.assertFalse(f_c.purgeable)
fqdn = "bar.x.y.z.foo.foo"
label, the_domain = ensure_label_domain(fqdn)
self.ctnr.domains.add(the_domain)
txt = TXT.objects.create(
label=label, ctnr=self.ctnr, domain=the_domain, txt_data="Nothing")
self.assertTrue(the_domain.purgeable)
# txt makes the domain un-purgeable.
self.assertFalse(prune_tree(the_domain))
txt.delete()
# The tree should have pruned itself.
# Make sure stuff was deleted.
self.assertFalse(Domain.objects.filter(name="x.y.z.foo.foo"))
self.assertFalse(Domain.objects.filter(name="y.z.foo.foo"))
self.assertFalse(Domain.objects.filter(name="z.foo.foo"))
self.assertTrue(Domain.objects.filter(name="foo.foo"))
def test_cleanup_intr(self):
self.assertFalse(Domain.objects.filter(name="x.y.z.foo.poo").exists())
self.assertFalse(Domain.objects.filter(name="y.z.foo.poo").exists())
self.assertFalse(Domain.objects.filter(name="z.foo.poo").exists())
self.assertTrue(Domain.objects.filter(name="foo.poo").exists())
create_zone('10.in-addr.arpa')
fqdn = "bar.x.y.z.foo.poo"
label, the_domain = ensure_label_domain(fqdn)
self.ctnr.domains.add(the_domain)
self.ctnr.ranges.add(self.sr)
system = System.objects.create(name='foobar', ctnr=self.ctnr)
addr = StaticInterface.objects.create(label=label,
domain=the_domain,
ip_type='4',
ip_str="10.2.3.4",
mac="00:11:22:33:44:55",
system=system)
self.assertFalse(prune_tree(the_domain))
addr.delete(**{'delete_system': False})
self.assertFalse(Domain.objects.filter(name="x.y.z.foo.poo").exists())
self.assertFalse(Domain.objects.filter(name="y.z.foo.poo").exists())
self.assertFalse(Domain.objects.filter(name="z.foo.poo").exists())
self.assertTrue(Domain.objects.filter(name="foo.poo").exists())
def test_basic_add_remove3(self):
# Make sure that if a domain is set to not purgeable the prune stops at
# that domain when a record exists in a domain.
Domain.objects.create(name='foo')
f_c = create_zone('foo.foo')
self.assertFalse(f_c.purgeable)
fqdn = "bar.x.y.z.foo.foo"
label, the_domain = ensure_label_domain(fqdn)
self.ctnr.domains.add(the_domain)
txt = TXT.objects.create(
label=label, ctnr=self.ctnr, domain=the_domain, txt_data="Nothing")
self.assertTrue(the_domain.purgeable)
# txt makes the domain un-purgeable.
self.assertFalse(prune_tree(the_domain))
txt.delete()
# The tree should have pruned itself.
# Make sure stuff was deleted.
self.assertFalse(Domain.objects.filter(name="x.y.z.foo.foo"))
self.assertFalse(Domain.objects.filter(name="y.z.foo.foo"))
self.assertFalse(Domain.objects.filter(name="z.foo.foo"))
self.assertTrue(Domain.objects.filter(name="foo.foo"))
def test_cleanup_cname(self):
# Make sure CNAME record block
c = Domain(name='foo1')
c.save()
self.assertFalse(c.purgeable)
f_c = create_fake_zone('foo.foo1', suffix="")
self.assertEqual(f_c.name, 'foo.foo1')
self.assertFalse(Domain.objects.filter(name="x.y.z.foo.foo1"))
self.assertFalse(Domain.objects.filter(name="y.z.foo.foo1"))
self.assertFalse(Domain.objects.filter(name="z.foo.foo1"))
self.assertTrue(Domain.objects.filter(name="foo.foo1"))
self.assertFalse(f_c.purgeable)
fqdn = "cname.x.y.z.foo.foo1"
label, the_domain = ensure_label_domain(fqdn)
cname = CNAME(label=label, domain=the_domain, target="foo")
cname.save()
self.assertFalse(prune_tree(the_domain))
cname.delete()
self.assertFalse(Domain.objects.filter(name="x.y.z.foo.foo1"))
self.assertFalse(Domain.objects.filter(name="y.z.foo.foo1"))
self.assertFalse(Domain.objects.filter(name="z.foo.foo1"))
fqdn = "bar.x.y.z.foo.poo"
self.assertTrue(Domain.objects.filter(name="foo.foo1"))
def test_basic_add_remove3(self):
# MAke sure that if a domain is set to not purgeable the prune stops at
# that domain when a record exists in a domain
c = Domain(name='foo')
c.save()
self.assertFalse(c.purgeable)
f_c = Domain(name='foo.foo')
s, _ = SOA.objects.get_or_create(primary="foo", contact="foo",
comment="foo.foo")
f_c.soa = s
f_c.save()
self.assertFalse(f_c.purgeable)
fqdn = "bar.x.y.z.foo.foo"
label, the_domain = ensure_label_domain(fqdn)
txt = TXT(label=label, domain=the_domain, txt_data="Nthing")
txt.save()
self.assertTrue(the_domain.purgeable)
# txt makes the domain un-purgeable.
self.assertFalse(prune_tree(the_domain))
txt.delete()
# The tree should have pruned itself
# Make sure stuff was deleted.
self.assertFalse(Domain.objects.filter(name="x.y.z.foo.foo"))
self.assertFalse(Domain.objects.filter(name="y.z.foo.foo"))
self.assertFalse(Domain.objects.filter(name="z.foo.foo"))
self.assertTrue(Domain.objects.filter(name="foo.foo"))
def test_cleanup_intr(self):
self.assertFalse(Domain.objects.filter(name="x.y.z.foo.poo"))
self.assertFalse(Domain.objects.filter(name="y.z.foo.poo"))
self.assertFalse(Domain.objects.filter(name="z.foo.poo"))
self.assertTrue(Domain.objects.filter(name="foo.poo"))
Domain.objects.get_or_create(name="arpa")
Domain.objects.get_or_create(name="in-addr.arpa")
Domain.objects.get_or_create(name="10.in-addr.arpa")
fqdn = "bar.x.y.z.foo.poo"
label, the_domain = ensure_label_domain(fqdn)
system = System()
addr = StaticInterface(label=label,
domain=the_domain,
ip_type='4',
ip_str="10.2.3.4",
mac="00:11:22:33:44:55",
system=system)
addr.save()
self.assertFalse(prune_tree(the_domain))
addr.delete()
self.assertFalse(Domain.objects.filter(name="x.y.z.foo.poo"))
self.assertFalse(Domain.objects.filter(name="y.z.foo.poo"))
self.assertFalse(Domain.objects.filter(name="z.foo.poo"))
self.assertTrue(Domain.objects.filter(name="foo.poo"))
def test_cleanup_cname(self):
# Make sure CNAME record block
c = Domain.objects.create(name='foo1')
self.assertFalse(c.purgeable)
f_c = create_zone('foo.foo1')
self.ctnr.domains.add(f_c)
self.assertEqual(f_c.name, 'foo.foo1')
self.assertFalse(Domain.objects.filter(name="x.y.z.foo.foo1").exists())
self.assertFalse(Domain.objects.filter(name="y.z.foo.foo1").exists())
self.assertFalse(Domain.objects.filter(name="z.foo.foo1").exists())
self.assertTrue(Domain.objects.filter(name="foo.foo1").exists())
self.assertFalse(f_c.purgeable)
fqdn = "cname.x.y.z.foo.foo1"
label, the_domain = ensure_label_domain(fqdn)
self.ctnr.domains.add(the_domain)
cname = CNAME.objects.create(
label=label, ctnr=self.ctnr, domain=the_domain, target="foo")
self.assertFalse(prune_tree(the_domain))
cname.delete()
self.assertFalse(Domain.objects.filter(name="x.y.z.foo.foo1").exists())
self.assertFalse(Domain.objects.filter(name="y.z.foo.foo1").exists())
self.assertFalse(Domain.objects.filter(name="z.foo.foo1").exists())
fqdn = "bar.x.y.z.foo.poo"
self.assertTrue(Domain.objects.filter(name="foo.foo1").exists())
def test_cleanup_cname(self):
# Make sure CNAME record block
c = Domain(name='foo1')
c.save()
self.assertFalse(c.purgeable)
f_c = create_fake_zone('foo.foo1', suffix="")
self.assertEqual(f_c.name, 'foo.foo1')
self.assertFalse(Domain.objects.filter(name="x.y.z.foo.foo1"))
self.assertFalse(Domain.objects.filter(name="y.z.foo.foo1"))
self.assertFalse(Domain.objects.filter(name="z.foo.foo1"))
self.assertTrue(Domain.objects.filter(name="foo.foo1"))
self.assertFalse(f_c.purgeable)
fqdn = "cname.x.y.z.foo.foo1"
label, the_domain = ensure_label_domain(fqdn)
cname = CNAME(label=label, domain=the_domain, target="foo")
cname.save()
self.assertFalse(prune_tree(the_domain))
cname.delete()
self.assertFalse(Domain.objects.filter(name="x.y.z.foo.foo1"))
self.assertFalse(Domain.objects.filter(name="y.z.foo.foo1"))
self.assertFalse(Domain.objects.filter(name="z.foo.foo1"))
fqdn = "bar.x.y.z.foo.poo"
self.assertTrue(Domain.objects.filter(name="foo.foo1"))
def save(self, *args, **kwargs):
self.full_clean()
set_fqdn(self)
check_TLD_condition(self)
update_soa(self)
if self.pk:
# We need to get the domain from the db. If it's not our current
# domain, call prune_tree on the domain in the db later.
db_domain = self.__class__.objects.get(pk=self.pk).domain
if self.domain == db_domain:
db_domain = None
else:
db_domain = None
super(BaseAddressRecord, self).save(*args, **kwargs)
if db_domain:
from cyder.cydns.utils import prune_tree
prune_tree(db_domain)
def test_basic_add_remove5(self):
# Make sure all record types block
Domain.objects.create(name='foo22')
f_c = create_zone('foo.foo22')
self.assertFalse(f_c.purgeable)
fqdn = "bar.x.y.z.foo.foo22"
label, the_domain = ensure_label_domain(fqdn)
self.ctnr.domains.add(the_domain)
txt = TXT.objects.create(
label=label, ctnr=self.ctnr, domain=the_domain, txt_data="Nothing")
self.assertFalse(prune_tree(the_domain))
txt.delete()
label, the_domain = ensure_label_domain(fqdn)
self.ctnr.domains.add(the_domain)
addr = AddressRecord.objects.create(
label=label, ctnr=self.ctnr, domain=the_domain, ip_type='4',
ip_str="10.2.3.4")
self.assertFalse(prune_tree(the_domain))
addr.delete()
label, the_domain = ensure_label_domain(fqdn)
self.ctnr.domains.add(the_domain)
mx = MX.objects.create(
label=label, ctnr=self.ctnr, domain=the_domain, server="foo",
priority=4)
self.assertFalse(prune_tree(the_domain))
mx.delete()
label, the_domain = ensure_label_domain(fqdn)
self.ctnr.domains.add(the_domain)
ns = Nameserver.objects.create(
domain=the_domain, server="asdfasffoo")
self.assertFalse(prune_tree(the_domain))
ns.delete()
label, the_domain = ensure_label_domain(fqdn)
self.ctnr.domains.add(the_domain)
srv = SRV.objects.create(
label='_' + label, ctnr=self.ctnr, domain=the_domain, target="foo",
priority=4, weight=4, port=34)
self.assertFalse(prune_tree(the_domain))
srv.delete()
def test_basic_add_remove5(self):
# Make sure all record types block
c = Domain(name='foo22')
c.save()
self.assertFalse(c.purgeable)
f_c = Domain(name='foo.foo22')
s, _ = SOA.objects.get_or_create(primary="foo", contact="foo",
comment="foo.foo22")
f_c.soa = s
f_c.save()
self.assertFalse(f_c.purgeable)
fqdn = "bar.x.y.z.foo.foo22"
label, the_domain = ensure_label_domain(fqdn)
txt = TXT(label=label, domain=the_domain, txt_data="Nthing")
txt.save()
self.assertFalse(prune_tree(the_domain))
txt.delete()
label, the_domain = ensure_label_domain(fqdn)
addr = AddressRecord(label=label, domain=the_domain,
ip_type='4', ip_str="10.2.3.4")
addr.save()
self.assertFalse(prune_tree(the_domain))
addr.delete()
label, the_domain = ensure_label_domain(fqdn)
mx = MX(label=label, domain=the_domain, server="foo", priority=4)
mx.save()
self.assertFalse(prune_tree(the_domain))
mx.delete()
label, the_domain = ensure_label_domain(fqdn)
ns = Nameserver(domain=the_domain, server="asdfasffoo")
ns.save()
self.assertFalse(prune_tree(the_domain))
ns.delete()
label, the_domain = ensure_label_domain(fqdn)
srv = SRV(
label='_' + label, domain=the_domain, target="foo", priority=4,
weight=4, port=34)
srv.save()
self.assertFalse(prune_tree(the_domain))
srv.delete()
def delete(self, *args, **kwargs):
"""Address Records that are glue records or that are pointed to
by a CNAME should not be removed from the database.
"""
if kwargs.pop("validate_glue", True):
if self.nameserver_set.exists():
raise ValidationError("Cannot delete the record {0}. It is "
"a glue record.".format(self.record_type()))
if kwargs.pop("check_cname", True):
if CNAME.objects.filter(target=self.fqdn):
raise ValidationError("A CNAME points to this {0} record. "
"Change the CNAME before deleting this record.".
format(self.record_type()))
from cyder.cydns.utils import prune_tree
objs_domain = self.domain
super(BaseAddressRecord, self).delete(*args, **kwargs)
prune_tree(objs_domain)
def save(self, *args, **kwargs):
if self.pk:
# We need to get the domain from the db. If it's not our current
# domain, call prune_tree on the domain in the db later.
db_domain = self.reload().domain
if self.domain == db_domain:
db_domain = None
else:
db_domain = None
no_build = kwargs.pop("no_build", False)
super(CydnsRecord, self).save(*args, **kwargs)
if not no_build:
self.schedule_zone_rebuild()
if db_domain:
from cyder.cydns.utils import prune_tree
prune_tree(db_domain)
def save(self, *args, **kwargs):
if self.pk:
# We need to get the domain from the db. If it's not our current
# domain, call prune_tree on the domain in the db later.
db_domain = self.reload().domain
if self.domain == db_domain:
db_domain = None
else:
db_domain = None
no_build = kwargs.pop("no_build", False)
super(CydnsRecord, self).save(*args, **kwargs)
if not no_build:
self.schedule_zone_rebuild()
if db_domain:
from cyder.cydns.utils import prune_tree
prune_tree(db_domain)
def test_basic_add_remove1(self):
c = Domain.objects.create(name='com')
self.assertFalse(c.purgeable)
f_c = Domain.objects.create(name='foo.com')
s = SOA.objects.create(
primary="foo", contact="foo", root_domain=f_c,
description="foo.zfoo.comom")
f_c = f_c.reload()
self.assertFalse(f_c.purgeable)
fqdn = "bar.x.y.z.foo.com"
label, the_domain = ensure_label_domain(fqdn)
self.ctnr.domains.add(the_domain)
self.assertEqual(label, "bar")
self.assertEqual(the_domain.name, "x.y.z.foo.com")
self.assertTrue(the_domain.purgeable)
self.assertEqual(the_domain.master_domain.name, "y.z.foo.com")
self.assertTrue(the_domain.master_domain.purgeable)
self.assertEqual(
the_domain.master_domain.master_domain.name, "z.foo.com")
self.assertTrue(the_domain.master_domain.master_domain.purgeable)
self.assertEqual(
the_domain.master_domain.master_domain.master_domain.name,
"foo.com"
)
self.assertFalse(
the_domain.master_domain.master_domain.master_domain.purgeable)
# Now call prune_tree on the_domain.
self.assertTrue(prune_tree(the_domain))
self.assertFalse(Domain.objects.filter(name="x.y.z.foo.com"))
self.assertFalse(Domain.objects.filter(name="y.z.foo.com"))
self.assertFalse(Domain.objects.filter(name="z.foo.com"))
self.assertTrue(Domain.objects.filter(name="foo.com"))
# Make sure other domain's can't be pruned.
self.assertFalse(prune_tree(f_c))
self.assertTrue(Domain.objects.filter(name="foo.com"))
self.assertFalse(prune_tree(c))
self.assertTrue(Domain.objects.filter(name="com"))
def test_basic_add_remove1(self):
c = Domain.objects.create(name='com')
self.assertFalse(c.purgeable)
f_c = Domain.objects.create(name='foo.com')
s = SOA.objects.create(
primary="foo", contact="foo", root_domain=f_c,
description="foo.zfoo.comom")
f_c = f_c.reload()
self.assertFalse(f_c.purgeable)
fqdn = "bar.x.y.z.foo.com"
label, the_domain = ensure_label_domain(fqdn)
self.ctnr.domains.add(the_domain)
self.assertEqual(label, "bar")
self.assertEqual(the_domain.name, "x.y.z.foo.com")
self.assertTrue(the_domain.purgeable)
self.assertEqual(the_domain.master_domain.name, "y.z.foo.com")
self.assertTrue(the_domain.master_domain.purgeable)
self.assertEqual(
the_domain.master_domain.master_domain.name, "z.foo.com")
self.assertTrue(the_domain.master_domain.master_domain.purgeable)
self.assertEqual(
the_domain.master_domain.master_domain.master_domain.name,
"foo.com"
)
self.assertFalse(
the_domain.master_domain.master_domain.master_domain.purgeable)
# Now call prune_tree on the_domain.
self.assertTrue(prune_tree(the_domain))
self.assertFalse(Domain.objects.filter(name="x.y.z.foo.com"))
self.assertFalse(Domain.objects.filter(name="y.z.foo.com"))
self.assertFalse(Domain.objects.filter(name="z.foo.com"))
self.assertTrue(Domain.objects.filter(name="foo.com"))
# Make sure other domain's can't be pruned.
self.assertFalse(prune_tree(f_c))
self.assertTrue(Domain.objects.filter(name="foo.com"))
self.assertFalse(prune_tree(c))
self.assertTrue(Domain.objects.filter(name="com"))
def test_basic_add_remove6(self):
# Make sure CNAME record block
f_c = create_fake_zone("foo.foo1", suffix="")
f_c.save()
self.assertFalse(f_c.purgeable)
fqdn = "cname.x.y.z.foo.foo1"
label, the_domain = ensure_label_domain(fqdn)
cname = CNAME(label=label, domain=the_domain, target="foo")
cname.save()
self.assertFalse(prune_tree(the_domain))
cname.delete()
def test_basic_add_remove1(self):
c = Domain(name='com')
c.save()
self.assertFalse(c.purgeable)
f_c = Domain(name='foo.com')
s, _ = SOA.objects.get_or_create(primary="foo", contact="foo",
description="foo.zfoo.comom")
f_c.soa = s
f_c.save()
self.assertFalse(f_c.purgeable)
fqdn = "bar.x.y.z.foo.com"
label, the_domain = ensure_label_domain(fqdn)
self.assertEqual(label, "bar")
self.assertEqual(the_domain.name, "x.y.z.foo.com")
self.assertTrue(the_domain.purgeable)
self.assertEqual(the_domain.master_domain.name, "y.z.foo.com")
self.assertTrue(the_domain.master_domain.purgeable)
self.assertEqual(
the_domain.master_domain.master_domain.name, "z.foo.com")
self.assertTrue(the_domain.master_domain.master_domain.purgeable)
self.assertEqual(
the_domain.master_domain.master_domain.master_domain.name,
"foo.com"
)
self.assertFalse(
the_domain.master_domain.master_domain.master_domain.purgeable)
# Now call prune tree one the_domain
self.assertTrue(prune_tree(the_domain))
self.assertFalse(Domain.objects.filter(name="x.y.z.foo.com"))
self.assertFalse(Domain.objects.filter(name="y.z.foo.com"))
self.assertFalse(Domain.objects.filter(name="z.foo.com"))
self.assertTrue(Domain.objects.filter(name="foo.com"))
# Make sure other domain's can't be pruned
self.assertFalse(prune_tree(f_c))
self.assertTrue(Domain.objects.filter(name="foo.com"))
self.assertFalse(prune_tree(c))
self.assertTrue(Domain.objects.filter(name="com"))
def test_basic_add_remove9(self):
# Make sure all record types block
f_c = create_fake_zone("foo.foo22", suffix="")
self.assertFalse(f_c.purgeable)
fqdn = "y.z.foo.foo22"
label, the_domain = ensure_label_domain(fqdn)
addr = AddressRecord(label=label, domain=the_domain,
ip_type='4', ip_str="10.2.3.4")
addr.save()
self.assertFalse(prune_tree(the_domain))
f_c = create_fake_zone("y.z.foo.foo22", suffix="")
self.assertFalse(f_c.purgeable)
def test_basic_add_remove7(self):
# try a star record
f_c = create_fake_zone("foo.foo2", suffix="")
f_c.save()
self.assertFalse(f_c.purgeable)
fqdn = "*.x.y.z.foo.foo2"
label, the_domain = ensure_label_domain(fqdn)
self.assertEqual('*', label)
cname = CNAME(label=label, domain=the_domain, target="foo")
cname.save()
self.assertFalse(prune_tree(the_domain))
cname.delete()
def test_basic_add_remove5(self):
# Make sure all record types block
f_c = create_fake_zone("foo.foo22", suffix="")
self.assertFalse(f_c.purgeable)
fqdn = "bar.x.y.z.foo.foo22"
label, the_domain = ensure_label_domain(fqdn)
txt = TXT(label=label, domain=the_domain, txt_data="Nthing")
txt.save()
self.assertFalse(prune_tree(the_domain))
txt.delete()
label, the_domain = ensure_label_domain(fqdn)
addr = AddressRecord(label=label, domain=the_domain,
ip_type='4', ip_str="10.2.3.4")
addr.save()
self.assertFalse(prune_tree(the_domain))
addr.delete()
label, the_domain = ensure_label_domain(fqdn)
mx = MX(label=label, domain=the_domain, server="foo", priority=4)
mx.save()
self.assertFalse(prune_tree(the_domain))
mx.delete()
label, the_domain = ensure_label_domain(fqdn)
ns = Nameserver(domain=the_domain, server="asdfasffoo")
ns.save()
self.assertFalse(prune_tree(the_domain))
ns.delete()
label, the_domain = ensure_label_domain(fqdn)
srv = SRV(
label='_' + label, domain=the_domain, target="foo", priority=4,
weight=4, port=34)
srv.save()
self.assertFalse(prune_tree(the_domain))
srv.delete()
def test_basic_add_remove7(self):
# try a star record
Domain.objects.create(name='foo2')
f_c = create_zone('foo.foo2')
f_c.save()
self.assertFalse(f_c.purgeable)
fqdn = "*.x.y.z.foo.foo2"
label, the_domain = ensure_label_domain(fqdn)
self.ctnr.domains.add(the_domain)
self.assertEqual('*', label)
cname = CNAME.objects.create(
label=label, ctnr=self.ctnr, domain=the_domain, target="foo")
self.assertFalse(prune_tree(the_domain))
cname.delete()
def test_basic_add_remove7(self):
# try a star record
Domain.objects.create(name='foo2')
f_c = create_zone('foo.foo2')
f_c.save()
self.assertFalse(f_c.purgeable)
fqdn = "*.x.y.z.foo.foo2"
label, the_domain = ensure_label_domain(fqdn)
self.ctnr.domains.add(the_domain)
self.assertEqual('*', label)
cname = CNAME.objects.create(
label=label, ctnr=self.ctnr, domain=the_domain, target="foo")
self.assertFalse(prune_tree(the_domain))
cname.delete()
def test_basic_add_remove6(self):
# Make sure CNAME record block
Domain.objects.create(name='foo1')
f_c = create_zone('foo.foo1')
f_c.save()
self.assertFalse(f_c.purgeable)
fqdn = "cname.x.y.z.foo.foo1"
label, the_domain = ensure_label_domain(fqdn)
self.ctnr.domains.add(the_domain)
cname = CNAME.objects.create(
label=label, ctnr=self.ctnr, domain=the_domain, target="foo")
self.assertFalse(prune_tree(the_domain))
cname.delete()
def test_basic_add_remove6(self):
# Make sure CNAME record block
Domain.objects.create(name='foo1')
f_c = create_zone('foo.foo1')
f_c.save()
self.assertFalse(f_c.purgeable)
fqdn = "cname.x.y.z.foo.foo1"
label, the_domain = ensure_label_domain(fqdn)
self.ctnr.domains.add(the_domain)
cname = CNAME.objects.create(
label=label, ctnr=self.ctnr, domain=the_domain, target="foo")
self.assertFalse(prune_tree(the_domain))
cname.delete()
def test_basic_add_remove9(self):
# Make sure all record types block.
Domain.objects.create(name='foo22')
f_c = create_zone('foo.foo22')
self.assertFalse(f_c.purgeable)
fqdn = "y.z.foo.foo22"
label, the_domain = ensure_label_domain(fqdn)
self.ctnr.domains.add(the_domain)
addr = AddressRecord.objects.create(
label=label, ctnr=self.ctnr, domain=the_domain, ip_type='4',
ip_str="10.2.3.4")
self.assertFalse(prune_tree(the_domain))
new_domain = ensure_domain('y.z.foo.foo22')
self.assertFalse(new_domain.purgeable)
