X-Git-Url: https://git.llucax.com/software/pymin.git/blobdiff_plain/296d853cc95fd5bef262248cfe21b507abd26a4f..9c443d159056e112ed23af07afa38022882583b3:/pymin/services/firewall/__init__.py?ds=inline diff --git a/pymin/services/firewall/__init__.py b/pymin/services/firewall/__init__.py index dbf9b15..06b4191 100644 --- a/pymin/services/firewall/__init__.py +++ b/pymin/services/firewall/__init__.py @@ -8,62 +8,9 @@ from os import path from pymin.seqtools import Sequence from pymin.dispatcher import Handler, handler, HandlerError from pymin.services.util import Restorable, ConfigWriter, ServiceHandler, \ - TransactionalHandler - -__ALL__ = ('FirewallHandler', 'Error', 'RuleError', 'RuleAlreadyExistsError', - 'RuleNotFoundError') - -class Error(HandlerError): - r""" - Error(command) -> Error instance :: Base FirewallHandler exception class. - - All exceptions raised by the FirewallHandler inherits from this one, so you can - easily catch any FirewallHandler exception. - - message - A descriptive error message. - """ - - def __init__(self, message): - r"Initialize the Error object. See class documentation for more info." - self.message = message - - def __str__(self): - return self.message - -class RuleError(Error, KeyError): - r""" - RuleError(rule) -> RuleError instance. - - This is the base exception for all rule related errors. - """ - - def __init__(self, rule): - r"Initialize the object. See class documentation for more info." - self.message = 'Rule error: "%s"' % rule - -class RuleAlreadyExistsError(RuleError): - r""" - RuleAlreadyExistsError(rule) -> RuleAlreadyExistsError instance. - - This exception is raised when trying to add a rule that already exists. - """ - - def __init__(self, rule): - r"Initialize the object. See class documentation for more info." - self.message = 'Rule already exists: "%s"' % rule - -class RuleNotFoundError(RuleError): - r""" - RuleNotFoundError(rule) -> RuleNotFoundError instance. - - This exception is raised when trying to operate on a rule that doesn't - exists. - """ - - def __init__(self, rule): - r"Initialize the object. See class documentation for more info." - self.message = 'Rule not found: "%s"' % rule + TransactionalHandler, ListSubHandler +__ALL__ = ('FirewallHandler',) class Rule(Sequence): r"""Rule(chain, target[, src[, dst[, ...]]]) -> Rule instance. @@ -103,77 +50,24 @@ class Rule(Sequence): if src_port is not None: self.src_port = src_port if dst_port is not None: self.dst_port = dst_port - def __cmp__(self, other): - r"Compares two Rule objects." - if self.chain == other.chain \ - and self.target == other.target \ - and self.src == other.src \ - and self.dst == other.dst \ - and self.protocol == other.protocol \ - and self.src_port == other.src_port \ - and self.dst_port == other.dst_port: - return 0 - return cmp(id(self), id(other)) - def as_tuple(self): r"Return a tuple representing the rule." return (self.chain, self.target, self.src, self.dst, self.protocol, - self.src_port) + self.src_port, self.dst_port) -class RuleHandler(Handler): - r"""RuleHandler(rules) -> RuleHandler instance :: Handle a list of rules. +class RuleHandler(ListSubHandler): + r"""RuleHandler(parent) -> RuleHandler instance :: Handle a list of rules. This class is a helper for FirewallHandler to do all the work related to rules administration. - rules - A list of Rule objects. + parent - The parent service handler. """ - def __init__(self, rules): - r"Initialize the object, see class documentation for details." - self.rules = rules - - @handler(u'Add a new rule.') - def add(self, *args, **kwargs): - r"add(rule) -> None :: Add a rule to the rules list (see Rule doc)." - rule = Rule(*args, **kwargs) - if rule in self.rules: - raise RuleAlreadyExistsError(rule) - self.rules.append(rule) - - @handler(u'Update a rule.') - def update(self, index, *args, **kwargs): - r"update(index, rule) -> None :: Update a rule (see Rule doc)." - # TODO check if the modified rule is the same of an existing one - index = int(index) # TODO validation - try: - self.rules[index].update(*args, **kwargs) - except IndexError: - raise RuleNotFoundError(index) - - @handler(u'Delete a rule.') - def delete(self, index): - r"delete(index) -> Rule :: Delete a rule from the list returning it." - index = int(index) # TODO validation - try: - return self.rules.pop(index) - except IndexError: - raise RuleNotFoundError(index) - - @handler(u'Get information about a rule.') - def get(self, index): - r"get(rule) -> Rule :: Get all the information about a rule." - index = int(index) # TODO validation - try: - return self.rules[index] - except IndexError: - raise RuleNotFoundError(index) - - @handler(u'Get information about all rules.') - def show(self): - r"show() -> list of Rules :: List all the complete rules information." - return self.rules + handler_help = u"Manage firewall rules" + _cont_subhandler_attr = 'rules' + _cont_subhandler_class = Rule class FirewallHandler(Restorable, ConfigWriter, ServiceHandler, TransactionalHandler): @@ -188,7 +82,9 @@ class FirewallHandler(Restorable, ConfigWriter, ServiceHandler, Both defaults to the current working directory. """ - _persistent_attrs = 'rules' + handler_help = u"Manage firewall service" + + _persistent_attrs = ['rules'] _restorable_defaults = dict(rules=list()) @@ -199,14 +95,14 @@ class FirewallHandler(Restorable, ConfigWriter, ServiceHandler, r"Initialize the object, see class documentation for details." self._persistent_dir = pickle_dir self._config_writer_cfg_dir = config_dir - self._service_start = path.join(self._config_writer_cfg_dir, - self._config_writer_files) + self._service_start = ('sh', path.join(self._config_writer_cfg_dir, + self._config_writer_files)) self._service_stop = ('iptables', '-t', 'filter', '-F') self._service_restart = self._service_start self._service_reload = self._service_start self._config_build_templates() - self._restore() - self.rule = RuleHandler(self.rules) + ServiceHandler.__init__(self) + self.rule = RuleHandler(self) def _get_config_vars(self, config_file): return dict(rules=self.rules)