def post_handler(self, object_, record_type, orig_qd): """Create or update object_. qd is a QueryDict.""" qd = copy.deepcopy( orig_qd) # If there are ever errors, we have to preserver # the original qd comment = qd.pop('comment', [''])[0].strip() # This little chunk of code could be factored out, but I think it's # more clear when you see which objects don't need to call this in one # spot. qd, errors = self.modify_qd(qd, object_=object_) if errors: return None, errors # Create a save-able form to create/update the object if object_: object_form = self.form(qd, instance=object_) else: object_form = self.form(qd) if object_form.is_valid(): try: object_ = object_form.save() reversion.set_comment(comment) except ValidationError, e: if 'domain' in qd: prune_tree(Domain.objects.get(pk=qd['domain'])) e_dict = ErrorDict() e_dict['__all__'] = ErrorList(e.messages) return None, e_dict return object_, None
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(MozdnsRecord, 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 mozdns.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. """ 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 = 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 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_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 delete(self, *args, **kwargs): if self.domain.soa: self.domain.soa.schedule_rebuild() from mozdns.utils import prune_tree call_prune_tree = kwargs.pop('call_prune_tree', True) objs_domain = self.domain super(MozdnsRecord, self).delete(*args, **kwargs) if call_prune_tree: prune_tree(objs_domain)
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_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. f_c = create_fake_zone("foo.goo", suffix="") 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_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_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_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_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_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_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_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_srv_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) 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() 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_txt(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")) self.assertFalse(self.f_c.purgeable) fqdn = "bar.x.y.z.foo.poo" 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() 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 f_c = create_fake_zone("foo.foo", suffix="") 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_sreg(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 = create_fake_host(hostname="foo.mozilla.com") addr = StaticReg.objects.create( label=label, domain=the_domain, ip_type='4', ip_str="10.2.3.4", system=system ) 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"))
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) except TypeError, e: if 'domain' in bundle.data: prune_tree(bundle.data['domain']) bundle.errors['error_messages'] = e.message self.error_response(bundle.errors, request) return self.save_commit(request, bundle, views, comment, kv) def save_commit(self, request, bundle, views, comment, kv): # Q: Why is update_views called in two different places?!? # A: Due to many-to-many objects neeeding both objects to exist in the # db before any relationships can be made, we call update_views # *before* changing the object if the object is being *updated* (it has # a primary key), and we call update_views *after* save is called if # the object is new. If the object was new and we find invalid views # after it was created, we delete the object and raise a 400. # TODO, use db transaction and rollback() for a cleaner implementation
object_form = self.form(qd) if object_form.is_valid(): try: object_ = object_form.save() reversion.set_comment(comment) except ValidationError, e: if 'domain' in qd: prune_tree(Domain.objects.get(pk=qd['domain'])) e_dict = ErrorDict() e_dict['__all__'] = ErrorList(e.messages) return None, e_dict return object_, None else: if 'domain' in qd: prune_tree(Domain.objects.get(pk=qd['domain'])) return None, object_form._errors def make_rdtype_tagger(tagged_klasses): def tag(Klass): tagged_klasses[Klass.__name__.strip('_')] = Klass return Klass return tag obj_meta = {} tag_rdtype = make_rdtype_tagger(obj_meta)
object_form = self.form(qd) if object_form.is_valid(): try: object_ = object_form.save() reversion.set_comment(comment) except ValidationError, e: if 'domain' in qd: prune_tree(Domain.objects.get(pk=qd['domain'])) e_dict = ErrorDict() e_dict['__all__'] = ErrorList(e.messages) return None, e_dict return object_, None else: if 'domain' in qd: prune_tree(Domain.objects.get(pk=qd['domain'])) return None, object_form._errors def make_rdtype_tagger(tagged_klasses): def tag(Klass): tagged_klasses[Klass.__name__.strip('_')] = Klass return Klass return tag obj_meta = {} tag_rdtype = make_rdtype_tagger(obj_meta) def get_obj_meta(record_type): return obj_meta[record_type]
fqdn = request.POST.get('fqdn', '') try: label, domain = ensure_label_domain(fqdn) # If we hit we need to back out of creating this interface, # make sure to call prune_tree on this domain. except ValidationError, e: return HttpResponse(json.dumps({'success': False, 'error_message': "Error creating label and domain: " "{0}".format(" ".join(e.messages))})) # Determine the keys to store later when nameing the interface. try: x = SystemResource.extract_nic_attrs(intr_name) interface_type, primary, alias = x except ValidationError, e: prune_tree(domain) return HttpResponse(json.dumps({'success': False, 'error_message': " ".join(e.messages)})) # Create the Interface s = StaticInterface(label=label, mac=mac_address, domain=domain, ip_str=ip_address, ip_type='4', system=system, dhcp_enabled=enable_dhcp, dns_enabled=enable_dns) try: s.clean() s.save() except ValidationError, e: prune_tree(domain) return HttpResponse(json.dumps({'success': False, 'error_message': "Failed to create an interface: {0}".format(" ".join(e.messages))}))