def removeTemplate(self, name):
template = self.include_templates[name]
if template.parent:
raise RulesetError(
tr('It is not possible to delete the "%s" template, included in the "%s" template'),
name, template.parent)
templates = [template]
for template in self.include_templates.itervalues():
if template.parent != name:
continue
templates.append(template)
names = [template.name for template in templates]
updates = Updates(Update("ruleset", "update", -1))
action = Action(
ActionHandler(updates, self._removeTemplates, names),
ActionHandler(updates, self._addTemplates, templates))
action.apply()
try:
for library in self._libraries.itervalues():
library.removeTemplate(action, name)
except:
# Rollback
action.unapply()
raise
return self.addAction(action, apply=False)
def setLinksAction(self, data):
old_links = dict(self)
new_links = self.createLinks(data)
updates = Updates(Update("generic-links", "update", -1))
action = Action(
ActionHandler(updates, self._setLinksRuleset, new_links),
ActionHandler(updates, self._setLinksRuleset, old_links))
action.apply()
self.ruleset.fusion.replace(self, action)
return self.ruleset.addAction(action, apply=False)
def addTemplate(self, logger, name):
loader_context = LoadRulesetContext(logger)
template = self._createTemplate(name, None)
# Set template mode
updates = Updates(Update("ruleset", "update", -1))
action = Action(
ActionHandler(updates, self._setTemplate),
ActionHandler(updates, self._unsetTemplate))
action.apply()
try:
# Register the template
names = (template.name,)
templates = (template,)
add_template = Action(
ActionHandler(updates, self._addTemplates, templates),
ActionHandler(updates, self._removeTemplates, names))
action.executeAndChain(add_template)
# Load the template objects (create actions)
self.loadFile(loader_context, "template", name, action=action,
from_template=name, ruleset_id=template.identifier)
# Unset template flag
unset = Action(
ActionHandler(updates, self._unsetTemplate),
ActionHandler(updates, self._setTemplate))
action.executeAndChain(unset)
except:
# Rollback
action.unapply()
raise
return self.addAction(action, apply=False)
def modifyObjectAction(self, object, new_attr):
"""
Modify the object using an action.
The result is the action which has already been executed.
"""
old_id = object.id
object.checkEditable()
old_attr = object.getAttributes()
new_id = new_attr["id"]
domain = object.update_domain
if old_id != new_id:
existing = self.get(new_id)
if (existing is not None) and (existing is not object):
duplicateIdentifierError(new_id)
apply_updates = Updates(Update(domain, "delete", old_id), Update(domain, "create", new_id))
unapply_updates = Updates(Update(domain, "delete", new_id), Update(domain, "create", old_id))
else:
apply_updates = Updates(Update(domain, "update", new_id))
unapply_updates = apply_updates
action = Action(
ActionHandler(apply_updates, self._setattr, object, new_attr),
ActionHandler(unapply_updates, self._setattr, object, old_attr),
)
if old_id != new_id and object.original_id:
set_original = Action(
ActionHandler(apply_updates, self._set_original_id, object, None),
ActionHandler(unapply_updates, self._set_original_id, object, object.original_id),
)
action.chain(set_original)
action.apply()
if old_id != new_id:
self._updateObjects(action, object.references, object, old_attr)
self._updateObjects(action, object.getReferents())
object.onModifyAction(action, old_attr)
return action
def ufwi_confSync(self, logger, netcfg):
action = Action.createEmpty()
self.createSystemNetworks(logger, netcfg, action)
return self.addAction(action, False)
def modifyObjectAction(self, acl, new_attr):
self.checkEditable(acl)
old_attr = acl.getAttributes()
if 'id' not in new_attr:
new_attr['id'] = old_attr['id']
tmp_acl = self.RULE_CLASS(self, new_attr)
domain = self.UPDATE_DOMAIN
chain_domain = self.UPDATE_CHAIN_DOMAIN
old_chain1 = self.getAclChain(acl)
old_chain2 = self.getAclChain(tmp_acl)
if old_chain1 == old_chain2:
if acl.id == tmp_acl.id:
apply_updates = Updates(Update(domain, "update", acl.id))
unapply_updates = apply_updates
else:
apply_updates = Updates(
Update(domain, "delete", acl.id),
Update(domain, "create", tmp_acl.id))
unapply_updates = Updates(
Update(domain, "delete", tmp_acl.id),
Update(domain, "create", acl.id))
referents = set(acl.getReferents()) ^ set(tmp_acl.getReferents())
action = Action(
ActionHandler(apply_updates, self._setattr, acl, new_attr),
ActionHandler(unapply_updates, self._setattr, acl, old_attr))
action.apply()
self._updateObjects(action, referents)
else:
old_order = old_chain1.getOrder(acl)
if 1 < len(old_chain1):
apply_update1 = Update(chain_domain, "update",
old_chain1.createUpdateKey())
unapply_update1 = Update(chain_domain, "update",
old_chain1.createUpdateKey(acl))
else:
apply_update1 = Update(chain_domain, "delete",
old_chain1.createUpdateKey())
unapply_update1 = Update(chain_domain, "create",
old_chain1.createUpdateKey(acl))
if old_chain2 is None:
old_chain2 = self.getAclChain(tmp_acl, create=True)
apply_update2 = Update(chain_domain, "create",
old_chain2.createUpdateKey(tmp_acl))
unapply_update2 = Update(chain_domain, "delete",
old_chain2.createUpdateKey())
else:
apply_update2 = Update(chain_domain, "update",
old_chain2.createUpdateKey(tmp_acl))
unapply_update2 = Update(chain_domain, "update",
old_chain2.createUpdateKey())
apply_updates = Updates(apply_update1, apply_update2)
unapply_updates = Updates(unapply_update2, unapply_update1)
action = Action(
ActionHandler(apply_updates, self._replace,
acl, new_attr, None),
ActionHandler(unapply_updates, self._replace,
acl, old_attr, old_order))
action.apply()
old_referents = set(acl.getReferents())
new_referents = set(tmp_acl.getReferents())
for object in (old_referents ^ new_referents):
# update references
update = object.createUpdate()
action.addApplyUpdate(update)
action.addUnapplyUpdate(update)
return action
