fb-pdnstools 1.0.0__py3-none-any.whl → 1.1.0__py3-none-any.whl

fb_pdnstools/bulk_rm_app.py

@@ -12,6 +12,7 @@ from __future__ import absolute_import
 # Standard modules
 import copy
 import ipaddress
+import locale
 import logging
 import os
 import pathlib
@@ -21,12 +22,12 @@ from functools import cmp_to_key
 
 # Third party modules
 from fb_tools.app import BaseApplication
+from fb_tools.argparse_actions import CfgFileOptionAction
 from fb_tools.common import compare_fqdn
 from fb_tools.common import pp
 from fb_tools.common import reverse_pointer
 from fb_tools.common import to_bool
 from fb_tools.common import to_str
-from fb_tools.config import CfgFileOptionAction
 from fb_tools.errors import FbAppError
 
 # Own modules
@@ -35,9 +36,15 @@ from . import DEFAULT_PORT
 from . import __version__ as GLOBAL_VERSION
 from .bulk_rm_cfg import PdnsBulkRmCfg
 from .server import PowerDNSServer
+from .xlate import DOMAIN
+from .xlate import LOCALE_DIR
 from .xlate import XLATOR
+from .xlate import __base_dir__ as __xlate_base_dir__
+from .xlate import __lib_dir__ as __xlate_lib_dir__
+from .xlate import __mo_file__ as __xlate_mo_file__
+from .xlate import __module_dir__ as __xlate_module_dir__
 
-__version__ = '0.7.3'
+__version__ = "1.0.0"
 LOG = logging.getLogger(__name__)
 
 _ = XLATOR.gettext
@@ -61,10 +68,11 @@ class PdnsBulkRmApp(BaseApplication):
     def __init__(self, appname=None, verbose=0, version=GLOBAL_VERSION, *args, **kwargs):
         """Initialize the PdnsBulkRmApp object."""
         desc = _(
-            'Removes the given addresses (A-, AAAA- or CNAME-Records) completety from '
-            'PowerDNS. If there are multiple entries to a DNS-Name, all appropriate '
-            'records are removed. Additionally all appropriate reverse entries (PTR-records) '
-            'were also removed, if they are pointing back to the given A- or AAAA-record.')
+            "Removes the given addresses (A-, AAAA- or CNAME-Records) completety from "
+            "PowerDNS. If there are multiple entries to a DNS-Name, all appropriate "
+            "records are removed. Additionally all appropriate reverse entries (PTR-records) "
+            "were also removed, if they are pointing back to the given A- or AAAA-record."
+        )
 
         self._cfg_file = None
         self.config = None
@@ -78,10 +86,7 @@ class PdnsBulkRmApp(BaseApplication):
         self.expected_ptr = None
 
         super(PdnsBulkRmApp, self).__init__(
-            description=desc,
-            verbose=verbose,
-            version=version,
-            *args, **kwargs
+            *args, **kwargs, description=desc, verbose=verbose, version=version,
         )
 
         self.initialized = True
@@ -114,8 +119,20 @@ class PdnsBulkRmApp(BaseApplication):
         @rtype:  dict
         """
         res = super(PdnsBulkRmApp, self).as_dict(short=short)
-        res['cfg_file'] = self.cfg_file
-        res['rm_reverse'] = self.rm_reverse
+        res["cfg_file"] = self.cfg_file
+        res["rm_reverse"] = self.rm_reverse
+
+        if "xlate" not in res:
+            res["xlate"] = {}
+
+        res["xlate"]["fb_vmware"] = {
+            "__module_dir__": __xlate_module_dir__,
+            "__lib_dir__": __xlate_lib_dir__,
+            "__base_dir__": __xlate_base_dir__,
+            "LOCALE_DIR": LOCALE_DIR,
+            "DOMAIN": DOMAIN,
+            "__mo_file__": __xlate_mo_file__,
+        }
 
         return res
 
@@ -138,8 +155,11 @@ class PdnsBulkRmApp(BaseApplication):
         self.perform_arg_parser()
 
         self.config = PdnsBulkRmCfg(
-            appname=self.appname, verbose=self.verbose, base_dir=self.base_dir,
-            config_file=self.cfg_file)
+            appname=self.appname,
+            verbose=self.verbose,
+            base_dir=self.base_dir,
+            config_file=self.cfg_file,
+        )
 
         self.config.read()
         if self.config.verbose > self.verbose:
@@ -147,7 +167,7 @@ class PdnsBulkRmApp(BaseApplication):
         self.config.initialized = True
 
         if self.verbose > 3:
-            LOG.debug('Read configuration:\n{}'.format(pp(self.config.as_dict())))
+            LOG.debug("Read configuration:\n{}".format(pp(self.config.as_dict())))
 
         self.perform_arg_parser_pdns()
 
@@ -155,15 +175,21 @@ class PdnsBulkRmApp(BaseApplication):
             self.read_address_file()
 
         if not self.addresses:
-            LOG.error(_('No addresses to remove given.'))
+            LOG.error(_("No addresses to remove given."))
             self.exit(1)
 
         self.pdns = PowerDNSServer(
-            appname=self.appname, verbose=self.verbose, base_dir=self.base_dir,
-            master_server=self.config.pdns_master, port=self.config.pdns_api_port,
-            key=self.config.pdns_api_key, use_https=self.config.pdns_api_https,
+            appname=self.appname,
+            verbose=self.verbose,
+            base_dir=self.base_dir,
+            master_server=self.config.pdns_master,
+            port=self.config.pdns_api_port,
+            key=self.config.pdns_api_key,
+            use_https=self.config.pdns_api_https,
             path_prefix=self.config.pdns_api_prefix,
-            simulate=self.simulate, force=self.force, initialized=True,
+            simulate=self.simulate,
+            force=self.force,
+            initialized=True,
         )
 
         self.pdns.initialized = True
@@ -174,69 +200,102 @@ class PdnsBulkRmApp(BaseApplication):
         """Public available method to initiate the argument parser."""
         super(PdnsBulkRmApp, self).init_arg_parser()
 
-        default_cfg_file = self.base_dir.joinpath('etc').joinpath(self.appname + '.ini')
+        default_cfg_file = self.base_dir.joinpath("etc").joinpath(self.appname + ".ini")
 
         self.arg_parser.add_argument(
-            '-c', '--config', '--config-file', dest='cfg_file', metavar=_('FILE'),
+            "-c",
+            "--config",
+            "--config-file",
+            dest="cfg_file",
+            metavar=_("FILE"),
             action=CfgFileOptionAction,
-            help=_('Configuration file (default: {!r})').format(default_cfg_file)
+            help=_("Configuration file (default: {!r})").format(default_cfg_file),
         )
 
-        pdns_group = self.arg_parser.add_argument_group(_('PowerDNS options'))
+        pdns_group = self.arg_parser.add_argument_group(_("PowerDNS options"))
 
         pdns_group.add_argument(
-            '-H', '--host', dest='host', metavar=_('HOST'),
+            "-H",
+            "--host",
+            dest="host",
+            metavar=_("HOST"),
             help=_(
-                'Address or hostname of the PowerDNS server providing '
-                'the API (Default: {!r}).').format(PdnsBulkRmCfg.default_pdns_master)
+                "Address or hostname of the PowerDNS server providing " "the API (Default: {!r})."
+            ).format(PdnsBulkRmCfg.default_pdns_master),
         )
 
         pdns_group.add_argument(
-            '-P', '--port', dest='port', type=int, metavar=_('PORT'),
-            help=_('Port on PowerDNS server for API on (Default: {}).').format(DEFAULT_PORT))
+            "-P",
+            "--port",
+            dest="port",
+            type=int,
+            metavar=_("PORT"),
+            help=_("Port on PowerDNS server for API on (Default: {}).").format(DEFAULT_PORT),
+        )
 
         pdns_group.add_argument(
-            '-K', '--key', '--api-key', metavar='KEY', dest='api_key',
-            help=_('The API key for accessing the PowerDNS API.')
+            "-K",
+            "--key",
+            "--api-key",
+            metavar="KEY",
+            dest="api_key",
+            help=_("The API key for accessing the PowerDNS API."),
         )
 
         pdns_group.add_argument(
-            '--https', action='store_true', dest='https',
-            help=_('Use HTTPS to access the PowerDNS API (Default: {}).').format(
-                PdnsBulkRmCfg.default_pdns_api_https),
+            "--https",
+            action="store_true",
+            dest="https",
+            help=_("Use HTTPS to access the PowerDNS API (Default: {}).").format(
+                PdnsBulkRmCfg.default_pdns_api_https
+            ),
         )
 
         pdns_group.add_argument(
-            '--prefix', dest='api_path_prefix',
+            "--prefix",
+            dest="api_path_prefix",
             help=_(
-                'The global prefix for all paths for accessing the PowerDNS API '
-                '(Default: {!r}).').format(DEFAULT_API_PREFIX)
+                "The global prefix for all paths for accessing the PowerDNS API "
+                "(Default: {!r})."
+            ).format(DEFAULT_API_PREFIX),
         )
 
         # Source of the addresses - file or cmdline arguments
         # source_group = self.arg_parser.add_mutually_exclusive_group()
 
         self.arg_parser.add_argument(
-            '-N', '--no-reverse', action='store_true', dest='no_reverse',
+            "-N",
+            "--no-reverse",
+            action="store_true",
+            dest="no_reverse",
             help=_(
                 "Don't remove reverse DNS entries (PTR records) to the given addresses. "
-                '(Default: False - reverse entries will be removed).')
+                "(Default: False - reverse entries will be removed)."
+            ),
         )
 
         self.arg_parser.add_argument(
-            '-F', '--file', metavar=_('FILE'), dest='addr_file', type=pathlib.Path,
+            "-F",
+            "--file",
+            metavar=_("FILE"),
+            dest="addr_file",
+            type=pathlib.Path,
             help=_(
-                'File containing the addresses to remove. The addresses must be '
-                'whitespace separeted, lines may be commented out by prepending them '
+                "File containing the addresses to remove. The addresses must be "
+                "whitespace separeted, lines may be commented out by prepending them "
                 "with a hash sign '#'. This option is mutually exclusive with "
-                'giving the addresses as command line arguments.')
+                "giving the addresses as command line arguments."
+            ),
         )
 
         self.arg_parser.add_argument(
-            'addresses', metavar=_('ADDRESS'), type=str, nargs='*',
+            "addresses",
+            metavar=_("ADDRESS"),
+            type=str,
+            nargs="*",
             help=_(
-                'Addresses to remove. This option is mutually exclusive with '
-                'the {!r} option.').format('-F/--file'),
+                "Addresses to remove. This option is mutually exclusive with " "the {!r} option."
+            ).format("-F/--file"),
         )
 
     # -------------------------------------------------------------------------
@@ -250,8 +309,9 @@ class PdnsBulkRmApp(BaseApplication):
         """Execute some actions after parsing the command line parameters."""
         if self.args.addr_file and self.args.addresses:
             msg = _(
-                'The option {!r} is mutually exclusive with giving the addresses '
-                'as command line arguments.').format('-F/--file')
+                "The option {!r} is mutually exclusive with giving the addresses "
+                "as command line arguments."
+            ).format("-F/--file")
             LOG.error(msg)
             self.arg_parser.print_usage(sys.stderr)
             self.exit(1)
@@ -259,15 +319,15 @@ class PdnsBulkRmApp(BaseApplication):
         if self.args.addr_file:
             afile = self.args.addr_file
             if not afile.exists():
-                msg = _('File {!r} does not exists.').format(str(afile))
+                msg = _("File {!r} does not exists.").format(str(afile))
                 LOG.error(msg)
                 self.exit(1)
             if not afile.is_file():
-                msg = _('File {!r} is not a regular file.').format(str(afile))
+                msg = _("File {!r} is not a regular file.").format(str(afile))
                 LOG.error(msg)
                 self.exit(1)
             if not os.access(str(afile), os.R_OK):
-                msg = _('No read access to file {!r}.').format(str(afile))
+                msg = _("No read access to file {!r}.").format(str(afile))
                 LOG.error(msg)
                 self.exit(1)
             self.address_file = afile
@@ -289,7 +349,7 @@ class PdnsBulkRmApp(BaseApplication):
         if self.args.addresses:
             for address in self.args.addresses:
                 addr = address.strip().lower()
-                if addr != '' and addr not in self.addresses:
+                if addr != "" and addr not in self.addresses:
                     self.addresses.append(addr)
 
     # -------------------------------------------------------------------------
@@ -297,26 +357,26 @@ class PdnsBulkRmApp(BaseApplication):
         """Read the file containing all addresses to remove."""
         content = self.read_file(self.address_file)
         if self.verbose > 2:
-            LOG.debug(_('Content of {!r}:').format(str(self.address_file)) + '\n' + content)
+            LOG.debug(_("Content of {!r}:").format(str(self.address_file)) + "\n" + content)
 
-        re_comment = re.compile(r'\s*#.*')
-        re_whitespace = re.compile(r'\s+')
+        re_comment = re.compile(r"\s*#.*")
+        re_whitespace = re.compile(r"\s+")
 
         addresses = []
         for line in content.splitlines():
-            line_stripped = re_comment.sub('', line).strip()
-            if line_stripped == '':
+            line_stripped = re_comment.sub("", line).strip()
+            if line_stripped == "":
                 continue
             for token in re_whitespace.split(line_stripped):
                 addr = token.strip().lower()
-                if addr != '' and addr not in addresses:
+                if addr != "" and addr not in addresses:
                     addresses.append(addr)
 
         if addresses:
             self.addresses = addresses
 
         if not self.addresses:
-            LOG.error(_('No addresses to remove found in {!r}.').format(str(self.address_file)))
+            LOG.error(_("No addresses to remove found in {!r}.").format(str(self.address_file)))
             self.exit(1)
 
     # -------------------------------------------------------------------------
@@ -329,8 +389,7 @@ class PdnsBulkRmApp(BaseApplication):
     def _run(self):
 
         print()
-        LOG.debug('Starting {a!r}, version {v!r} ...'.format(
-            a=self.appname, v=self.version))
+        LOG.debug("Starting {a!r}, version {v!r} ...".format(a=self.appname, v=self.version))
 
         ret = 0
         try:
@@ -354,19 +413,20 @@ class PdnsBulkRmApp(BaseApplication):
         """Display the informotion to t screen about simulation mode."""
         if not self.simulate:
             return
-        print(self.colored(_('Simulation mode - nothing will be removed in real.'), 'YELLOW'))
+        print(self.colored(_("Simulation mode - nothing will be removed in real."), "YELLOW"))
         print()
 
     # -------------------------------------------------------------------------
     def do_remove(self):
         """Remove finally all addresses in DNS."""
         for zone_name in sorted(
-                self.records2remove.keys(), key=lambda x: cmp_to_key(compare_fqdn)(x)):
+            self.records2remove.keys(), key=lambda x: cmp_to_key(compare_fqdn)(x)
+        ):
             print()
             zone = self.pdns.zones[zone_name]
             rrsets_rm = []
             for rrset in self.records2remove[zone_name]:
-                zone.add_rrset_for_remove(rrset['fqdn'], rrset['type'], rrsets_rm)
+                zone.add_rrset_for_remove(rrset["fqdn"], rrset["type"], rrsets_rm)
             zone.del_rrsets(rrsets_rm)
 
         print()
@@ -375,34 +435,34 @@ class PdnsBulkRmApp(BaseApplication):
     def _canon_addresses(self, addresses):
 
         if self.verbose > 1:
-            LOG.debug(_('Canonizing all given addresses.'))
+            LOG.debug(_("Canonizing all given addresses."))
         all_fqdns = []
 
         for addr in addresses:
 
             fqdn = self.pdns.name2fqdn(addr)
             if not fqdn:
-                LOG.warning(_('Address {!r} could not interpreted as a FQDN.').format(addr))
+                LOG.warning(_("Address {!r} could not interpreted as a FQDN.").format(addr))
                 continue
             if fqdn not in all_fqdns:
                 all_fqdns.append(fqdn)
 
         if self.verbose > 2:
-            LOG.debug(_('Canonized addresses:') + '\n' + pp(all_fqdns))
+            LOG.debug(_("Canonized addresses:") + "\n" + pp(all_fqdns))
         return all_fqdns
 
     # -------------------------------------------------------------------------
     def _get_zones_of_addresses(self, fqdns):
 
         if self.verbose > 1:
-            LOG.debug(_('Retrieve zones for canonized addresses.'))
+            LOG.debug(_("Retrieve zones for canonized addresses."))
         zones_of_records = {}
 
         for fqdn in fqdns:
 
             zones = self.pdns.get_all_zones_for_item(fqdn)
             if not zones:
-                LOG.warning(_('Did not found an appropriate zone for address {!r}.').format(fqdn))
+                LOG.warning(_("Did not found an appropriate zone for address {!r}.").format(fqdn))
                 continue
 
             for zone_name in zones:
@@ -411,14 +471,14 @@ class PdnsBulkRmApp(BaseApplication):
                 zones_of_records[zone_name][fqdn] = {}
 
         if self.verbose > 2:
-            LOG.debug(_('Zones of addresses:') + '\n' + pp(zones_of_records))
+            LOG.debug(_("Zones of addresses:") + "\n" + pp(zones_of_records))
         return zones_of_records
 
     # -------------------------------------------------------------------------
     def _verify_fqdns_in_pdns_zones(self, zone_name, zones_of_records, fqdns_found=None):
 
         if self.verbose > 1:
-            LOG.debug(_('Verifying FQDNs for zone {!r}.').format(zone_name))
+            LOG.debug(_("Verifying FQDNs for zone {!r}.").format(zone_name))
 
         if fqdns_found is None:
             fqdns_found = []
@@ -426,8 +486,11 @@ class PdnsBulkRmApp(BaseApplication):
         zone = self.pdns.zones[zone_name]
         zone.update()
         if self.verbose > 1:
-            LOG.debug(_('Found {c} resource record sets (RRSET) for zone {z!r}.').format(
-                c=len(zone.rrsets), z=zone_name))
+            LOG.debug(
+                _("Found {c} resource record sets (RRSET) for zone {z!r}.").format(
+                    c=len(zone.rrsets), z=zone_name
+                )
+            )
 
         for fqdn in zones_of_records[zone_name]:
             fqdns_in_zone_found = self._verify_fqdn_in_pdns_zone(zone_name, fqdn)
@@ -442,13 +505,16 @@ class PdnsBulkRmApp(BaseApplication):
         zone = self.pdns.zones[zone_name]
         fqdns_in_zone_found = []
 
-        fqdn_puny = to_str(fqdn.encode('idna'))
+        fqdn_puny = to_str(fqdn.encode("idna"))
         if self.verbose > 1:
             if fqdn != fqdn_puny:
-                LOG.debug(_('Searching {f!r} ({p!r}) in zone {z!r} ...').format(
-                    f=fqdn, p=fqdn_puny, z=zone_name))
+                LOG.debug(
+                    _("Searching {f!r} ({p!r}) in zone {z!r} ...").format(
+                        f=fqdn, p=fqdn_puny, z=zone_name
+                    )
+                )
             else:
-                LOG.debug(_('Searching {f!r} in zone {z!r} ...').format(f=fqdn, z=zone_name))
+                LOG.debug(_("Searching {f!r} in zone {z!r} ...").format(f=fqdn, z=zone_name))
 
         for rrset in zone.rrsets:
 
@@ -458,33 +524,35 @@ class PdnsBulkRmApp(BaseApplication):
                 if rrset.name != fqdn_puny:
                     continue
 
-            rrset2remove = {'fqdn': fqdn_puny, 'type': rrset.type.upper(), 'records': []}
+            rrset2remove = {"fqdn": fqdn_puny, "type": rrset.type.upper(), "records": []}
             found = False
             if zone.reverse_zone:
-                if rrset.type.upper() == 'PTR':
+                if rrset.type.upper() == "PTR":
                     found = True
             else:
-                if rrset.type.upper() in ('A', 'AAAA', 'CNAME'):
+                if rrset.type.upper() in ("A", "AAAA", "CNAME"):
                     found = True
             if not found:
                 continue
 
             for record in rrset.records:
-                if zone.reverse_zone and rrset.type.upper() == 'PTR':
+                if zone.reverse_zone and rrset.type.upper() == "PTR":
                     if self.expected_ptr is not None and fqdn_puny in self.expected_ptr:
                         ptr = self.pdns.decanon_name(fqdn_puny)
                         exp = self.pdns.decanon_name(self.expected_ptr[fqdn_puny])
                         addr = self.pdns.decanon_name(record.content)
                         if self.verbose > 1:
-                            LOG.debug(_('Expexted PTR: {p!r} => {a!r}.').format(p=ptr, a=exp))
+                            LOG.debug(_("Expexted PTR: {p!r} => {a!r}.").format(p=ptr, a=exp))
                         if record.content != self.expected_ptr[fqdn_puny]:
-                            LOG.warning(_(
-                                'PTR {p!r} does not pointing to expected {e!r}, '
-                                'but to {c!r} instead, ignoring for deletion.').format(
-                                p=ptr, e=exp, c=addr))
+                            LOG.warning(
+                                _(
+                                    "PTR {p!r} does not pointing to expected {e!r}, "
+                                    "but to {c!r} instead, ignoring for deletion."
+                                ).format(p=ptr, e=exp, c=addr)
+                            )
                             continue
-                record2remove = {'content': record.content, 'disabled': record.disabled}
-                rrset2remove['records'].append(record2remove)
+                record2remove = {"content": record.content, "disabled": record.disabled}
+                rrset2remove["records"].append(record2remove)
             if zone_name not in self.records2remove:
                 self.records2remove[zone_name] = []
             self.records2remove[zone_name].append(rrset2remove)
@@ -496,7 +564,7 @@ class PdnsBulkRmApp(BaseApplication):
     # -------------------------------------------------------------------------
     def verify_addresses(self, addresses):
         """Verify all given DNS addresses."""
-        LOG.debug(_('Verifying all given DNS addresses.'))
+        LOG.debug(_("Verifying all given DNS addresses."))
 
         fqdns_found = []
 
@@ -504,35 +572,36 @@ class PdnsBulkRmApp(BaseApplication):
         zones_of_records = self._get_zones_of_addresses(all_fqdns)
 
         if not zones_of_records:
-            msg = _('Did not found any addresses with an appropriate zone in PowerDNS.')
+            msg = _("Did not found any addresses with an appropriate zone in PowerDNS.")
             LOG.error(msg)
             return 1
 
         if self.verbose > 1:
-            LOG.debug(_('Found zones for addresses:') + '\n' + pp(zones_of_records))
+            LOG.debug(_("Found zones for addresses:") + "\n" + pp(zones_of_records))
 
         for zone_name in zones_of_records:
             fqdns_found = self._verify_fqdns_in_pdns_zones(
-                zone_name, zones_of_records, fqdns_found)
+                zone_name, zones_of_records, fqdns_found
+            )
         if self.verbose > 2:
-            LOG.debug(_('The following FQDNs were found:') + '\n' + pp(fqdns_found))
+            LOG.debug(_("The following FQDNs were found:") + "\n" + pp(fqdns_found))
 
         fqdns_not_found = []
         for fqdn in all_fqdns:
             if fqdn not in fqdns_found:
                 fqdns_not_found.append(fqdn)
         if fqdns_not_found:
-            msg = _('The following addresses (FQDNs) are not found:')
+            msg = _("The following addresses (FQDNs) are not found:")
             for fqdn in fqdns_not_found:
-                msg += '\n  * {!r}'.format(fqdn)
+                msg += "\n  * {!r}".format(fqdn)
             LOG.warning(msg)
 
         if not self.records2remove:
             return 1
 
         if self.verbose > 2:
-            msg = _('Found resource record sets to remove:')
-            msg += '\n' + pp(self.records2remove)
+            msg = _("Found resource record sets to remove:")
+            msg += "\n" + pp(self.records2remove)
             LOG.debug(msg)
 
         return 0
@@ -540,7 +609,7 @@ class PdnsBulkRmApp(BaseApplication):
     # -------------------------------------------------------------------------
     def get_reverse_records(self):
         """Evaluate reverse PTR records of A and AAAA records."""
-        LOG.debug(_('Evaluating reverse PTR records of A and AAAA records.'))
+        LOG.debug(_("Evaluating reverse PTR records of A and AAAA records."))
 
         addresses = []
         self.expected_ptr = {}
@@ -549,12 +618,12 @@ class PdnsBulkRmApp(BaseApplication):
 
             for rrset in self.records2remove[zone_name]:
 
-                if rrset['type'] not in ('A', 'AAAA'):
+                if rrset["type"] not in ("A", "AAAA"):
                     continue
 
-                for record in rrset['records']:
-                    addr_str = record['content']
-                    LOG.debug(_('Try to get reverse address of {!r} ...').format(addr_str))
+                for record in rrset["records"]:
+                    addr_str = record["content"]
+                    LOG.debug(_("Try to get reverse address of {!r} ...").format(addr_str))
                     addr = None
                     fqdn = None
 
@@ -562,100 +631,121 @@ class PdnsBulkRmApp(BaseApplication):
                         addr = ipaddress.ip_address(addr_str)
                         fqdn = self.pdns.canon_name(reverse_pointer(addr))
                     except ValueError:
-                        msg = _('IP address {!r} seems not to be a valid IP address.').format(
-                            addr_str)
+                        msg = _("IP address {!r} seems not to be a valid IP address.").format(
+                            addr_str
+                        )
                         LOG.error(msg)
                         continue
-                    LOG.debug(_('Found reverse address {!r}.').format(fqdn))
+                    LOG.debug(_("Found reverse address {!r}.").format(fqdn))
                     if fqdn not in addresses:
                         addresses.append(fqdn)
-                    self.expected_ptr[fqdn] = rrset['fqdn']
+                    self.expected_ptr[fqdn] = rrset["fqdn"]
 
         if not addresses:
             return 0
 
         if self.verbose > 1:
-            LOG.debug(_('Expected PTR records:') + '\n' + pp(self.expected_ptr))
+            LOG.debug(_("Expected PTR records:") + "\n" + pp(self.expected_ptr))
 
         return self.verify_addresses(addresses)
 
     # -------------------------------------------------------------------------
     def show_records(self):
         """Display all DNS records to remove on screen."""
-        title = _('All DNS records to remove')
+        title = _("All DNS records to remove")
         print()
         print(title)
-        print('=' * len(title))
+        print("=" * len(title))
         print()
 
-        disabled = _('Disabled.')
+        disabled = _("Disabled.")
         headers = {
-            'fqdn': _('Name'),
-            'z': _('Zone'),
-            'type': _('Type'),
-            'rec': _('Record'),
-            'dis': '',
+            "fqdn": _("Name"),
+            "z": _("Zone"),
+            "type": _("Type"),
+            "rec": _("Record"),
+            "dis": "",
         }
         lengths = {
-            'fqdn': len(headers['fqdn']),
-            'z': len(headers['z']),
-            'type': len(headers['type']),
-            'rec': len(headers['rec']),
-            'dis': len(disabled),
+            "fqdn": len(headers["fqdn"]),
+            "z": len(headers["z"]),
+            "type": len(headers["type"]),
+            "rec": len(headers["rec"]),
+            "dis": len(disabled),
         }
         count = 0
-        if lengths['type'] < 8:
-            lengths['type'] = 8
+        if lengths["type"] < 8:
+            lengths["type"] = 8
 
         for zone_name in self.records2remove.keys():
-            if len(zone_name) > lengths['z']:
-                lengths['z'] = len(zone_name)
+            if len(zone_name) > lengths["z"]:
+                lengths["z"] = len(zone_name)
             for rrset in self.records2remove[zone_name]:
-                fqdn = self.pdns.decanon_name(rrset['fqdn'])
-                rr_type = rrset['type']
-                if len(fqdn) > lengths['fqdn']:
-                    lengths['fqdn'] = len(fqdn)
-                if len(rr_type) > lengths['type']:
-                    lengths['type'] = len(rr_type)
-                for record in rrset['records']:
+                fqdn = self.pdns.decanon_name(rrset["fqdn"])
+                rr_type = rrset["type"]
+                if len(fqdn) > lengths["fqdn"]:
+                    lengths["fqdn"] = len(fqdn)
+                if len(rr_type) > lengths["type"]:
+                    lengths["type"] = len(rr_type)
+                for record in rrset["records"]:
                     count += 1
-                    content = self.pdns.decanon_name(record['content'])
-                    if len(content) > lengths['rec']:
-                        lengths['rec'] = len(content)
+                    content = self.pdns.decanon_name(record["content"])
+                    if len(content) > lengths["rec"]:
+                        lengths["rec"] = len(content)
 
-        tpl = '{{fqdn:<{}}}  '.format(lengths['fqdn'])
-        tpl += '{{z:<{}}}  '.format(lengths['z'])
-        tpl += '{{type:<{}}}  '.format(lengths['type'])
-        tpl += '{{rec:<{}}}  '.format(lengths['rec'])
-        tpl += '{{dis:<{}}}'.format(lengths['dis'])
+        tpl = "{{fqdn:<{}}}  ".format(lengths["fqdn"])
+        tpl += "{{z:<{}}}  ".format(lengths["z"])
+        tpl += "{{type:<{}}}  ".format(lengths["type"])
+        tpl += "{{rec:<{}}}  ".format(lengths["rec"])
+        tpl += "{{dis:<{}}}".format(lengths["dis"])
 
         header = tpl.format(**headers)
         print(header)
-        print('-' * len(header))
+        print("-" * len(header))
 
         for zone_name in sorted(
-                self.records2remove.keys(), key=lambda x: cmp_to_key(compare_fqdn)(x)):
+            self.records2remove.keys(), key=lambda x: cmp_to_key(compare_fqdn)(x)
+        ):
             for rrset in self.records2remove[zone_name]:
-                for record in rrset['records']:
-                    content = self.pdns.decanon_name(record['content'])
+                for record in rrset["records"]:
+                    content = self.pdns.decanon_name(record["content"])
                     out = {}
-                    out['z'] = self.pdns.decanon_name(zone_name)
-                    out['fqdn'] = self.pdns.decanon_name(rrset['fqdn'])
-                    out['type'] = rrset['type']
-                    out['rec'] = content
-                    if record['disabled']:
-                        out['dis'] = disabled
+                    out["z"] = self.pdns.decanon_name(zone_name)
+                    out["fqdn"] = self.pdns.decanon_name(rrset["fqdn"])
+                    out["type"] = rrset["type"]
+                    out["rec"] = content
+                    if record["disabled"]:
+                        out["dis"] = disabled
                     else:
-                        out['dis'] = ''
+                        out["dis"] = ""
                     print(tpl.format(**out))
         print()
-        msg = ngettext('Total one DNS record to remove.', 'Total {} DNS records to remove.', count)
+        msg = ngettext("Total one DNS record to remove.", "Total {} DNS records to remove.", count)
         print(msg.format(count))
         print()
 
 
 # =============================================================================
-if __name__ == '__main__':
+def main():
+    """Entrypoint for pdns-bulk-remove."""
+    my_path = pathlib.Path(__file__)
+    appname = my_path.name
+
+    locale.setlocale(locale.LC_ALL, "")
+
+    app = PdnsBulkRmApp(appname=appname)
+    app.initialized = True
+
+    if app.verbose > 2:
+        print(_("{c}-Object:\n{a}").format(c=app.__class__.__name__, a=app), file=sys.stderr)
+
+    app()
+
+    sys.exit(0)
+
+
+# =============================================================================
+if __name__ == "__main__":
 
     pass