def generic_check(self, obj, do_label=True, label_prefix=""):
# Make sure all record types block
c, _ = Domain.objects.get_or_create(name='foo22')
self.assertFalse(c.purgeable)
f_c, _ = Domain.objects.get_or_create(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)
if do_label:
# NS records don't like labels
label = label_prefix + label
obj.label = label
obj.domain = the_domain
obj.save()
fqdn = "bar.x.y.xx.foo.foo22"
label, new_domain = ensure_label_domain(fqdn)
obj.domain = new_domain
obj.save()
# The original domain should have been deleted.
self.assertFalse(Domain.objects.filter(name="x.y.z.foo.foo22"))
# Make sure no objects were harmed.
self.assertTrue(obj.__class__.objects.get(pk=obj.pk))
obj.delete()
# The new domain should now have been deleted.
self.assertFalse(Domain.objects.filter(name="x.y.xx.foo.foo22"))
def generic_check(self, obj, do_label=True, label_prefix=""):
# Make sure all record types block
c, _ = Domain.objects.get_or_create(name='foo22')
self.assertFalse(c.purgeable)
f_c, _ = Domain.objects.get_or_create(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)
if do_label:
# NS records don't like labels
label = label_prefix + label
obj.label = label
obj.domain = the_domain
obj.save()
fqdn = "bar.x.y.xx.foo.foo22"
label, new_domain = ensure_label_domain(fqdn)
obj.domain = new_domain
obj.save()
# The original domain should have been deleted.
self.assertFalse(Domain.objects.filter(name="x.y.z.foo.foo22"))
# Make sure no objects were harmed.
self.assertTrue(obj.__class__.objects.get(pk=obj.pk))
obj.delete()
# The new domain should now have been deleted.
self.assertFalse(Domain.objects.filter(name="x.y.xx.foo.foo22"))
def generic_check(self, obj, do_label=True, label_prefix=""):
# Make sure all record types block
f_c = create_zone('foo.foo22')
self.ctnr.domains.add(f_c)
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)
if do_label:
# NS records don't like labels
label = label_prefix + label
obj.label = label
obj.domain = the_domain
obj.save()
fqdn = "bar.x.y.xx.foo.foo22"
label, new_domain = ensure_label_domain(fqdn)
self.ctnr.domains.add(new_domain)
obj.domain = new_domain
obj.save()
# The original domain should have been deleted.
self.assertFalse(Domain.objects.filter(name="x.y.z.foo.foo22"))
# Make sure no objects were harmed.
self.assertTrue(obj.__class__.objects.get(pk=obj.pk))
obj.delete()
# The new domain should now have been deleted.
self.assertFalse(Domain.objects.filter(name="x.y.xx.foo.foo22"))
def test_basic_add_remove8(self):
# Make sure a record's label is changed to '' when a domain with the
# same name as it's fqdn is created.
Domain.objects.create(name='foo3')
f_c = create_zone('foo.foo3')
self.assertFalse(f_c.purgeable)
fqdn = "www.x.y.z.foo.foo3"
label, the_domain = ensure_label_domain(fqdn)
self.ctnr.domains.add(the_domain)
self.assertEqual('www', label)
self.assertEqual('x.y.z.foo.foo3', the_domain.name)
self.assertTrue(the_domain.pk)
cname = CNAME.objects.create(
label=label, ctnr=self.ctnr, domain=the_domain, target="foo")
fqdn = "*.www.x.y.z.foo.foo3"
the_domain.save()
label2, the_domain2 = ensure_label_domain(fqdn)
self.ctnr.domains.add(the_domain2)
cname = CNAME.objects.get(fqdn=cname.fqdn)
self.assertEqual('', cname.label)
self.assertEqual('www.x.y.z.foo.foo3', cname.domain.name)
self.assertEqual('*', label2)
self.assertEqual('www.x.y.z.foo.foo3', the_domain2.name)
def test_basic_add_remove8(self):
# Make sure a record's label is changed to '' when a domain with the
# same name as it's fqdn is created.
Domain.objects.create(name='foo3')
f_c = create_zone('foo.foo3')
self.assertFalse(f_c.purgeable)
fqdn = "www.x.y.z.foo.foo3"
label, the_domain = ensure_label_domain(fqdn)
self.ctnr.domains.add(the_domain)
self.assertEqual('www', label)
self.assertEqual('x.y.z.foo.foo3', the_domain.name)
self.assertTrue(the_domain.pk)
cname = CNAME.objects.create(
label=label, ctnr=self.ctnr, domain=the_domain, target="foo")
fqdn = "*.www.x.y.z.foo.foo3"
the_domain.save()
label2, the_domain2 = ensure_label_domain(fqdn)
self.ctnr.domains.add(the_domain2)
cname = CNAME.objects.get(fqdn=cname.fqdn)
self.assertEqual('', cname.label)
self.assertEqual('www.x.y.z.foo.foo3', cname.domain.name)
self.assertEqual('*', label2)
self.assertEqual('www.x.y.z.foo.foo3', the_domain2.name)
def generic_check(self, obj, do_label=True, label_prefix=""):
# Make sure all record types block
f_c = create_zone('foo.foo22')
self.ctnr.domains.add(f_c)
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)
if do_label:
# NS records don't like labels
label = label_prefix + label
obj.label = label
obj.domain = the_domain
obj.save()
fqdn = "bar.x.y.xx.foo.foo22"
label, new_domain = ensure_label_domain(fqdn)
self.ctnr.domains.add(new_domain)
obj.domain = new_domain
obj.save()
# The original domain should have been deleted.
self.assertFalse(Domain.objects.filter(name="x.y.z.foo.foo22"))
# Make sure no objects were harmed.
self.assertTrue(obj.__class__.objects.get(pk=obj.pk))
obj.delete()
# The new domain should now have been deleted.
self.assertFalse(Domain.objects.filter(name="x.y.xx.foo.foo22"))
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_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.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_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_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)
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_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_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
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_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)
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 table_update(request, pk, obj_type=None):
"""
Called from editableGrid tables when updating a field. Try to update
an object specified by pk with the post data.
"""
# Infer obj_type from URL, saves trouble of having to specify
# kwargs everywhere in the dispatchers.
obj_type = obj_type or request.path.split('/')[2]
Klass, FormKlass = get_klasses(obj_type)
obj = get_object_or_404(Klass, pk=pk)
if not perm_soft(request, ACTION_UPDATE, obj=obj):
return HttpResponse(json.dumps({'error': 'You do not have appropriate'
' permissions.'}))
# DNS specific.
qd = request.POST.copy()
if 'fqdn' in qd and obj_type != "ptr":
fqdn = qd.pop('fqdn')[0]
try:
# Call prune tree later if error, else domain leak.
label, domain = ensure_label_domain(fqdn)
except ValidationError, e:
return HttpResponse(json.dumps({'error': e.messages}))
qd['label'], qd['domain'] = label, str(domain.pk)
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_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(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 table_update(request, pk, obj_type=None):
"""
Called from editableGrid tables when updating a field. Try to update
an object specified by pk with the post data.
"""
# Infer obj_type from URL, saves trouble of having to specify
# kwargs everywhere in the dispatchers.
obj_type = obj_type or request.path.split('/')[2]
Klass, FormKlass = get_klasses(obj_type)
obj = get_object_or_404(Klass, pk=pk)
if not perm_soft(request, ACTION_UPDATE, obj=obj):
return HttpResponse(json.dumps({'error': 'You do not have appropriate'
' permissions.'}))
# DNS specific.
qd = request.POST.copy()
if 'fqdn' in qd and obj_type != "ptr":
fqdn = qd.pop('fqdn')[0]
try:
# Call prune tree later if error, else domain leak.
label, domain = ensure_label_domain(fqdn)
except ValidationError, e:
return HttpResponse(json.dumps({'error': e.messages}))
qd['label'], qd['domain'] = label, str(domain.pk)
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 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 hydrate(self, bundle):
"""Hydrate handles the conversion of fqdn to a label or domain."""
if 'fqdn' in bundle.data:
try:
label_domain = ensure_label_domain(bundle.data['fqdn'])
bundle.data['label'], bundle.data['domain'] = label_domain
except ValidationError, e:
errors = {}
errors['fqdn'] = e.messages
bundle.errors['error_messages'] = json.dumps(errors)
def hydrate(self, bundle):
"""Hydrate handles the conversion of fqdn to a label or domain."""
if 'fqdn' in bundle.data:
try:
label_domain = ensure_label_domain(bundle.data['fqdn'])
bundle.data['label'], bundle.data['domain'] = label_domain
except ValidationError, e:
errors = {}
errors['fqdn'] = e.messages
bundle.errors['error_messages'] = json.dumps(errors)
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 _fqdn_to_domain(qd):
"""Resolve FQDN to domain and attach to record object. """
domain = None
if 'fqdn' in qd:
fqdn = qd.pop('fqdn')[0]
try:
# Call prune tree later if error, else domain leak.
label, domain = ensure_label_domain(fqdn)
except ValidationError, e:
return None, None, e.messages
qd['label'], qd['domain'] = label, str(domain.pk)
def _fqdn_to_domain(qd):
"""Resolve FQDN to domain and attach to record object. """
domain = None
if 'fqdn' in qd:
fqdn = qd.pop('fqdn')[0]
try:
# Call prune tree later if error, else domain leak.
label, domain = ensure_label_domain(fqdn)
except ValidationError, e:
return None, None, e.messages
qd['label'], qd['domain'] = label, str(domain.pk)
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_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 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))
class CommonDNSResource(ModelResource):
domain = fields.CharField()
# User passes string, in hydrate we find a
# domain
views = fields.ListField(null=True, blank=True)
# User passes list of view names, in hydrate we
# make these the actual view objects
def obj_delete_list(self, request=None, **kwargs):
# We dont' want this method being used
raise NotImplemented
def dehydrate(self, bundle):
# Every DNS Resource should have a domain
bundle.data['views'] = [view.name for view in bundle.obj.views.all()]
if 'domain' in bundle.data:
bundle.data['domain'] = bundle.obj.domain.name
return bundle
def hydrate(self, bundle):
"""Hydrate handles the conversion of fqdn to a label or domain.
This function handles two cases:
1) Label and domain are in bundle
2) Label and domain are *not* in bundle and fqdn is in bundle.
All other cases cause hydration errors to be raised and
bundle.errors will be set.
"""
# Every DNS Resource should have a domain
if ('fqdn' not in bundle.data and 'domain' in bundle.data
and 'label' in bundle.data):
domain_name = bundle.data.get('domain')
try:
domain = Domain.objects.get(name=domain_name)
bundle.data['domain'] = domain
except ObjectDoesNotExist, e:
errors = {}
errors['domain'] = "Couldn't find domain {0}".format(
domain_name)
bundle.errors['error_messages'] = json.dumps(errors)
elif ('fqdn' in bundle.data
and not ('domain' in bundle.data or 'label' in bundle.data)):
try:
label_domain = ensure_label_domain(bundle.data['fqdn'])
bundle.data['label'], bundle.data['domain'] = label_domain
except ValidationError, e:
errors = {}
errors['fqdn'] = e.messages
bundle.errors['error_messages'] = json.dumps(errors)
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_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_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_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)
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)
def test_ns_cleanup(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"))
fqdn = "bar.x.y.z.foo.poo"
label, the_domain = ensure_label_domain(fqdn)
ns = Nameserver(domain=the_domain, server="asdfasffoo")
ns.save()
self.assertFalse(prune_tree(the_domain))
ns.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_mx(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"))
fqdn = "bar.x.y.z.foo.poo"
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()
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_mx(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"))
fqdn = "bar.x.y.z.foo.poo"
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()
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_ns_cleanup(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"))
fqdn = "bar.x.y.z.foo.poo"
label, the_domain = ensure_label_domain(fqdn)
ns = Nameserver(domain=the_domain, server="asdfasffoo")
ns.save()
self.assertFalse(prune_tree(the_domain))
ns.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_ns_cleanup(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())
fqdn = "bar.x.y.z.foo.poo"
label, the_domain = ensure_label_domain(fqdn)
self.ctnr.domains.add(the_domain)
ns = Nameserver.objects.create(
ctnr=self.ctnr, domain=the_domain, server="asdfasffoo")
self.assertFalse(prune_tree(the_domain))
ns.delete()
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_cleanup_address(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"))
fqdn = "bar.x.y.z.foo.poo"
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()
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_remove6(self):
# Make sure CNAME record block
c = Domain(name='foo1')
c.save()
self.assertFalse(c.purgeable)
f_c = Domain(name='foo.foo1')
s, _ = SOA.objects.get_or_create(primary="foo", contact="foo",
comment="foo.foo1")
f_c.soa = s
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()