Don't run Python 3.5 tests twice.

* Add --allow-downgrade to chocolatey command.

* Upgrade tests to use Python 3.8.1.

.azure-pipelines/INSTALL.md

@@ -69,12 +69,12 @@ Access can be defined for all or only selected repositories, which is nice.
 ```
 
 - Redirected to Azure DevOps, select the account created in _Having an Azure DevOps account_ section.
-- Select the organization, and click "Create a new project" (let's name it the same than the targetted github repo)
+- Select the organization, and click "Create a new project" (let's name it the same than the targeted github repo)
 - The Visibility is public, to profit from 10 parallel jobs
 
 ```
 !!! ACCESS !!!
-Azure Pipelines needs access to the GitHub account (in term of beeing able to check it is valid), and the Resources shared between the GitHub account and Azure Pipelines.
+Azure Pipelines needs access to the GitHub account (in term of being able to check it is valid), and the Resources shared between the GitHub account and Azure Pipelines.
 ```
 
 _Done. We can move to pipelines configuration._

.azure-pipelines/templates/installer-tests.yml

@@ -40,7 +40,7 @@ jobs:
         displayName: Retrieve Windows installer
       - script: $(Build.SourcesDirectory)\bin\certbot-beta-installer-win32.exe /S
         displayName: Install Certbot
-      - powershell: Invoke-WebRequest https://www.python.org/ftp/python/3.8.0/python-3.8.0-amd64-webinstall.exe -OutFile C:\py3-setup.exe
+      - powershell: Invoke-WebRequest https://www.python.org/ftp/python/3.8.1/python-3.8.1-amd64-webinstall.exe -OutFile C:\py3-setup.exe
         displayName: Get Python
       - script: C:\py3-setup.exe /quiet PrependPath=1 InstallAllUsers=1 Include_launcher=1 InstallLauncherAllUsers=1 Include_test=0 Include_doc=0 Include_dev=1 Include_debug=0 Include_tcltk=0 TargetDir=C:\py3
         displayName: Install Python

.gitignore

@@ -26,6 +26,7 @@ tags
 \#*#
 .idea
 .ropeproject
+.vscode
 
 # auth --cert-path --chain-path
 /*.pem

.travis.yml

@@ -57,13 +57,10 @@ matrix:
       # cryptography we support cannot be compiled against the version of
       # OpenSSL in Xenial or newer.
       dist: trusty
-      env: TOXENV='py27-{acme,apache,apache-v2,certbot,dns,nginx}-oldest'
+      env: TOXENV='py27-{acme,apache,certbot,dns,nginx}-oldest'
       <<: *not-on-master
-    - python: "3.4"
-      env: TOXENV=py34
-      <<: *not-on-master
-    - python: "3.7"
-      env: TOXENV=py37
+    - python: "3.5"
+      env: TOXENV=py35
       <<: *not-on-master
     - python: "3.8"
       env: TOXENV=py38
@@ -163,31 +160,12 @@ matrix:
       sudo: required
       services: docker
       <<: *extended-test-suite
-    - python: "3.4"
-      env: TOXENV=py34
-      <<: *extended-test-suite
-    - python: "3.5"
-      env: TOXENV=py35
-      <<: *extended-test-suite
     - python: "3.6"
       env: TOXENV=py36
       <<: *extended-test-suite
     - python: "3.7"
       env: TOXENV=py37
       <<: *extended-test-suite
-    - python: "3.8"
-      env: TOXENV=py38
-      <<: *extended-test-suite
-    - python: "3.4"
-      env: ACME_SERVER=boulder-v1 TOXENV=integration
-      sudo: required
-      services: docker
-      <<: *extended-test-suite
-    - python: "3.4"
-      env: ACME_SERVER=boulder-v2 TOXENV=integration
-      sudo: required
-      services: docker
-      <<: *extended-test-suite
     - python: "3.5"
       env: ACME_SERVER=boulder-v1 TOXENV=integration
       sudo: required
@@ -232,6 +210,10 @@ matrix:
       env: TOXENV=le_auto_centos6
       services: docker
       <<: *extended-test-suite
+    - sudo: required
+      env: TOXENV=le_auto_oraclelinux6
+      services: docker
+      <<: *extended-test-suite
     - sudo: required
       env: TOXENV=docker_dev
       services: docker

acme/acme/client.py

@@ -942,7 +942,7 @@ class ClientNetwork(object):
     :param messages.RegistrationResource account: Account object. Required if you are
             planning to use .post() with acme_version=2 for anything other than
             creating a new account; may be set later after registering.
-    :param josepy.JWASignature alg: Algoritm to use in signing JWS.
+    :param josepy.JWASignature alg: Algorithm to use in signing JWS.
     :param bool verify_ssl: Whether to verify certificates on SSL connections.
     :param str user_agent: String to send as User-Agent header.
     :param float timeout: Timeout for requests.

acme/acme/messages.py

@@ -36,7 +36,7 @@ ERROR_CODES = {
                    ' domain'),
     'dns': 'There was a problem with a DNS query during identifier validation',
     'dnssec': 'The server could not validate a DNSSEC signed domain',
-    'incorrectResponse': 'Response recieved didn\'t match the challenge\'s requirements',
+    'incorrectResponse': 'Response received didn\'t match the challenge\'s requirements',
     # deprecate invalidEmail
     'invalidEmail': 'The provided email for a registration was invalid',
     'invalidContact': 'The provided contact URI was invalid',
@@ -245,13 +245,13 @@ class Directory(jose.JSONDeSerializable):
         try:
             return self[name.replace('_', '-')]
         except KeyError as error:
-            raise AttributeError(str(error) + ': ' + name)
+            raise AttributeError(str(error))
 
     def __getitem__(self, name):
         try:
             return self._jobj[self._canon_key(name)]
         except KeyError:
-            raise KeyError('Directory field not found')
+            raise KeyError('Directory field "' + self._canon_key(name) + '" not found')
 
     def to_partial_json(self):
         return self._jobj

acme/docs/conf.py

@@ -41,7 +41,7 @@ extensions = [
 ]
 
 autodoc_member_order = 'bysource'
-autodoc_default_flags = ['show-inheritance', 'private-members']
+autodoc_default_flags = ['show-inheritance']
 
 # Add any paths that contain templates here, relative to this directory.
 templates_path = ['_templates']

acme/setup.py

@@ -4,7 +4,7 @@ from setuptools import find_packages
 from setuptools import setup
 from setuptools.command.test import test as TestCommand
 
-version = '1.1.0.dev0'
+version = '1.2.0.dev0'
 
 # Please update tox.ini when modifying dependency version requirements
 install_requires = [

certbot-apache/certbot_apache/_internal/apache_util.py

@@ -1,17 +1,9 @@
 """ Utility functions for certbot-apache plugin """
 import binascii
-import fnmatch
-import logging
-import re
-import subprocess
 
-from certbot import errors
 from certbot import util
-
 from certbot.compat import os
 
-logger = logging.getLogger(__name__)
-
 
 def get_mod_deps(mod_name):
     """Get known module dependencies.
@@ -113,131 +105,3 @@ def parse_define_file(filepath, varname):
 def unique_id():
     """ Returns an unique id to be used as a VirtualHost identifier"""
     return binascii.hexlify(os.urandom(16)).decode("utf-8")
-
-
-def included_in_paths(filepath, paths):
-    """
-    Returns true if the filepath is included in the list of paths
-    that may contain full paths or wildcard paths that need to be
-    expanded.
-
-    :param str filepath: Filepath to check
-    :params list paths: List of paths to check against
-
-    :returns: True if included
-    :rtype: bool
-    """
-
-    return any([fnmatch.fnmatch(filepath, path) for path in paths])
-
-
-def parse_defines(apachectl):
-    """
-    Gets Defines from httpd process and returns a dictionary of
-    the defined variables.
-
-    :param str apachectl: Path to apachectl executable
-
-    :returns: dictionary of defined variables
-    :rtype: dict
-    """
-
-    variables = dict()
-    define_cmd = [apachectl, "-t", "-D",
-                  "DUMP_RUN_CFG"]
-    matches = parse_from_subprocess(define_cmd, r"Define: ([^ \n]*)")
-    try:
-        matches.remove("DUMP_RUN_CFG")
-    except ValueError:
-        return {}
-
-    for match in matches:
-        if match.count("=") > 1:
-            logger.error("Unexpected number of equal signs in "
-                         "runtime config dump.")
-            raise errors.PluginError(
-                "Error parsing Apache runtime variables")
-        parts = match.partition("=")
-        variables[parts[0]] = parts[2]
-
-    return variables
-
-
-def parse_includes(apachectl):
-    """
-    Gets Include directives from httpd process and returns a list of
-    their values.
-
-    :param str apachectl: Path to apachectl executable
-
-    :returns: list of found Include directive values
-    :rtype: list of str
-    """
-
-    inc_cmd = [apachectl, "-t", "-D",
-               "DUMP_INCLUDES"]
-    return parse_from_subprocess(inc_cmd, r"\(.*\) (.*)")
-
-
-def parse_modules(apachectl):
-    """
-    Get loaded modules from httpd process, and return the list
-    of loaded module names.
-
-    :param str apachectl: Path to apachectl executable
-
-    :returns: list of found LoadModule module names
-    :rtype: list of str
-    """
-
-    mod_cmd = [apachectl, "-t", "-D",
-               "DUMP_MODULES"]
-    return parse_from_subprocess(mod_cmd, r"(.*)_module")
-
-
-def parse_from_subprocess(command, regexp):
-    """Get values from stdout of subprocess command
-
-    :param list command: Command to run
-    :param str regexp: Regexp for parsing
-
-    :returns: list parsed from command output
-    :rtype: list
-
-    """
-    stdout = _get_runtime_cfg(command)
-    return re.compile(regexp).findall(stdout)
-
-
-def _get_runtime_cfg(command):
-    """
-    Get runtime configuration info.
-
-    :param command: Command to run
-
-    :returns: stdout from command
-
-    """
-    try:
-        proc = subprocess.Popen(
-            command,
-            stdout=subprocess.PIPE,
-            stderr=subprocess.PIPE,
-            universal_newlines=True)
-        stdout, stderr = proc.communicate()
-
-    except (OSError, ValueError):
-        logger.error(
-            "Error running command %s for runtime parameters!%s",
-            command, os.linesep)
-        raise errors.MisconfigurationError(
-            "Error accessing loaded Apache parameters: {0}".format(
-                command))
-    # Small errors that do not impede
-    if proc.returncode != 0:
-        logger.warning("Error in checking parameter list: %s", stderr)
-        raise errors.MisconfigurationError(
-            "Apache is unable to check whether or not the module is "
-            "loaded because Apache is misconfigured.")
-
-    return stdout

certbot-apache/certbot_apache/_internal/apacheparser.py

@@ -1,242 +0,0 @@
-""" apacheconfig implementation of the ParserNode interfaces """
-
-from functools import partial
-
-from certbot import errors
-
-from certbot_apache._internal import assertions
-from certbot_apache._internal import interfaces
-from certbot_apache._internal import parsernode_util as util
-
-
-class ApacheParserNode(interfaces.ParserNode):
-    """ apacheconfig implementation of ParserNode interface.
-
-        Expects metadata `ac_ast` to be passed in, where `ac_ast` is the AST provided
-        by parsing the equivalent configuration text using the apacheconfig library.
-    """
-
-    def __init__(self, **kwargs):
-        ancestor, dirty, filepath, metadata = util.parsernode_kwargs(kwargs)  # pylint: disable=unused-variable
-        super(ApacheParserNode, self).__init__(**kwargs)
-        self.ancestor = ancestor
-        self.filepath = filepath
-        self.dirty = dirty
-        self.metadata = metadata
-        self._raw = self.metadata["ac_ast"]
-
-    def save(self, msg): # pragma: no cover
-        pass
-
-    def find_ancestors(self, name):  # pylint: disable=unused-variable
-        """Find ancestor BlockNodes with a given name"""
-        return [ApacheBlockNode(name=assertions.PASS,
-                                parameters=assertions.PASS,
-                                ancestor=self,
-                                filepath=assertions.PASS,
-                                metadata=self.metadata)]
-
-
-class ApacheCommentNode(ApacheParserNode):
-    """ apacheconfig implementation of CommentNode interface """
-
-    def __init__(self, **kwargs):
-        comment, kwargs = util.commentnode_kwargs(kwargs)  # pylint: disable=unused-variable
-        super(ApacheCommentNode, self).__init__(**kwargs)
-        self.comment = comment
-
-    def __eq__(self, other):  # pragma: no cover
-        if isinstance(other, self.__class__):
-            return (self.comment == other.comment and
-                    self.dirty == other.dirty and
-                    self.ancestor == other.ancestor and
-                    self.metadata == other.metadata and
-                    self.filepath == other.filepath)
-        return False
-
-
-class ApacheDirectiveNode(ApacheParserNode):
-    """ apacheconfig implementation of DirectiveNode interface """
-
-    def __init__(self, **kwargs):
-        name, parameters, enabled, kwargs = util.directivenode_kwargs(kwargs)
-        super(ApacheDirectiveNode, self).__init__(**kwargs)
-        self.name = name
-        self.parameters = parameters
-        self.enabled = enabled
-        self.include = None
-
-    def __eq__(self, other):  # pragma: no cover
-        if isinstance(other, self.__class__):
-            return (self.name == other.name and
-                    self.filepath == other.filepath and
-                    self.parameters == other.parameters and
-                    self.enabled == other.enabled and
-                    self.dirty == other.dirty and
-                    self.ancestor == other.ancestor and
-                    self.metadata == other.metadata)
-        return False
-
-    def set_parameters(self, _parameters):
-        """Sets the parameters for DirectiveNode"""
-        return
-
-
-def _parameters_from_string(text):
-    text = text.strip()
-    words = []
-    word = ""
-    quote = None
-    escape = False
-    for c in text:
-        if c.isspace() and not quote:
-            if word:
-                words.append(word)
-            word = ""
-        else:
-            word += c
-        if not escape:
-            if not quote and c in "\"\'":
-                quote = c
-            elif c == quote:
-                words.append(word[1:-1])
-                word = ""
-                quote = None
-        escape = c == "\\"
-    if word:
-        words.append(word)
-    return tuple(words)
-
-
-class ApacheBlockNode(ApacheDirectiveNode):
-    """ apacheconfig implementation of BlockNode interface """
-
-    def __init__(self, **kwargs):
-        super(ApacheBlockNode, self).__init__(**kwargs)
-        self._raw_children = self._raw
-        children = []
-        for raw_node in self._raw_children:
-            metadata = self.metadata.copy()
-            metadata['ac_ast'] = raw_node
-            if raw_node.typestring == "comment":
-                node = ApacheCommentNode(comment=raw_node.name[2:],
-                                         metadata=metadata, ancestor=self,
-                                         filepath=self.filepath)
-            elif raw_node.typestring == "block":
-                parameters = _parameters_from_string(raw_node.arguments)
-                node = ApacheBlockNode(name=raw_node.tag, parameters=parameters,
-                                       metadata=metadata, ancestor=self,
-                                       filepath=self.filepath, enabled=self.enabled)
-            else:
-                parameters = ()
-                if raw_node.value:
-                    parameters = _parameters_from_string(raw_node.value)
-                node = ApacheDirectiveNode(name=raw_node.name, parameters=parameters,
-                                           metadata=metadata, ancestor=self,
-                                           filepath=self.filepath, enabled=self.enabled)
-            children.append(node)
-        self.children = tuple(children)
-
-    def __eq__(self, other):  # pragma: no cover
-        if isinstance(other, self.__class__):
-            return (self.name == other.name and
-                    self.filepath == other.filepath and
-                    self.parameters == other.parameters and
-                    self.children == other.children and
-                    self.enabled == other.enabled and
-                    self.dirty == other.dirty and
-                    self.ancestor == other.ancestor and
-                    self.metadata == other.metadata)
-        return False
-
-    def _add_child_thing(self, raw_string, partial_node, position):
-        position = len(self._raw_children) if not position else position
-        # Cap position to length to mimic AugeasNode behavior. TODO: document that this happens
-        position = min(len(self._raw_children), position)
-        raw_ast = self._raw_children.add(position, raw_string)
-        metadata = self.metadata.copy()
-        metadata['ac_ast'] = raw_ast
-        new_node = partial_node(ancestor=self, metadata=metadata, filepath=self.filepath)
-
-        # Update metadata
-        children = list(self.children)
-        children.insert(position, new_node)
-        self.children = tuple(children)
-        return new_node
-
-    def add_child_block(self, name, parameters=None, position=None):
-        """Adds a new BlockNode to the sequence of children"""
-        parameters_str = " " + " ".join(parameters) if parameters else ""
-        if not parameters:
-            parameters = []
-        partial_block = partial(ApacheBlockNode, name=name,
-                                parameters=tuple(parameters), enabled=self.enabled)
-        return self._add_child_thing("\n<%s%s>\n</%s>" % (name, parameters_str, name),
-                                                         partial_block, position)
-
-    def add_child_directive(self, name, parameters=None, position=None):
-        """Adds a new DirectiveNode to the sequence of children"""
-        parameters_str = " " + " ".join(parameters) if parameters else ""
-        if not parameters:  # TODO (mona): test
-            parameters = []  # pragma: no cover
-        partial_block = partial(ApacheDirectiveNode, name=name,
-                                parameters=tuple(parameters), enabled=self.enabled)
-        return self._add_child_thing("\n%s%s" % (name, parameters_str), partial_block, position)
-
-    def add_child_comment(self, comment="", position=None):
-        """Adds a new CommentNode to the sequence of children"""
-        partial_comment = partial(ApacheCommentNode, comment=comment)
-        return self._add_child_thing(comment, partial_comment, position)
-
-    def find_blocks(self, name, exclude=True): # pylint: disable=unused-argument
-        """Recursive search of BlockNodes from the sequence of children"""
-        return [ApacheBlockNode(name=assertions.PASS,
-                                parameters=assertions.PASS,
-                                ancestor=self,
-                                filepath=assertions.PASS,
-                                metadata=self.metadata)]
-
-    def find_directives(self, name, exclude=True): # pylint: disable=unused-argument
-        """Recursive search of DirectiveNodes from the sequence of children"""
-        return [ApacheDirectiveNode(name=assertions.PASS,
-                                    parameters=assertions.PASS,
-                                    ancestor=self,
-                                    filepath=assertions.PASS,
-                                    metadata=self.metadata)]
-
-    def find_comments(self, comment, exact=False): # pylint: disable=unused-argument
-        """Recursive search of DirectiveNodes from the sequence of children"""
-        return [ApacheCommentNode(comment=assertions.PASS,
-                                  ancestor=self,
-                                  filepath=assertions.PASS,
-                                  metadata=self.metadata)]
-
-    # TODO (mona): test
-    def delete_child(self, child):  # pragma: no cover
-        """Deletes a ParserNode from the sequence of children"""
-        index = -1
-        i = None
-        for i, elem in enumerate(self.children):
-            if elem == child:
-                index = i
-                break
-        if index < 0:
-            raise errors.PluginError("Could not find child node to delete")
-        children_list = list(self.children)
-        thing = children_list.pop(i)
-        self.children = tuple(children_list)
-        self._raw_children.remove(i)
-        return thing
-
-    def unsaved_files(self):  # pragma: no cover
-        """Returns a list of unsaved filepaths"""
-        return [assertions.PASS]
-
-    def parsed_paths(self):  # pragma: no cover
-        """Returns a list of parsed configuration file paths"""
-        return [assertions.PASS]
-
-
-interfaces.CommentNode.register(ApacheCommentNode)
-interfaces.DirectiveNode.register(ApacheDirectiveNode)
-interfaces.BlockNode.register(ApacheBlockNode)

certbot-apache/certbot_apache/_internal/assertions.py

@@ -1,142 +0,0 @@
-"""Dual parser node assertions"""
-import fnmatch
-
-from certbot_apache._internal import interfaces
-
-
-PASS = "CERTBOT_PASS_ASSERT"
-
-
-def assertEqual(first, second):
-    """ Equality assertion """
-
-    if isinstance(first, interfaces.CommentNode):
-        assertEqualComment(first, second)
-    elif isinstance(first, interfaces.DirectiveNode):
-        assertEqualDirective(first, second)
-
-    # Do an extra interface implementation assertion, as the contents were
-    # already checked for BlockNode in the assertEqualDirective
-    if isinstance(first, interfaces.BlockNode):
-        assert isinstance(second, interfaces.BlockNode)
-
-    # Skip tests if filepath includes the pass value. This is done
-    # because filepath is variable of the base ParserNode interface, and
-    # unless the implementation is actually done, we cannot assume getting
-    # correct results from boolean assertion for dirty
-    if not isPass(first.filepath) and not isPass(second.filepath):
-        assert first.dirty == second.dirty
-        # We might want to disable this later if testing with two separate
-        # (but identical) directory structures.
-        assert first.filepath == second.filepath
-
-def assertEqualComment(first, second): # pragma: no cover
-    """ Equality assertion for CommentNode """
-
-    assert isinstance(first, interfaces.CommentNode)
-    assert isinstance(second, interfaces.CommentNode)
-
-    if not isPass(first.comment) and not isPass(second.comment):  # type: ignore
-        assert first.comment == second.comment  # type: ignore
-
-def _assertEqualDirectiveComponents(first, second): # pragma: no cover
-    """ Handles assertion for instance variables for DirectiveNode and BlockNode"""
-
-    # Enabled value cannot be asserted, because Augeas implementation
-    # is unable to figure that out.
-    # assert first.enabled == second.enabled
-    if not isPass(first.name) and not isPass(second.name):
-        assert first.name == second.name
-
-    if not isPass(first.parameters) and not isPass(second.parameters):
-        assert first.parameters == second.parameters
-
-def assertEqualDirective(first, second):
-    """ Equality assertion for DirectiveNode """
-
-    assert isinstance(first, interfaces.DirectiveNode)
-    assert isinstance(second, interfaces.DirectiveNode)
-    _assertEqualDirectiveComponents(first, second)
-
-def isPass(value): # pragma: no cover
-    """Checks if the value is set to PASS"""
-    if isinstance(value, bool):
-        return True
-    return PASS in value
-
-def isPassDirective(block):
-    """ Checks if BlockNode or DirectiveNode should pass the assertion """
-
-    if isPass(block.name):
-        return True
-    if isPass(block.parameters): # pragma: no cover
-        return True
-    if isPass(block.filepath): # pragma: no cover
-        return True
-    return False
-
-def isPassComment(comment):
-    """ Checks if CommentNode should pass the assertion """
-
-    if isPass(comment.comment):
-        return True
-    if isPass(comment.filepath): # pragma: no cover
-        return True
-    return False
-
-def isPassNodeList(nodelist): # pragma: no cover
-    """ Checks if a ParserNode in the nodelist should pass the assertion,
-    this function is used for results of find_* methods. Unimplemented find_*
-    methods should return a sequence containing a single ParserNode instance
-    with assertion pass string."""
-
-    try:
-        node = nodelist[0]
-    except IndexError:
-        node = None
-
-    if not node: # pragma: no cover
-        return False
-
-    if isinstance(node, interfaces.DirectiveNode):
-        return isPassDirective(node)
-    return isPassComment(node)
-
-def assertEqualSimple(first, second):
-    """ Simple assertion """
-    if not isPass(first) and not isPass(second):
-        assert first == second
-
-def isEqualVirtualHost(first, second):
-    """
-    Checks that two VirtualHost objects are similar. There are some built
-    in differences with the implementations: VirtualHost created by ParserNode
-    implementation doesn't have "path" defined, as it was used for Augeas path
-    and that cannot obviously be used in the future. Similarly the legacy
-    version lacks "node" variable, that has a reference to the BlockNode for the
-    VirtualHost.
-    """
-    return (
-        first.name == second.name and
-        first.aliases == second.aliases and
-        first.filep == second.filep and
-        first.addrs == second.addrs and
-        first.ssl == second.ssl and
-        first.enabled == second.enabled and
-        first.modmacro == second.modmacro and
-        first.ancestor == second.ancestor
-    )
-
-def assertEqualPathsList(first, second):  # pragma: no cover
-    """
-    Checks that the two lists of file paths match. This assertion allows for wildcard
-    paths.
-    """
-    if any([isPass(path) for path in first]):
-        return
-    if any([isPass(path) for path in second]):
-        return
-    for fpath in first:
-        assert any([fnmatch.fnmatch(fpath, spath) for spath in second])
-    for spath in second:
-        assert any([fnmatch.fnmatch(fpath, spath) for fpath in first])

certbot-apache/certbot_apache/_internal/augeasparser.py

@@ -1,538 +0,0 @@
-"""
-Augeas implementation of the ParserNode interfaces.
-
-Augeas works internally by using XPATH notation. The following is a short example
-of how this all works internally, to better understand what's going on under the
-hood.
-
-A configuration file /etc/apache2/apache2.conf with the following content:
-
-    # First comment line
-    # Second comment line
-    WhateverDirective whatevervalue
-    <ABlock>
-        DirectiveInABlock dirvalue
-    </ABlock>
-    SomeDirective somedirectivevalue
-    <ABlock>
-        AnotherDirectiveInABlock dirvalue
-    </ABlock>
-    # Yet another comment
-
-
-Translates over to Augeas path notation (of immediate children), when calling
-for example: aug.match("/files/etc/apache2/apache2.conf/*")
-
-[
-    "/files/etc/apache2/apache2.conf/#comment[1]",
-    "/files/etc/apache2/apache2.conf/#comment[2]",
-    "/files/etc/apache2/apache2.conf/directive[1]",
-    "/files/etc/apache2/apache2.conf/ABlock[1]",
-    "/files/etc/apache2/apache2.conf/directive[2]",
-    "/files/etc/apache2/apache2.conf/ABlock[2]",
-    "/files/etc/apache2/apache2.conf/#comment[3]"
-]
-
-Regardless of directives name, its key in the Augeas tree is always "directive",
-with index where needed of course. Comments work similarly, while blocks
-have their own key in the Augeas XPATH notation.
-
-It's important to note that all of the unique keys have their own indices.
-
-Augeas paths are case sensitive, while Apache configuration is case insensitive.
-It looks like this:
-
-    <block>
-        directive value
-    </block>
-    <Block>
-        Directive Value
-    </Block>
-    <block>
-        directive value
-    </block>
-    <bLoCk>
-        DiReCtiVe VaLuE
-    </bLoCk>
-
-Translates over to:
-
-[
-    "/files/etc/apache2/apache2.conf/block[1]",
-    "/files/etc/apache2/apache2.conf/Block[1]",
-    "/files/etc/apache2/apache2.conf/block[2]",
-    "/files/etc/apache2/apache2.conf/bLoCk[1]",
-]
-"""
-from acme.magic_typing import Set  # pylint: disable=unused-import, no-name-in-module
-from certbot import errors
-from certbot.compat import os
-
-from certbot_apache._internal import apache_util
-from certbot_apache._internal import assertions
-from certbot_apache._internal import interfaces
-from certbot_apache._internal import parser
-from certbot_apache._internal import parsernode_util as util
-
-
-class AugeasParserNode(interfaces.ParserNode):
-    """ Augeas implementation of ParserNode interface """
-
-    def __init__(self, **kwargs):
-        ancestor, dirty, filepath, metadata = util.parsernode_kwargs(kwargs)  # pylint: disable=unused-variable
-        super(AugeasParserNode, self).__init__(**kwargs)
-        self.ancestor = ancestor
-        self.filepath = filepath
-        self.dirty = dirty
-        self.metadata = metadata
-        self.parser = self.metadata.get("augeasparser")
-        try:
-            if self.metadata["augeaspath"].endswith("/"):
-                raise errors.PluginError(
-                    "Augeas path: {} has a trailing slash".format(
-                        self.metadata["augeaspath"]
-                    )
-                )
-        except KeyError:
-            raise errors.PluginError("Augeas path is required")
-
-    def save(self, msg):
-        self.parser.save(msg)
-
-    def find_ancestors(self, name):
-        """
-        Searches for ancestor BlockNodes with a given name.
-
-        :param str name: Name of the BlockNode parent to search for
-
-        :returns: List of matching ancestor nodes.
-        :rtype: list of AugeasBlockNode
-        """
-
-        ancestors = []
-
-        parent = self.metadata["augeaspath"]
-        while True:
-            # Get the path of ancestor node
-            parent = parent.rpartition("/")[0]
-            # Root of the tree
-            if not parent or parent == "/files":
-                break
-            anc = self._create_blocknode(parent)
-            if anc.name.lower() == name.lower():
-                ancestors.append(anc)
-
-        return ancestors
-
-    def _create_blocknode(self, path):
-        """
-        Helper function to create a BlockNode from Augeas path. This is used by
-        AugeasParserNode.find_ancestors and AugeasBlockNode.
-        and AugeasBlockNode.find_blocks
-
-        """
-
-        name = self._aug_get_name(path)
-        metadata = {"augeasparser": self.parser, "augeaspath": path}
-
-        # Check if the file was included from the root config or initial state
-        enabled = self.parser.parsed_in_original(
-            apache_util.get_file_path(path)
-        )
-
-        return AugeasBlockNode(name=name,
-                               enabled=enabled,
-                               ancestor=assertions.PASS,
-                               filepath=apache_util.get_file_path(path),
-                               metadata=metadata)
-
-    def _aug_get_name(self, path):
-        """
-        Helper function to get name of a configuration block or variable from path.
-        """
-
-        # Remove the ending slash if any
-        if path[-1] == "/":  # pragma: no cover
-            path = path[:-1]
-
-        # Get the block name
-        name = path.split("/")[-1]
-
-        # remove [...], it's not allowed in Apache configuration and is used
-        # for indexing within Augeas
-        name = name.split("[")[0]
-        return name
-
-
-class AugeasCommentNode(AugeasParserNode):
-    """ Augeas implementation of CommentNode interface """
-
-    def __init__(self, **kwargs):
-        comment, kwargs = util.commentnode_kwargs(kwargs)  # pylint: disable=unused-variable
-        super(AugeasCommentNode, self).__init__(**kwargs)
-        # self.comment = comment
-        self.comment = comment
-
-    def __eq__(self, other):
-        if isinstance(other, self.__class__):
-            return (self.comment == other.comment and
-                    self.filepath == other.filepath and
-                    self.dirty == other.dirty and
-                    self.ancestor == other.ancestor and
-                    self.metadata == other.metadata)
-        return False
-
-
-class AugeasDirectiveNode(AugeasParserNode):
-    """ Augeas implementation of DirectiveNode interface """
-
-    def __init__(self, **kwargs):
-        name, parameters, enabled, kwargs = util.directivenode_kwargs(kwargs)
-        super(AugeasDirectiveNode, self).__init__(**kwargs)
-        self.name = name
-        self.enabled = enabled
-        if parameters:
-            self.set_parameters(parameters)
-
-    def __eq__(self, other):
-        if isinstance(other, self.__class__):
-            return (self.name == other.name and
-                    self.filepath == other.filepath and
-                    self.parameters == other.parameters and
-                    self.enabled == other.enabled and
-                    self.dirty == other.dirty and
-                    self.ancestor == other.ancestor and
-                    self.metadata == other.metadata)
-        return False
-
-    def set_parameters(self, parameters):
-        """
-        Sets parameters of a DirectiveNode or BlockNode object.
-
-        :param list parameters: List of all parameters for the node to set.
-        """
-        orig_params = self._aug_get_params(self.metadata["augeaspath"])
-
-        # Clear out old parameters
-        for _ in orig_params:
-            # When the first parameter is removed, the indices get updated
-            param_path = "{}/arg[1]".format(self.metadata["augeaspath"])
-            self.parser.aug.remove(param_path)
-        # Insert new ones
-        for pi, param in enumerate(parameters):
-            param_path = "{}/arg[{}]".format(self.metadata["augeaspath"], pi+1)
-            self.parser.aug.set(param_path, param)
-
-    @property
-    def parameters(self):
-        """
-        Fetches the parameters from Augeas tree, ensuring that the sequence always
-        represents the current state
-
-        :returns: Tuple of parameters for this DirectiveNode
-        :rtype: tuple:
-        """
-        return tuple(self._aug_get_params(self.metadata["augeaspath"]))
-
-    def _aug_get_params(self, path):
-        """Helper function to get parameters for DirectiveNodes and BlockNodes"""
-
-        arg_paths = self.parser.aug.match(path + "/arg")
-        return [self.parser.get_arg(apath) for apath in arg_paths]
-
-
-class AugeasBlockNode(AugeasDirectiveNode):
-    """ Augeas implementation of BlockNode interface """
-
-    def __init__(self, **kwargs):
-        super(AugeasBlockNode, self).__init__(**kwargs)
-        self.children = ()
-
-    def __eq__(self, other):
-        if isinstance(other, self.__class__):
-            return (self.name == other.name and
-                    self.filepath == other.filepath and
-                    self.parameters == other.parameters and
-                    self.children == other.children and
-                    self.enabled == other.enabled and
-                    self.dirty == other.dirty and
-                    self.ancestor == other.ancestor and
-                    self.metadata == other.metadata)
-        return False
-
-    # pylint: disable=unused-argument
-    def add_child_block(self, name, parameters=None, position=None):  # pragma: no cover
-        """Adds a new BlockNode to the sequence of children"""
-
-        insertpath, realpath, before = self._aug_resolve_child_position(
-            name,
-            position
-        )
-        new_metadata = {"augeasparser": self.parser, "augeaspath": realpath}
-
-        # Create the new block
-        self.parser.aug.insert(insertpath, name, before)
-        # Check if the file was included from the root config or initial state
-        enabled = self.parser.parsed_in_original(
-            apache_util.get_file_path(realpath)
-        )
-
-        # Parameters will be set at the initialization of the new object
-        new_block = AugeasBlockNode(name=name,
-                                    parameters=parameters,
-                                    enabled=enabled,
-                                    ancestor=assertions.PASS,
-                                    filepath=apache_util.get_file_path(realpath),
-                                    metadata=new_metadata)
-        return new_block
-
-    # pylint: disable=unused-argument
-    def add_child_directive(self, name, parameters=None, position=None):  # pragma: no cover
-        """Adds a new DirectiveNode to the sequence of children"""
-
-        if not parameters:
-            raise errors.PluginError("Directive requires parameters and none were set.")
-
-        insertpath, realpath, before = self._aug_resolve_child_position(
-            "directive",
-            position
-        )
-        new_metadata = {"augeasparser": self.parser, "augeaspath": realpath}
-
-        # Create the new directive
-        self.parser.aug.insert(insertpath, "directive", before)
-        # Set the directive key
-        self.parser.aug.set(realpath, name)
-        # Check if the file was included from the root config or initial state
-        enabled = self.parser.parsed_in_original(
-            apache_util.get_file_path(realpath)
-        )
-
-        new_dir = AugeasDirectiveNode(name=name,
-                                      parameters=parameters,
-                                      enabled=enabled,
-                                      ancestor=assertions.PASS,
-                                      filepath=apache_util.get_file_path(realpath),
-                                      metadata=new_metadata)
-        return new_dir
-
-    def add_child_comment(self, comment="", position=None):
-        """Adds a new CommentNode to the sequence of children"""
-
-        insertpath, realpath, before = self._aug_resolve_child_position(
-            "#comment",
-            position
-        )
-        new_metadata = {"augeasparser": self.parser, "augeaspath": realpath}
-
-        # Create the new comment
-        self.parser.aug.insert(insertpath, "#comment", before)
-        # Set the comment content
-        self.parser.aug.set(realpath, comment)
-
-        new_comment = AugeasCommentNode(comment=comment,
-                                        ancestor=assertions.PASS,
-                                        filepath=apache_util.get_file_path(realpath),
-                                        metadata=new_metadata)
-        return new_comment
-
-    def find_blocks(self, name, exclude=True):
-        """Recursive search of BlockNodes from the sequence of children"""
-
-        nodes = list()
-        paths = self._aug_find_blocks(name)
-        if exclude:
-            paths = self.parser.exclude_dirs(paths)
-        for path in paths:
-            nodes.append(self._create_blocknode(path))
-
-        return nodes
-
-    def find_directives(self, name, exclude=True):
-        """Recursive search of DirectiveNodes from the sequence of children"""
-
-        nodes = list()
-        ownpath = self.metadata.get("augeaspath")
-
-        directives = self.parser.find_dir(name, start=ownpath, exclude=exclude)
-        already_parsed = set()  # type: Set[str]
-        for directive in directives:
-            # Remove the /arg part from the Augeas path
-            directive = directive.partition("/arg")[0]
-            # find_dir returns an object for each _parameter_ of a directive
-            # so we need to filter out duplicates.
-            if directive not in already_parsed:
-                nodes.append(self._create_directivenode(directive))
-                already_parsed.add(directive)
-
-        return nodes
-
-    def find_comments(self, comment):
-        """
-        Recursive search of DirectiveNodes from the sequence of children.
-
-        :param str comment: Comment content to search for.
-        """
-
-        nodes = list()
-        ownpath = self.metadata.get("augeaspath")
-
-        comments = self.parser.find_comments(comment, start=ownpath)
-        for com in comments:
-            nodes.append(self._create_commentnode(com))
-
-        return nodes
-
-    def delete_child(self, child):
-        """
-        Deletes a ParserNode from the sequence of children, and raises an
-        exception if it's unable to do so.
-        :param AugeasParserNode: child: A node to delete.
-        """
-        if not self.parser.aug.remove(child.metadata["augeaspath"]):
-
-            raise errors.PluginError(
-                ("Could not delete child node, the Augeas path: {} doesn't " +
-                 "seem to exist.").format(child.metadata["augeaspath"])
-            )
-
-    def unsaved_files(self):
-        """Returns a list of unsaved filepaths"""
-        return self.parser.unsaved_files()
-
-    def parsed_paths(self):
-        """
-        Returns a list of file paths that have currently been parsed into the parser
-        tree. The returned list may include paths with wildcard characters, for
-        example: ['/etc/apache2/conf.d/*.load']
-
-        This is typically called on the root node of the ParserNode tree.
-
-        :returns: list of file paths of files that have been parsed
-        """
-
-        res_paths = []
-
-        paths = self.parser.existing_paths
-        for directory in paths:
-            for filename in paths[directory]:
-                res_paths.append(os.path.join(directory, filename))
-
-        return res_paths
-
-    def _create_commentnode(self, path):
-        """Helper function to create a CommentNode from Augeas path"""
-
-        comment = self.parser.aug.get(path)
-        metadata = {"augeasparser": self.parser, "augeaspath": path}
-
-        # Because of the dynamic nature of AugeasParser and the fact that we're
-        # not populating the complete node tree, the ancestor has a dummy value
-        return AugeasCommentNode(comment=comment,
-                                 ancestor=assertions.PASS,
-                                 filepath=apache_util.get_file_path(path),
-                                 metadata=metadata)
-
-    def _create_directivenode(self, path):
-        """Helper function to create a DirectiveNode from Augeas path"""
-
-        name = self.parser.get_arg(path)
-        metadata = {"augeasparser": self.parser, "augeaspath": path}
-
-        # Check if the file was included from the root config or initial state
-        enabled = self.parser.parsed_in_original(
-            apache_util.get_file_path(path)
-        )
-        return AugeasDirectiveNode(name=name,
-                                   ancestor=assertions.PASS,
-                                   enabled=enabled,
-                                   filepath=apache_util.get_file_path(path),
-                                   metadata=metadata)
-
-    def _aug_find_blocks(self, name):
-        """Helper function to perform a search to Augeas DOM tree to search
-        configuration blocks with a given name"""
-
-        # The code here is modified from configurator.get_virtual_hosts()
-        blk_paths = set()
-        for vhost_path in list(self.parser.parser_paths):
-            paths = self.parser.aug.match(
-                ("/files%s//*[label()=~regexp('%s')]" %
-                    (vhost_path, parser.case_i(name))))
-            blk_paths.update([path for path in paths if
-                              name.lower() in os.path.basename(path).lower()])
-        return blk_paths
-
-    def _aug_resolve_child_position(self, name, position):
-        """
-        Helper function that iterates through the immediate children and figures
-        out the insertion path for a new AugeasParserNode.
-
-        Augeas also generalizes indices for directives and comments, simply by
-        using "directive" or "comment" respectively as their names.
-
-        This function iterates over the existing children of the AugeasBlockNode,
-        returning their insertion path, resulting Augeas path and if the new node
-        should be inserted before or after the returned insertion path.
-
-        Note: while Apache is case insensitive, Augeas is not, and blocks like
-        Nameofablock and NameOfABlock have different indices.
-
-        :param str name: Name of the AugeasBlockNode to insert, "directive" for
-            AugeasDirectiveNode or "comment" for AugeasCommentNode
-        :param int position: The position to insert the child AugeasParserNode to
-
-        :returns: Tuple of insert path, resulting path and a boolean if the new
-            node should be inserted before it.
-        :rtype: tuple of str, str, bool
-        """
-
-        # Default to appending
-        before = False
-
-        all_children = self.parser.aug.match("{}/*".format(
-            self.metadata["augeaspath"])
-        )
-
-        # Calculate resulting_path
-        # Augeas indices start at 1. We use counter to calculate the index to
-        # be used in resulting_path.
-        counter = 1
-        for i, child in enumerate(all_children):
-            if position is not None and i >= position:
-                # We're not going to insert the new node to an index after this
-                break
-            childname = self._aug_get_name(child)
-            if name == childname:
-                counter += 1
-
-        resulting_path = "{}/{}[{}]".format(
-            self.metadata["augeaspath"],
-            name,
-            counter
-        )
-
-        # Form the correct insert_path
-        # Inserting the only child and appending as the last child work
-        # similarly in Augeas.
-        append = not all_children or position is None or position >= len(all_children)
-        if append:
-            insert_path = "{}/*[last()]".format(
-                self.metadata["augeaspath"]
-            )
-        elif position == 0:
-            # Insert as the first child, before the current first one.
-            insert_path = all_children[0]
-            before = True
-        else:
-            insert_path = "{}/*[{}]".format(
-                self.metadata["augeaspath"],
-                position
-            )
-
-        return (insert_path, resulting_path, before)
-
-
-interfaces.CommentNode.register(AugeasCommentNode)
-interfaces.DirectiveNode.register(AugeasDirectiveNode)
-interfaces.BlockNode.register(AugeasBlockNode)

certbot-apache/certbot_apache/_internal/configurator.py

@@ -12,11 +12,6 @@ import pkg_resources
 import six
 import zope.component
 import zope.interface
-try:
-    import apacheconfig
-    HAS_APACHECONFIG = True
-except ImportError:  # pragma: no cover
-    HAS_APACHECONFIG = False
 
 from acme import challenges
 from acme.magic_typing import DefaultDict  # pylint: disable=unused-import, no-name-in-module
@@ -34,10 +29,8 @@ from certbot.plugins import common
 from certbot.plugins.enhancements import AutoHSTSEnhancement
 from certbot.plugins.util import path_surgery
 from certbot_apache._internal import apache_util
-from certbot_apache._internal import assertions
 from certbot_apache._internal import constants
 from certbot_apache._internal import display_ops
-from certbot_apache._internal import dualparser
 from certbot_apache._internal import http_01
 from certbot_apache._internal import obj
 from certbot_apache._internal import parser
@@ -188,7 +181,6 @@ class ApacheConfigurator(common.Installer):
 
         """
         version = kwargs.pop("version", None)
-        use_parsernode = kwargs.pop("use_parsernode", False)
         super(ApacheConfigurator, self).__init__(*args, **kwargs)
 
         # Add name_server association dict
@@ -204,15 +196,10 @@ class ApacheConfigurator(common.Installer):
         self._autohsts = {}  # type: Dict[str, Dict[str, Union[int, float]]]
         # Reverter save notes
         self.save_notes = ""
-        # Should we use ParserNode implementation instead of the old behavior
-        self.USE_PARSERNODE = use_parsernode
-        # Saves the list of file paths that were parsed initially, and
-        # not added to parser tree by self.conf("vhost-root") for example.
-        self.parsed_paths = []  # type: List[str]
+
         # These will be set in the prepare function
         self._prepared = False
         self.parser = None
-        self.parser_root = None
         self.version = version
         self.vhosts = None
         self.options = copy.deepcopy(self.OS_DEFAULTS)
@@ -262,14 +249,6 @@ class ApacheConfigurator(common.Installer):
         # Perform the actual Augeas initialization to be able to react
         self.parser = self.get_parser()
 
-        # Set up ParserNode root
-        pn_meta = {"augeasparser": self.parser,
-                   "augeaspath": self.parser.get_root_augpath(),
-                   "ac_ast": None}
-        if self.USE_PARSERNODE and HAS_APACHECONFIG:
-            self.parser_root = self.get_parsernode_root(pn_meta)
-            self.parsed_paths = self.parser_root.parsed_paths()
-
         # Check for errors in parsing files with Augeas
         self.parser.check_parsing_errors("httpd.aug")
 
@@ -365,27 +344,6 @@ class ApacheConfigurator(common.Installer):
             self.option("server_root"), self.conf("vhost-root"),
             self.version, configurator=self)
 
-    def get_parsernode_root(self, metadata):
-        """Initializes the ParserNode parser root instance."""
-
-        apache_vars = dict()
-        apache_vars["defines"] = apache_util.parse_defines(self.option("ctl"))
-        apache_vars["includes"] = apache_util.parse_includes(self.option("ctl"))
-        apache_vars["modules"] = apache_util.parse_modules(self.option("ctl"))
-        metadata["apache_vars"] = apache_vars
-
-        with open(self.parser.loc["root"]) as f:
-            with apacheconfig.make_loader(writable=True,
-                  **apacheconfig.flavors.NATIVE_APACHE) as loader:
-                metadata["ac_ast"] = loader.loads(f.read())
-
-        return dualparser.DualBlockNode(
-            name=assertions.PASS,
-            ancestor=None,
-            filepath=self.parser.loc["root"],
-            metadata=metadata
-        )
-
     def _wildcard_domain(self, domain):
         """
         Checks if domain is a wildcard domain
@@ -910,29 +868,6 @@ class ApacheConfigurator(common.Installer):
         return vhost
 
     def get_virtual_hosts(self):
-        """
-        Temporary wrapper for legacy and ParserNode version for
-        get_virtual_hosts. This should be replaced with the ParserNode
-        implementation when ready.
-        """
-
-        v1_vhosts = self.get_virtual_hosts_v1()
-        if self.USE_PARSERNODE and HAS_APACHECONFIG:
-            v2_vhosts = self.get_virtual_hosts_v2()
-
-            for v1_vh in v1_vhosts:
-                found = False
-                for v2_vh in v2_vhosts:
-                    if assertions.isEqualVirtualHost(v1_vh, v2_vh):
-                        found = True
-                        break
-                if not found:
-                    raise AssertionError("Equivalent for {} was not found".format(v1_vh.path))
-
-            return v2_vhosts
-        return v1_vhosts
-
-    def get_virtual_hosts_v1(self):
         """Returns list of virtual hosts found in the Apache configuration.
 
         :returns: List of :class:`~certbot_apache._internal.obj.VirtualHost`
@@ -985,80 +920,6 @@ class ApacheConfigurator(common.Installer):
                     vhs.append(new_vhost)
         return vhs
 
-    def get_virtual_hosts_v2(self):
-        """Returns list of virtual hosts found in the Apache configuration using
-        ParserNode interface.
-        :returns: List of :class:`~certbot_apache.obj.VirtualHost`
-            objects found in configuration
-        :rtype: list
-        """
-
-        vhs = []
-        vhosts = self.parser_root.find_blocks("VirtualHost", exclude=False)
-        for vhblock in vhosts:
-            vhs.append(self._create_vhost_v2(vhblock))
-        return vhs
-
-    def _create_vhost_v2(self, node):
-        """Used by get_virtual_hosts_v2 to create vhost objects using ParserNode
-        interfaces.
-        :param interfaces.BlockNode node: The BlockNode object of VirtualHost block
-        :returns: newly created vhost
-        :rtype: :class:`~certbot_apache.obj.VirtualHost`
-        """
-        addrs = set()
-        for param in node.parameters:
-            addrs.add(obj.Addr.fromstring(param))
-
-        is_ssl = False
-        # Exclusion to match the behavior in get_virtual_hosts_v2
-        sslengine = node.find_directives("SSLEngine", exclude=False)
-        if sslengine:
-            for directive in sslengine:
-                if directive.parameters[0].lower() == "on":
-                    is_ssl = True
-                    break
-
-        # "SSLEngine on" might be set outside of <VirtualHost>
-        # Treat vhosts with port 443 as ssl vhosts
-        for addr in addrs:
-            if addr.get_port() == "443":
-                is_ssl = True
-
-        enabled = apache_util.included_in_paths(node.filepath, self.parsed_paths)
-
-        macro = False
-        # Check if the VirtualHost is contained in a mod_macro block
-        if node.find_ancestors("Macro"):
-            macro = True
-        vhost = obj.VirtualHost(
-            node.filepath, None, addrs, is_ssl, enabled, modmacro=macro, node=node
-        )
-        self._populate_vhost_names_v2(vhost)
-        return vhost
-
-    def _populate_vhost_names_v2(self, vhost):
-        """Helper function that populates the VirtualHost names.
-        :param host: In progress vhost whose names will be added
-        :type host: :class:`~certbot_apache.obj.VirtualHost`
-        """
-
-        servername_match = vhost.node.find_directives("ServerName",
-                                                      exclude=False)
-        serveralias_match = vhost.node.find_directives("ServerAlias",
-                                                       exclude=False)
-
-        servername = None
-        if servername_match:
-            servername = servername_match[-1].parameters[-1]
-
-        if not vhost.modmacro:
-            for alias in serveralias_match:
-                for serveralias in alias.parameters:
-                    vhost.aliases.add(serveralias)
-            vhost.name = servername
-
-
     def is_name_vhost(self, target_addr):
         """Returns if vhost is a name based vhost
 
@@ -1956,7 +1817,7 @@ class ApacheConfigurator(common.Installer):
                     ssl_vhost.filep)
 
     def _verify_no_matching_http_header(self, ssl_vhost, header_substring):
-        """Checks to see if an there is an existing Header directive that
+        """Checks to see if there is an existing Header directive that
         contains the string header_substring.
 
         :param ssl_vhost: vhost to check

certbot-apache/certbot_apache/_internal/dualparser.py

@@ -1,306 +0,0 @@
-""" Dual ParserNode implementation """
-from certbot_apache._internal import assertions
-from certbot_apache._internal import augeasparser
-from certbot_apache._internal import apacheparser
-
-
-class DualNodeBase(object):
-    """ Dual parser interface for in development testing. This is used as the
-    base class for dual parser interface classes. This class handles runtime
-    attribute value assertions."""
-
-    def save(self, msg):  # pragma: no cover
-        """ Call save for both parsers """
-        self.primary.save(msg)
-        self.secondary.save(msg)
-
-    def __getattr__(self, aname):
-        """ Attribute value assertion """
-        firstval = getattr(self.primary, aname)
-        secondval = getattr(self.secondary, aname)
-        exclusions = [
-            # Metadata will inherently be different, as ApacheParserNode does
-            # not have Augeas paths and so on.
-            aname == "metadata",
-            callable(firstval)
-        ]
-        if not any(exclusions):
-            assertions.assertEqualSimple(firstval, secondval)
-        return firstval
-
-    def find_ancestors(self, name):
-        """ Traverses the ancestor tree and returns ancestors matching name """
-        return self._find_helper(DualBlockNode, "find_ancestors", name)
-
-    def _find_helper(self, nodeclass, findfunc, search, **kwargs):
-        """A helper for find_* functions. The function specific attributes should
-        be passed as keyword arguments.
-
-        :param interfaces.ParserNode nodeclass: The node class for results.
-        :param str findfunc: Name of the find function to call
-        :param str search: The search term
-        """
-
-        primary_res = getattr(self.primary, findfunc)(search, **kwargs)
-        secondary_res = getattr(self.secondary, findfunc)(search, **kwargs)
-
-        # The order of search results for Augeas implementation cannot be
-        # assured.
-
-        pass_primary = assertions.isPassNodeList(primary_res)
-        pass_secondary = assertions.isPassNodeList(secondary_res)
-        new_nodes = list()
-
-        if pass_primary and pass_secondary:
-            # Both unimplemented
-            new_nodes.append(nodeclass(primary=primary_res[0],
-                                       secondary=secondary_res[0]))  # pragma: no cover
-        elif pass_primary:
-            for c in secondary_res:
-                new_nodes.append(nodeclass(primary=primary_res[0],
-                                           secondary=c))
-        elif pass_secondary:
-            for c in primary_res:
-                new_nodes.append(nodeclass(primary=c,
-                                           secondary=secondary_res[0]))
-        else:
-            assert len(primary_res) == len(secondary_res)
-            matches = self._create_matching_list(primary_res, secondary_res)
-            for p, s in matches:
-                new_nodes.append(nodeclass(primary=p, secondary=s))
-
-        return new_nodes
-
-
-class DualCommentNode(DualNodeBase):
-    """ Dual parser implementation of CommentNode interface """
-
-    def __init__(self, **kwargs):
-        """ This initialization implementation allows ordinary initialization
-        of CommentNode objects as well as creating a DualCommentNode object
-        using precreated or fetched CommentNode objects if provided as optional
-        arguments primary and secondary.
-
-        Parameters other than the following are from interfaces.CommentNode:
-
-        :param CommentNode primary: Primary pre-created CommentNode, mainly
-            used when creating new DualParser nodes using add_* methods.
-        :param CommentNode secondary: Secondary pre-created CommentNode
-        """
-
-        kwargs.setdefault("primary", None)
-        kwargs.setdefault("secondary", None)
-        primary = kwargs.pop("primary")
-        secondary = kwargs.pop("secondary")
-
-        if primary or secondary:
-            assert primary and secondary
-            self.primary = primary
-            self.secondary = secondary
-        else:
-            self.primary = augeasparser.AugeasCommentNode(**kwargs)
-            self.secondary = apacheparser.ApacheCommentNode(**kwargs)
-
-        assertions.assertEqual(self.primary, self.secondary)
-
-
-class DualDirectiveNode(DualNodeBase):
-    """ Dual parser implementation of DirectiveNode interface """
-
-    def __init__(self, **kwargs):
-        """ This initialization implementation allows ordinary initialization
-        of DirectiveNode objects as well as creating a DualDirectiveNode object
-        using precreated or fetched DirectiveNode objects if provided as optional
-        arguments primary and secondary.
-
-        Parameters other than the following are from interfaces.DirectiveNode:
-
-        :param DirectiveNode primary: Primary pre-created DirectiveNode, mainly
-            used when creating new DualParser nodes using add_* methods.
-        :param DirectiveNode secondary: Secondary pre-created DirectiveNode
-
-
-        """
-
-        kwargs.setdefault("primary", None)
-        kwargs.setdefault("secondary", None)
-        primary = kwargs.pop("primary")
-        secondary = kwargs.pop("secondary")
-
-        if primary or secondary:
-            assert primary and secondary
-            self.primary = primary
-            self.secondary = secondary
-        else:
-            self.primary = augeasparser.AugeasDirectiveNode(**kwargs)
-            self.secondary = apacheparser.ApacheDirectiveNode(**kwargs)
-
-        assertions.assertEqual(self.primary, self.secondary)
-
-    def set_parameters(self, parameters):
-        """ Sets parameters and asserts that both implementation successfully
-        set the parameter sequence """
-
-        self.primary.set_parameters(parameters)
-        self.secondary.set_parameters(parameters)
-        assertions.assertEqual(self.primary, self.secondary)
-
-
-class DualBlockNode(DualNodeBase):
-    """ Dual parser implementation of BlockNode interface """
-
-    def __init__(self, **kwargs):
-        """ This initialization implementation allows ordinary initialization
-        of BlockNode objects as well as creating a DualBlockNode object
-        using precreated or fetched BlockNode objects if provided as optional
-        arguments primary and secondary.
-
-        Parameters other than the following are from interfaces.BlockNode:
-
-        :param BlockNode primary: Primary pre-created BlockNode, mainly
-            used when creating new DualParser nodes using add_* methods.
-        :param BlockNode secondary: Secondary pre-created BlockNode
-        """
-
-        kwargs.setdefault("primary", None)
-        kwargs.setdefault("secondary", None)
-        primary = kwargs.pop("primary")
-        secondary = kwargs.pop("secondary")
-
-        if primary or secondary:
-            assert primary and secondary
-            self.primary = primary
-            self.secondary = secondary
-        else:
-            self.primary = augeasparser.AugeasBlockNode(**kwargs)
-            self.secondary = apacheparser.ApacheBlockNode(**kwargs)
-
-        assertions.assertEqual(self.primary, self.secondary)
-
-    def add_child_block(self, name, parameters=None, position=None):
-        """ Creates a new child BlockNode, asserts that both implementations
-        did it in a similar way, and returns a newly created DualBlockNode object
-        encapsulating both of the newly created objects """
-
-        primary_new = self.primary.add_child_block(name, parameters, position)
-        secondary_new = self.secondary.add_child_block(name, parameters, position)
-        assertions.assertEqual(primary_new, secondary_new)
-        new_block = DualBlockNode(primary=primary_new, secondary=secondary_new)
-        return new_block
-
-    def add_child_directive(self, name, parameters=None, position=None):
-        """ Creates a new child DirectiveNode, asserts that both implementations
-        did it in a similar way, and returns a newly created DualDirectiveNode
-        object encapsulating both of the newly created objects """
-
-        primary_new = self.primary.add_child_directive(name, parameters, position)
-        secondary_new = self.secondary.add_child_directive(name, parameters, position)
-        assertions.assertEqual(primary_new, secondary_new)
-        new_dir = DualDirectiveNode(primary=primary_new, secondary=secondary_new)
-        return new_dir
-
-    def add_child_comment(self, comment="", position=None):
-        """ Creates a new child CommentNode, asserts that both implementations
-        did it in a similar way, and returns a newly created DualCommentNode
-        object encapsulating both of the newly created objects """
-
-        primary_new = self.primary.add_child_comment(comment, position)
-        secondary_new = self.secondary.add_child_comment(comment, position)
-        assertions.assertEqual(primary_new, secondary_new)
-        new_comment = DualCommentNode(primary=primary_new, secondary=secondary_new)
-        return new_comment
-
-    def _create_matching_list(self, primary_list, secondary_list):
-        """ Matches the list of primary_list to a list of secondary_list and
-        returns a list of tuples. This is used to create results for find_
-        methods.
-
-        This helper function exists, because we cannot ensure that the list of
-        search results returned by primary.find_* and secondary.find_* are ordered
-        in a same way. The function pairs the same search results from both
-        implementations to a list of tuples.
-        """
-
-        matched = list()
-        for p in primary_list:
-            match = None
-            for s in secondary_list:
-                try:
-                    assertions.assertEqual(p, s)
-                    match = s
-                    break
-                except AssertionError:
-                    continue
-            if match:
-                matched.append((p, match))
-            else:
-                raise AssertionError("Could not find a matching node.")
-        return matched
-
-    def find_blocks(self, name, exclude=True):
-        """
-        Performs a search for BlockNodes using both implementations and does simple
-        checks for results. This is built upon the assumption that unimplemented
-        find_* methods return a list with a single assertion passing object.
-        After the assertion, it creates a list of newly created DualBlockNode
-        instances that encapsulate the pairs of returned BlockNode objects.
-        """
-
-        return self._find_helper(DualBlockNode, "find_blocks", name,
-                                 exclude=exclude)
-
-    def find_directives(self, name, exclude=True):
-        """
-        Performs a search for DirectiveNodes using both implementations and
-        checks the results. This is built upon the assumption that unimplemented
-        find_* methods return a list with a single assertion passing object.
-        After the assertion, it creates a list of newly created DualDirectiveNode
-        instances that encapsulate the pairs of returned DirectiveNode objects.
-        """
-
-        return self._find_helper(DualDirectiveNode, "find_directives", name,
-                                 exclude=exclude)
-
-    def find_comments(self, comment):
-        """
-        Performs a search for CommentNodes using both implementations and
-        checks the results. This is built upon the assumption that unimplemented
-        find_* methods return a list with a single assertion passing object.
-        After the assertion, it creates a list of newly created DualCommentNode
-        instances that encapsulate the pairs of returned CommentNode objects.
-        """
-
-        return self._find_helper(DualCommentNode, "find_comments", comment)
-
-    def delete_child(self, child):
-        """Deletes a child from the ParserNode implementations. The actual
-        ParserNode implementations are used here directly in order to be able
-        to match a child to the list of children."""
-
-        self.primary.delete_child(child.primary)
-        self.secondary.delete_child(child.secondary)
-
-    def unsaved_files(self):
-        """ Fetches the list of unsaved file paths and asserts that the lists
-        match """
-        primary_files = self.primary.unsaved_files()
-        secondary_files = self.secondary.unsaved_files()
-        assertions.assertEqualSimple(primary_files, secondary_files)
-
-        return primary_files
-
-    def parsed_paths(self):
-        """
-        Returns a list of file paths that have currently been parsed into the parser
-        tree. The returned list may include paths with wildcard characters, for
-        example: ['/etc/apache2/conf.d/*.load']
-
-        This is typically called on the root node of the ParserNode tree.
-
-        :returns: list of file paths of files that have been parsed
-        """
-
-        primary_paths = self.primary.parsed_paths()
-        secondary_paths = self.secondary.parsed_paths()
-        assertions.assertEqualPathsList(primary_paths, secondary_paths)
-        return primary_paths

certbot-apache/certbot_apache/_internal/interfaces.py

@@ -1,516 +0,0 @@
-"""ParserNode interface for interacting with configuration tree.
-
-General description
--------------------
-
-The ParserNode interfaces are designed to be able to contain all the parsing logic,
-while allowing their users to interact with the configuration tree in a Pythonic
-and well structured manner.
-
-The structure allows easy traversal of the tree of ParserNodes. Each ParserNode
-stores a reference to its ancestor and immediate children, allowing the user to
-traverse the tree using built in interface methods as well as accessing the interface
-properties directly.
-
-ParserNode interface implementation should stand between the actual underlying
-parser functionality and the business logic within Configurator code, interfacing
-with both. The ParserNode tree is a result of configuration parsing action.
-
-ParserNode tree will be in charge of maintaining the parser state and hence the
-abstract syntax tree (AST). Interactions between ParserNode tree and underlying
-parser should involve only parsing the configuration files to this structure, and
-writing it back to the filesystem - while preserving the format including whitespaces.
-
-For some implementations (Apache for example) it's important to keep track of and
-to use state information while parsing conditional blocks and directives. This
-allows the implementation to set a flag to parts of the parsed configuration
-structure as not being in effect in a case of unmatched conditional block. It's
-important to store these blocks in the tree as well in order to not to conduct
-destructive actions (failing to write back parts of the configuration) while writing
-the AST back to the filesystem.
-
-The ParserNode tree is in charge of maintaining the its own structure while every
-child node fetched with find - methods or by iterating its list of children can be
-changed in place. When making changes the affected nodes should be flagged as "dirty"
-in order for the parser implementation to figure out the parts of the configuration
-that need to be written back to disk during the save() operation.
-
-
-Metadata
---------
-
-The metadata holds all the implementation specific attributes of the ParserNodes -
-things like the positional information related to the AST, file paths, whitespacing,
-and any other information relevant to the underlying parser engine.
-
-Access to the metadata should be handled by implementation specific methods, allowing
-the Configurator functionality to access the underlying information where needed.
-
-For some implementations the node can be initialized using the information carried
-in metadata alone. This is useful especially when populating the ParserNode tree
-while parsing the configuration.
-
-
-Apache implementation
----------------------
-
-The Apache implementation of ParserNode interface requires some implementation
-specific functionalities that are not described by the interface itself.
-
-Initialization
-
-When the user of a ParserNode class is creating these objects, they must specify
-the parameters as described in the documentation for the __init__ methods below.
-When these objects are created internally, however, some parameters may not be
-needed because (possibly more detailed) information is included in the metadata
-parameter. In this case, implementations can deviate from the required parameters
-from __init__, however, they should still behave the same when metadata is not
-provided.
-
-For consistency internally, if an argument is provided directly in the ParserNode
-initialization parameters as well as within metadata it's recommended to establish
-clear behavior around this scenario within the implementation.
-
-Conditional blocks
-
-Apache configuration can have conditional blocks, for example: <IfModule ...>,
-resulting the directives and subblocks within it being either enabled or disabled.
-While find_* interface methods allow including the disabled parts of the configuration
-tree in searches a special care needs to be taken while parsing the structure in
-order to reflect the active state of configuration.
-
-Whitespaces
-
-Each ParserNode object is responsible of storing its prepending whitespace characters
-in order to be able to write the AST back to filesystem like it was, preserving the
-format, this applies for parameters of BlockNode and DirectiveNode as well.
-When parameters of ParserNode are changed, the pre-existing whitespaces in the
-parameter sequence are discarded, as the general reason for storing them is to
-maintain the ability to write the configuration back to filesystem exactly like
-it was. This loses its meaning when we have to change the directives or blocks
-parameters for other reasons.
-
-Searches and matching
-
-Apache configuration is largely case insensitive, so the Apache implementation of
-ParserNode interface needs to provide the user means to match block and directive
-names and parameters in case insensitive manner. This does not apply to everything
-however, for example the parameters of a conditional statement may be case sensitive.
-For this reason the internal representation of data should not ignore the case.
-"""
-
-import abc
-import six
-
-from acme.magic_typing import Any, Dict, Optional, Tuple  # pylint: disable=unused-import, no-name-in-module
-
-
-@six.add_metaclass(abc.ABCMeta)
-class ParserNode(object):
-    """
-    ParserNode is the basic building block of the tree of such nodes,
-    representing the structure of the configuration. It is largely meant to keep
-    the structure information intact and idiomatically accessible.
-
-    The root node as well as the child nodes of it should be instances of ParserNode.
-    Nodes keep track of their differences to on-disk representation of configuration
-    by marking modified ParserNodes as dirty to enable partial write-to-disk for
-    different files in the configuration structure.
-
-    While for the most parts the usage and the child types are obvious, "include"-
-    and similar directives are an exception to this rule. This is because of the
-    nature of include directives - which unroll the contents of another file or
-    configuration block to their place. While we could unroll the included nodes
-    to the parent tree, it remains important to keep the context of include nodes
-    separate in order to write back the original configuration as it was.
-
-    For parsers that require the implementation to keep track of the whitespacing,
-    it's responsibility of each ParserNode object itself to store its prepending
-    whitespaces in order to be able to reconstruct the complete configuration file
-    as it was when originally read from the disk.
-
-    ParserNode objects should have the following attributes:
-
-    # Reference to ancestor node, or None if the node is the root node of the
-    # configuration tree.
-    ancestor: Optional[ParserNode]
-
-    # True if this node has been modified since last save.
-    dirty: bool
-
-    # Filepath of the file where the configuration element for this ParserNode
-    # object resides. For root node, the value for filepath is the httpd root
-    # configuration file. Filepath can be None if a configuration directive is
-    # defined in for example the httpd command line.
-    filepath: Optional[str]
-
-    # Metadata dictionary holds all the implementation specific key-value pairs
-    # for the ParserNode instance.
-    metadata: Dict[str, Any]
-    """
-
-    @abc.abstractmethod
-    def __init__(self, **kwargs):
-        """
-        Initializes the ParserNode instance, and sets the ParserNode specific
-        instance variables. This is not meant to be used directly, but through
-        specific classes implementing ParserNode interface.
-
-        :param ancestor: BlockNode ancestor for this CommentNode. Required.
-        :type ancestor: BlockNode or None
-
-        :param filepath: Filesystem path for the file where this CommentNode
-            does or should exist in the filesystem. Required.
-        :type filepath: str or None
-
-        :param dirty: Boolean flag for denoting if this CommentNode has been
-            created or changed after the last save. Default: False.
-        :type dirty: bool
-
-        :param metadata: Dictionary of metadata values for this ParserNode object.
-            Metadata information should be used only internally in the implementation.
-            Default: {}
-        :type metadata: dict
-        """
-
-    @abc.abstractmethod
-    def save(self, msg):
-        """
-        Save traverses the children, and attempts to write the AST to disk for
-        all the objects that are marked dirty. The actual operation of course
-        depends on the underlying implementation. save() shouldn't be called
-        from the Configurator outside of its designated save() method in order
-        to ensure that the Reverter checkpoints are created properly.
-
-        Note: this approach of keeping internal structure of the configuration
-        within the ParserNode tree does not represent the file inclusion structure
-        of actual configuration files that reside in the filesystem. To handle
-        file writes properly, the file specific temporary trees should be extracted
-        from the full ParserNode tree where necessary when writing to disk.
-
-        :param str msg: Message describing the reason for the save.
-
-        """
-
-    @abc.abstractmethod
-    def find_ancestors(self, name):
-        """
-        Traverses the ancestor tree up, searching for BlockNodes with a specific
-        name.
-
-        :param str name: Name of the ancestor BlockNode to search for
-
-        :returns: A list of ancestor BlockNodes that match the name
-        :rtype: list of BlockNode
-        """
-
-
-# Linter rule exclusion done because of https://github.com/PyCQA/pylint/issues/179
-@six.add_metaclass(abc.ABCMeta)  # pylint: disable=abstract-method
-class CommentNode(ParserNode):
-    """
-    CommentNode class is used for representation of comments within the parsed
-    configuration structure. Because of the nature of comments, it is not able
-    to have child nodes and hence it is always treated as a leaf node.
-
-    CommentNode stores its contents in class variable 'comment' and does not
-    have a specific name.
-
-    CommentNode objects should have the following attributes in addition to
-    the ones described in ParserNode:
-
-    # Contains the contents of the comment without the directive notation
-    # (typically # or /* ... */).
-    comment: str
-
-    """
-
-    @abc.abstractmethod
-    def __init__(self, **kwargs):
-        """
-        Initializes the CommentNode instance and sets its instance variables.
-
-        :param comment: Contents of the comment. Required.
-        :type comment: str
-
-        :param ancestor: BlockNode ancestor for this CommentNode. Required.
-        :type ancestor: BlockNode or None
-
-        :param filepath: Filesystem path for the file where this CommentNode
-            does or should exist in the filesystem. Required.
-        :type filepath: str or None
-
-        :param dirty: Boolean flag for denoting if this CommentNode has been
-            created or changed after the last save. Default: False.
-        :type dirty: bool
-        """
-        super(CommentNode, self).__init__(ancestor=kwargs['ancestor'],
-                                          dirty=kwargs.get('dirty', False),
-                                          filepath=kwargs['filepath'],
-                                          metadata=kwargs.get('metadata', {}))  # pragma: no cover
-
-
-@six.add_metaclass(abc.ABCMeta)
-class DirectiveNode(ParserNode):
-    """
-    DirectiveNode class represents a configuration directive within the configuration.
-    It can have zero or more parameters attached to it. Because of the nature of
-    single directives, it is not able to have child nodes and hence it is always
-    treated as a leaf node.
-
-    If a this directive was defined on the httpd command line, the ancestor instance
-    variable for this DirectiveNode should be None, and it should be inserted to the
-    beginning of root BlockNode children sequence.
-
-    DirectiveNode objects should have the following attributes in addition to
-    the ones described in ParserNode:
-
-    # True if this DirectiveNode is enabled and False if it is inside of an
-    # inactive conditional block.
-    enabled: bool
-
-    # Name, or key of the configuration directive. If BlockNode subclass of
-    # DirectiveNode is the root configuration node, the name should be None.
-    name: Optional[str]
-
-    # Tuple of parameters of this ParserNode object, excluding whitespaces.
-    parameters: Tuple[str, ...]
-
-    """
-
-    @abc.abstractmethod
-    def __init__(self, **kwargs):
-        """
-        Initializes the DirectiveNode instance and sets its instance variables.
-
-        :param name: Name or key of the DirectiveNode object. Required.
-        :type name: str or None
-
-        :param tuple parameters: Tuple of str parameters for this DirectiveNode.
-            Default: ().
-        :type parameters: tuple
-
-        :param ancestor: BlockNode ancestor for this DirectiveNode, or None for
-            root configuration node. Required.
-        :type ancestor: BlockNode or None
-
-        :param filepath: Filesystem path for the file where this DirectiveNode
-            does or should exist in the filesystem, or None for directives introduced
-            in the httpd command line. Required.
-        :type filepath: str or None
-
-        :param dirty: Boolean flag for denoting if this DirectiveNode has been
-            created or changed after the last save. Default: False.
-        :type dirty: bool
-
-        :param enabled: True if this DirectiveNode object is parsed in the active
-            configuration of the httpd. False if the DirectiveNode exists within a
-            unmatched conditional configuration block. Default: True.
-        :type enabled: bool
-
-        """
-        super(DirectiveNode, self).__init__(ancestor=kwargs['ancestor'],
-                                            dirty=kwargs.get('dirty', False),
-                                            filepath=kwargs['filepath'],
-                                            metadata=kwargs.get('metadata', {}))  # pragma: no cover
-
-    @abc.abstractmethod
-    def set_parameters(self, parameters):
-        """
-        Sets the sequence of parameters for this ParserNode object without
-        whitespaces. While the whitespaces for parameters are discarded when using
-        this method, the whitespacing preceeding the ParserNode itself should be
-        kept intact.
-
-        :param list parameters: sequence of parameters
-        """
-
-
-@six.add_metaclass(abc.ABCMeta)
-class BlockNode(DirectiveNode):
-    """
-    BlockNode class represents a block of nested configuration directives, comments
-    and other blocks as its children. A BlockNode can have zero or more parameters
-    attached to it.
-
-    Configuration blocks typically consist of one or more child nodes of all possible
-    types. Because of this, the BlockNode class has various discovery and structure
-    management methods.
-
-    Lists of parameters used as an optional argument for some of the methods should
-    be lists of strings that are applicable parameters for each specific BlockNode
-    or DirectiveNode type. As an example, for a following configuration example:
-
-        <VirtualHost *:80>
-           ...
-        </VirtualHost>
-
-    The node type would be BlockNode, name would be 'VirtualHost' and its parameters
-    would be: ['*:80'].
-
-    While for the following example:
-
-        LoadModule alias_module /usr/lib/apache2/modules/mod_alias.so
-
-    The node type would be DirectiveNode, name would be 'LoadModule' and its
-    parameters would be: ['alias_module', '/usr/lib/apache2/modules/mod_alias.so']
-
-    The applicable parameters are dependent on the underlying configuration language
-    and its grammar.
-
-    BlockNode objects should have the following attributes in addition to
-    the ones described in DirectiveNode:
-
-    # Tuple of direct children of this BlockNode object. The order of children
-    # in this tuple retain the order of elements in the parsed configuration
-    # block.
-    children: Tuple[ParserNode, ...]
-
-    """
-
-    @abc.abstractmethod
-    def add_child_block(self, name, parameters=None, position=None):
-        """
-        Adds a new BlockNode child node with provided values and marks the callee
-        BlockNode dirty. This is used to add new children to the AST. The preceeding
-        whitespaces should not be added based on the ancestor or siblings for the
-        newly created object. This is to match the current behavior of the legacy
-        parser implementation.
-
-        :param str name: The name of the child node to add
-        :param list parameters: list of parameters for the node
-        :param int position: Position in the list of children to add the new child
-            node to. Defaults to None, which appends the newly created node to the list.
-            If an integer is given, the child is inserted before that index in the
-            list similar to list().insert.
-
-        :returns: BlockNode instance of the created child block
-
-        """
-
-    @abc.abstractmethod
-    def add_child_directive(self, name, parameters=None, position=None):
-        """
-        Adds a new DirectiveNode child node with provided values and marks the
-        callee BlockNode dirty. This is used to add new children to the AST. The
-        preceeding whitespaces should not be added based on the ancestor or siblings
-        for the newly created object. This is to match the current behavior of the
-        legacy parser implementation.
-
-
-        :param str name: The name of the child node to add
-        :param list parameters: list of parameters for the node
-        :param int position: Position in the list of children to add the new child
-            node to. Defaults to None, which appends the newly created node to the list.
-            If an integer is given, the child is inserted before that index in the
-            list similar to list().insert.
-
-        :returns: DirectiveNode instance of the created child directive
-
-        """
-
-    @abc.abstractmethod
-    def add_child_comment(self, comment="", position=None):
-        """
-        Adds a new CommentNode child node with provided value and marks the
-        callee BlockNode dirty. This is used to add new children to the AST. The
-        preceeding whitespaces should not be added based on the ancestor or siblings
-        for the newly created object. This is to match the current behavior of the
-        legacy parser implementation.
-
-
-        :param str comment: Comment contents
-        :param int position: Position in the list of children to add the new child
-            node to. Defaults to None, which appends the newly created node to the list.
-            If an integer is given, the child is inserted before that index in the
-            list similar to list().insert.
-
-        :returns: CommentNode instance of the created child comment
-
-        """
-
-    @abc.abstractmethod
-    def find_blocks(self, name, exclude=True):
-        """
-        Find a configuration block by name. This method walks the child tree of
-        ParserNodes under the instance it was called from. This way it is possible
-        to search for the whole configuration tree, when starting from root node or
-        to do a partial search when starting from a specified branch. The lookup
-        should be case insensitive.
-
-        :param str name: The name of the directive to search for
-        :param bool exclude: If the search results should exclude the contents of
-            ParserNode objects that reside within conditional blocks and because
-            of current state are not enabled.
-
-        :returns: A list of found BlockNode objects.
-        """
-
-    @abc.abstractmethod
-    def find_directives(self, name, exclude=True):
-        """
-        Find a directive by name. This method walks the child tree of ParserNodes
-        under the instance it was called from. This way it is possible to search
-        for the whole configuration tree, when starting from root node, or to do
-        a partial search when starting from a specified branch. The lookup should
-        be case insensitive.
-
-        :param str name: The name of the directive to search for
-        :param bool exclude: If the search results should exclude the contents of
-            ParserNode objects that reside within conditional blocks and because
-            of current state are not enabled.
-
-        :returns: A list of found DirectiveNode objects.
-
-        """
-
-    @abc.abstractmethod
-    def find_comments(self, comment):
-        """
-        Find comments with value containing the search term.
-
-        This method walks the child tree of ParserNodes under the instance it was
-        called from. This way it is possible to search for the whole configuration
-        tree, when starting from root node, or to do a partial search when starting
-        from a specified branch. The lookup should be case sensitive.
-
-        :param str comment: The content of comment to search for
-
-        :returns: A list of found CommentNode objects.
-
-        """
-
-    @abc.abstractmethod
-    def delete_child(self, child):
-        """
-        Remove a specified child node from the list of children of the called
-        BlockNode object.
-
-        :param ParserNode child: Child ParserNode object to remove from the list
-            of children of the callee.
-        """
-
-    @abc.abstractmethod
-    def unsaved_files(self):
-        """
-        Returns a list of file paths that have been changed since the last save
-        (or the initial configuration parse). The intended use for this method
-        is to tell the Reverter which files need to be included in a checkpoint.
-
-        This is typically called for the root of the ParserNode tree.
-
-        :returns: list of file paths of files that have been changed but not yet
-            saved to disk.
-        """
-
-    @abc.abstractmethod
-    def parsed_paths(self):
-        """
-        Returns a list of file paths that have currently been parsed into the parser
-        tree. The returned list may include paths with wildcard characters, for
-        example: ['/etc/apache2/conf.d/*.load']
-
-        This is typically called on the root node of the ParserNode tree.
-
-        :returns: list of file paths of files that have been parsed
-        """

certbot-apache/certbot_apache/_internal/obj.py

@@ -124,7 +124,7 @@ class VirtualHost(object):
     strip_name = re.compile(r"^(?:.+://)?([^ :$]*)")
 
     def __init__(self, filep, path, addrs, ssl, enabled, name=None,
-                 aliases=None, modmacro=False, ancestor=None, node=None):
+                 aliases=None, modmacro=False, ancestor=None):
 
         """Initialize a VH."""
         self.filep = filep
@@ -136,7 +136,6 @@ class VirtualHost(object):
         self.enabled = enabled
         self.modmacro = modmacro
         self.ancestor = ancestor
-        self.node = node
 
     def get_names(self):
         """Return a set of all names."""

certbot-apache/certbot_apache/_internal/override_gentoo.py

@@ -70,6 +70,6 @@ class GentooParser(parser.ApacheParser):
     def update_modules(self):
         """Get loaded modules from httpd process, and add them to DOM"""
         mod_cmd = [self.configurator.option("ctl"), "modules"]
-        matches = apache_util.parse_from_subprocess(mod_cmd, r"(.*)_module")
+        matches = self.parse_from_subprocess(mod_cmd, r"(.*)_module")
         for mod in matches:
             self.add_mod(mod.strip())

certbot-apache/certbot_apache/_internal/parser.py

@@ -3,6 +3,7 @@ import copy
 import fnmatch
 import logging
 import re
+import subprocess
 import sys
 
 import six
@@ -12,7 +13,6 @@ from acme.magic_typing import List  # pylint: disable=unused-import, no-name-in-
 from acme.magic_typing import Set  # pylint: disable=unused-import, no-name-in-module
 from certbot import errors
 from certbot.compat import os
-from certbot_apache._internal import apache_util
 from certbot_apache._internal import constants
 
 logger = logging.getLogger(__name__)
@@ -290,15 +290,32 @@ class ApacheParser(object):
 
     def update_runtime_variables(self):
         """Update Includes, Defines and Includes from httpd config dump data"""
-
         self.update_defines()
         self.update_includes()
         self.update_modules()
 
     def update_defines(self):
-        """Updates the dictionary of known variables in the configuration"""
+        """Get Defines from httpd process"""
 
-        self.variables = apache_util.parse_defines(self.configurator.option("ctl"))
+        variables = dict()
+        define_cmd = [self.configurator.option("ctl"), "-t", "-D",
+                      "DUMP_RUN_CFG"]
+        matches = self.parse_from_subprocess(define_cmd, r"Define: ([^ \n]*)")
+        try:
+            matches.remove("DUMP_RUN_CFG")
+        except ValueError:
+            return
+
+        for match in matches:
+            if match.count("=") > 1:
+                logger.error("Unexpected number of equal signs in "
+                             "runtime config dump.")
+                raise errors.PluginError(
+                    "Error parsing Apache runtime variables")
+            parts = match.partition("=")
+            variables[parts[0]] = parts[2]
+
+        self.variables = variables
 
     def update_includes(self):
         """Get includes from httpd process, and add them to DOM if needed"""
@@ -308,7 +325,9 @@ class ApacheParser(object):
         # configuration files
         _ = self.find_dir("Include")
 
-        matches = apache_util.parse_includes(self.configurator.option("ctl"))
+        inc_cmd = [self.configurator.option("ctl"), "-t", "-D",
+                   "DUMP_INCLUDES"]
+        matches = self.parse_from_subprocess(inc_cmd, r"\(.*\) (.*)")
         if matches:
             for i in matches:
                 if not self.parsed_in_current(i):
@@ -317,10 +336,56 @@ class ApacheParser(object):
     def update_modules(self):
         """Get loaded modules from httpd process, and add them to DOM"""
 
-        matches = apache_util.parse_modules(self.configurator.option("ctl"))
+        mod_cmd = [self.configurator.option("ctl"), "-t", "-D",
+                       "DUMP_MODULES"]
+        matches = self.parse_from_subprocess(mod_cmd, r"(.*)_module")
         for mod in matches:
             self.add_mod(mod.strip())
 
+    def parse_from_subprocess(self, command, regexp):
+        """Get values from stdout of subprocess command
+
+        :param list command: Command to run
+        :param str regexp: Regexp for parsing
+
+        :returns: list parsed from command output
+        :rtype: list
+
+        """
+        stdout = self._get_runtime_cfg(command)
+        return re.compile(regexp).findall(stdout)
+
+    def _get_runtime_cfg(self, command):  # pylint: disable=no-self-use
+        """Get runtime configuration info.
+        :param command: Command to run
+
+        :returns: stdout from command
+
+        """
+        try:
+            proc = subprocess.Popen(
+                command,
+                stdout=subprocess.PIPE,
+                stderr=subprocess.PIPE,
+                universal_newlines=True)
+            stdout, stderr = proc.communicate()
+
+        except (OSError, ValueError):
+            logger.error(
+                "Error running command %s for runtime parameters!%s",
+                command, os.linesep)
+            raise errors.MisconfigurationError(
+                "Error accessing loaded Apache parameters: {0}".format(
+                command))
+        # Small errors that do not impede
+        if proc.returncode != 0:
+            logger.warning("Error in checking parameter list: %s", stderr)
+            raise errors.MisconfigurationError(
+                "Apache is unable to check whether or not the module is "
+                "loaded because Apache is misconfigured.")
+
+        return stdout
+
     def filter_args_num(self, matches, args):  # pylint: disable=no-self-use
         """Filter out directives with specific number of arguments.
 
@@ -547,7 +612,7 @@ class ApacheParser(object):
             "%s//*[self::directive=~regexp('%s')]" % (start, regex))
 
         if exclude:
-            matches = self.exclude_dirs(matches)
+            matches = self._exclude_dirs(matches)
 
         if arg is None:
             arg_suffix = "/arg"
@@ -613,13 +678,7 @@ class ApacheParser(object):
 
         return value
 
-    def get_root_augpath(self):
-        """
-        Returns the Augeas path of root configuration.
-        """
-        return get_aug_path(self.loc["root"])
-
-    def exclude_dirs(self, matches):
+    def _exclude_dirs(self, matches):
         """Exclude directives that are not loaded into the configuration."""
         filters = [("ifmodule", self.modules), ("ifdefine", self.variables)]
 
@@ -705,7 +764,7 @@ class ApacheParser(object):
         split_arg = arg.split("/")
         for idx, split in enumerate(split_arg):
             if any(char in ApacheParser.fnmatch_chars for char in split):
-                # Turn it into a augeas regex
+                # Turn it into an augeas regex
                 # TODO: Can this instead be an augeas glob instead of regex
                 split_arg[idx] = ("* [label()=~regexp('%s')]" %
                                   self.fnmatch_to_re(split))

certbot-apache/certbot_apache/_internal/parsernode_util.py

@@ -1,129 +0,0 @@
-"""ParserNode utils"""
-
-
-def validate_kwargs(kwargs, required_names):
-    """
-    Ensures that the kwargs dict has all the expected values. This function modifies
-    the kwargs dictionary, and hence the returned dictionary should be used instead
-    in the caller function instead of the original kwargs.
-
-    :param dict kwargs: Dictionary of keyword arguments to validate.
-    :param list required_names: List of required parameter names.
-    """
-
-    validated_kwargs = dict()
-    for name in required_names:
-        try:
-            validated_kwargs[name] = kwargs.pop(name)
-        except KeyError:
-            raise TypeError("Required keyword argument: {} undefined.".format(name))
-
-    # Raise exception if unknown key word arguments are found.
-    if kwargs:
-        unknown = ", ".join(kwargs.keys())
-        raise TypeError("Unknown keyword argument(s): {}".format(unknown))
-    return validated_kwargs
-
-
-def parsernode_kwargs(kwargs):
-    """
-    Validates keyword arguments for ParserNode. This function modifies the kwargs
-    dictionary, and hence the returned dictionary should be used instead in the
-    caller function instead of the original kwargs.
-
-    If metadata is provided, the otherwise required argument "filepath" may be
-    omitted if the implementation is able to extract its value from the metadata.
-    This usecase is handled within this function. Filepath defaults to None.
-
-    :param dict kwargs: Keyword argument dictionary to validate.
-
-    :returns: Tuple of validated and prepared arguments.
-    """
-
-    # As many values of ParserNode instances can be derived from the metadata,
-    # (ancestor being a common exception here) make sure we permit it here as well.
-    if "metadata" in kwargs:
-        # Filepath can be derived from the metadata in Augeas implementation.
-        # Default is None, as in this case the responsibility of populating this
-        # variable lies on the implementation.
-        kwargs.setdefault("filepath", None)
-
-    kwargs.setdefault("dirty", False)
-    kwargs.setdefault("metadata", {})
-
-    kwargs = validate_kwargs(kwargs, ["ancestor", "dirty", "filepath", "metadata"])
-    return kwargs["ancestor"], kwargs["dirty"], kwargs["filepath"], kwargs["metadata"]
-
-
-def commentnode_kwargs(kwargs):
-    """
-    Validates keyword arguments for CommentNode and sets the default values for
-    optional kwargs. This function modifies the kwargs dictionary, and hence the
-    returned dictionary should be used instead in the caller function instead of
-    the original kwargs.
-
-    If metadata is provided, the otherwise required argument "comment" may be
-    omitted if the implementation is able to extract its value from the metadata.
-    This usecase is handled within this function.
-
-    :param dict kwargs: Keyword argument dictionary to validate.
-
-    :returns: Tuple of validated and prepared arguments and ParserNode kwargs.
-    """
-
-    # As many values of ParserNode instances can be derived from the metadata,
-    # (ancestor being a common exception here) make sure we permit it here as well.
-    if "metadata" in kwargs:
-        kwargs.setdefault("comment", None)
-        # Filepath can be derived from the metadata in Augeas implementation.
-        # Default is None, as in this case the responsibility of populating this
-        # variable lies on the implementation.
-        kwargs.setdefault("filepath", None)
-
-    kwargs.setdefault("dirty", False)
-    kwargs.setdefault("metadata", {})
-
-    kwargs = validate_kwargs(kwargs, ["ancestor", "dirty", "filepath", "comment",
-                                      "metadata"])
-
-    comment = kwargs.pop("comment")
-    return comment, kwargs
-
-
-def directivenode_kwargs(kwargs):
-    """
-    Validates keyword arguments for DirectiveNode and BlockNode and sets the
-    default values for optional kwargs. This function modifies the kwargs
-    dictionary, and hence the returned dictionary should be used instead in the
-    caller function instead of the original kwargs.
-
-    If metadata is provided, the otherwise required argument "name" may be
-    omitted if the implementation is able to extract its value from the metadata.
-    This usecase is handled within this function.
-
-    :param dict kwargs: Keyword argument dictionary to validate.
-
-    :returns: Tuple of validated and prepared arguments and ParserNode kwargs.
-    """
-
-    # As many values of ParserNode instances can be derived from the metadata,
-    # (ancestor being a common exception here) make sure we permit it here as well.
-    if "metadata" in kwargs:
-        kwargs.setdefault("name", None)
-        # Filepath can be derived from the metadata in Augeas implementation.
-        # Default is None, as in this case the responsibility of populating this
-        # variable lies on the implementation.
-        kwargs.setdefault("filepath", None)
-
-    kwargs.setdefault("dirty", False)
-    kwargs.setdefault("enabled", True)
-    kwargs.setdefault("parameters", ())
-    kwargs.setdefault("metadata", {})
-
-    kwargs = validate_kwargs(kwargs, ["ancestor", "dirty", "filepath", "name",
-                                      "parameters", "enabled", "metadata"])
-
-    name = kwargs.pop("name")
-    parameters = kwargs.pop("parameters")
-    enabled = kwargs.pop("enabled")
-    return name, parameters, enabled, kwargs

certbot-apache/local-oldest-requirements.txt

@@ -1,3 +1,3 @@
 # Remember to update setup.py to match the package versions below.
 acme[dev]==0.29.0
--e certbot[dev]
+certbot[dev]==1.1.0

certbot-apache/setup.py

@@ -4,13 +4,13 @@ from setuptools import find_packages
 from setuptools import setup
 from setuptools.command.test import test as TestCommand
 
-version = '1.1.0.dev0'
+version = '1.2.0.dev0'
 
 # Remember to update local-oldest-requirements.txt when changing the minimum
 # acme/certbot version.
 install_requires = [
     'acme>=0.29.0',
-    'certbot>=1.0.0.dev0',
+    'certbot>=1.1.0',
     'mock',
     'python-augeas',
     'setuptools',
@@ -18,9 +18,6 @@ install_requires = [
     'zope.interface',
 ]
 
-dev_extras = [
-    'apacheconfig>=0.3.2',
-]
 
 class PyTest(TestCommand):
     user_options = []
@@ -72,9 +69,6 @@ setup(
     packages=find_packages(),
     include_package_data=True,
     install_requires=install_requires,
-    extras_require={
-        'dev': dev_extras,
-    },
     entry_points={
         'certbot.plugins': [
             'apache = certbot_apache._internal.entrypoint:ENTRYPOINT',

certbot-apache/tests/augeasnode_test.py

@@ -1,327 +0,0 @@
-"""Tests for AugeasParserNode classes"""
-import mock
-
-import unittest
-import util
-
-try:
-    import apacheconfig  # pylint: disable=import-error,unused-import
-    HAS_APACHECONFIG = True
-except ImportError:  # pragma: no cover
-    HAS_APACHECONFIG = False
-
-from acme.magic_typing import List  # pylint: disable=unused-import, no-name-in-module
-from certbot import errors
-
-from certbot_apache._internal import assertions
-
-
-
-@unittest.skipIf(not HAS_APACHECONFIG, reason='Tests require apacheconfig dependency')
-class AugeasParserNodeTest(util.ApacheTest):  # pylint: disable=too-many-public-methods
-    """Test AugeasParserNode using available test configurations"""
-
-    def setUp(self):  # pylint: disable=arguments-differ
-        super(AugeasParserNodeTest, self).setUp()
-
-        self.config = util.get_apache_configurator(
-            self.config_path, self.vhost_path, self.config_dir, self.work_dir, use_parsernode=True)
-        self.vh_truth = util.get_vh_truth(
-            self.temp_dir, "debian_apache_2_4/multiple_vhosts")
-
-    def test_save(self):
-        with mock.patch('certbot_apache._internal.parser.ApacheParser.save') as mock_save:
-            self.config.parser_root.save("A save message")
-        self.assertTrue(mock_save.called)
-        self.assertEqual(mock_save.call_args[0][0], "A save message")
-
-    def test_unsaved_files(self):
-        with mock.patch('certbot_apache._internal.parser.ApacheParser.unsaved_files') as mock_uf:
-            mock_uf.return_value = ["first", "second"]
-            files = self.config.parser_root.unsaved_files()
-        self.assertEqual(files, ["first", "second"])
-
-    def test_get_block_node_name(self):
-        from certbot_apache._internal.augeasparser import AugeasBlockNode
-        block = AugeasBlockNode(
-            name=assertions.PASS,
-            ancestor=None,
-            filepath=assertions.PASS,
-            metadata={"augeasparser": mock.Mock(), "augeaspath": "/files/anything"}
-        )
-        testcases = {
-            "/some/path/FirstNode/SecondNode": "SecondNode",
-            "/some/path/FirstNode/SecondNode/": "SecondNode",
-            "OnlyPathItem": "OnlyPathItem",
-            "/files/etc/apache2/apache2.conf/VirtualHost": "VirtualHost",
-            "/Anything": "Anything",
-        }
-        for test in testcases:
-            self.assertEqual(block._aug_get_name(test), testcases[test])  # pylint: disable=protected-access
-
-    def test_find_blocks(self):
-        blocks = self.config.parser_root.find_blocks("VirtualHost", exclude=False)
-        self.assertEqual(len(blocks), 12)
-
-    def test_find_blocks_case_insensitive(self):
-        vhs = self.config.parser_root.find_blocks("VirtualHost")
-        vhs2 = self.config.parser_root.find_blocks("viRtuAlHoST")
-        self.assertEqual(len(vhs), len(vhs2))
-
-    def test_find_directive_found(self):
-        directives = self.config.parser_root.find_directives("Listen")
-        self.assertEqual(len(directives), 1)
-        self.assertTrue(directives[0].filepath.endswith("/apache2/ports.conf"))
-        self.assertEqual(directives[0].parameters, (u'80',))
-
-    def test_find_directive_notfound(self):
-        directives = self.config.parser_root.find_directives("Nonexistent")
-        self.assertEqual(len(directives), 0)
-
-    def test_find_directive_from_block(self):
-        blocks = self.config.parser_root.find_blocks("virtualhost")
-        found = False
-        for vh in blocks:
-            if vh.filepath.endswith("sites-enabled/certbot.conf"):
-                servername = vh.find_directives("servername")
-                self.assertEqual(servername[0].parameters[0], "certbot.demo")
-                found = True
-        self.assertTrue(found)
-
-    def test_find_comments(self):
-        rootcomment = self.config.parser_root.find_comments(
-            "This is the main Apache server configuration file. "
-        )
-        self.assertEqual(len(rootcomment), 1)
-        self.assertTrue(rootcomment[0].filepath.endswith(
-            "debian_apache_2_4/multiple_vhosts/apache2/apache2.conf"
-        ))
-
-    def test_set_parameters(self):
-        servernames = self.config.parser_root.find_directives("servername")
-        names = []  # type: List[str]
-        for servername in servernames:
-            names += servername.parameters
-        self.assertFalse("going_to_set_this" in names)
-        servernames[0].set_parameters(["something", "going_to_set_this"])
-        servernames = self.config.parser_root.find_directives("servername")
-        names = []
-        for servername in servernames:
-            names += servername.parameters
-        self.assertTrue("going_to_set_this" in names)
-
-    def test_set_parameters_atinit(self):
-        from certbot_apache._internal.augeasparser import AugeasDirectiveNode
-        servernames = self.config.parser_root.find_directives("servername")
-        setparam = "certbot_apache._internal.augeasparser.AugeasDirectiveNode.set_parameters"
-        with mock.patch(setparam) as mock_set:
-            AugeasDirectiveNode(
-                name=servernames[0].name,
-                parameters=["test", "setting", "these"],
-                ancestor=assertions.PASS,
-                metadata=servernames[0].primary.metadata
-            )
-            self.assertTrue(mock_set.called)
-            self.assertEqual(
-                mock_set.call_args_list[0][0][0],
-                ["test", "setting", "these"]
-            )
-
-    def test_set_parameters_delete(self):
-        # Set params
-        servername = self.config.parser_root.find_directives("servername")[0]
-        servername.set_parameters(["thisshouldnotexistpreviously", "another",
-                                   "third"])
-
-        # Delete params
-        servernames = self.config.parser_root.find_directives("servername")
-        found = False
-        for servername in servernames:
-            if "thisshouldnotexistpreviously" in servername.parameters:
-                self.assertEqual(len(servername.parameters), 3)
-                servername.set_parameters(["thisshouldnotexistpreviously"])
-                found = True
-        self.assertTrue(found)
-
-        # Verify params
-        servernames = self.config.parser_root.find_directives("servername")
-        found = False
-        for servername in servernames:
-            if "thisshouldnotexistpreviously" in servername.parameters:
-                self.assertEqual(len(servername.parameters), 1)
-                servername.set_parameters(["thisshouldnotexistpreviously"])
-                found = True
-        self.assertTrue(found)
-
-    def test_add_child_comment(self):
-        newc = self.config.parser_root.add_child_comment("The content")
-        comments = self.config.parser_root.find_comments("The content")
-        self.assertEqual(len(comments), 1)
-        self.assertEqual(
-            newc.metadata["augeaspath"],
-            comments[0].primary.metadata["augeaspath"]
-        )
-        self.assertEqual(newc.comment, comments[0].comment)
-
-    def test_delete_child(self):
-        listens = self.config.parser_root.primary.find_directives("Listen")
-        self.assertEqual(len(listens), 1)
-        self.config.parser_root.primary.delete_child(listens[0])
-
-        listens = self.config.parser_root.primary.find_directives("Listen")
-        self.assertEqual(len(listens), 0)
-
-    def test_delete_child_not_found(self):
-        listen = self.config.parser_root.find_directives("Listen")[0]
-        listen.primary.metadata["augeaspath"] = "/files/something/nonexistent"
-
-        self.assertRaises(
-            errors.PluginError,
-            self.config.parser_root.delete_child,
-            listen
-        )
-
-    def test_add_child_block(self):
-        nb = self.config.parser_root.add_child_block(
-            "NewBlock",
-            ["first", "second"]
-        )
-        rpath, _, directive = nb.primary.metadata["augeaspath"].rpartition("/")
-        self.assertEqual(
-            rpath,
-            self.config.parser_root.primary.metadata["augeaspath"]
-        )
-        self.assertTrue(directive.startswith("NewBlock"))
-
-    def test_add_child_block_beginning(self):
-        self.config.parser_root.add_child_block(
-            "Beginning",
-            position=0
-        )
-        parser = self.config.parser_root.primary.parser
-        root_path = self.config.parser_root.primary.metadata["augeaspath"]
-        # Get first child
-        first = parser.aug.match("{}/*[1]".format(root_path))
-        self.assertTrue(first[0].endswith("Beginning"))
-
-    def test_add_child_block_append(self):
-        self.config.parser_root.add_child_block(
-            "VeryLast",
-        )
-        parser = self.config.parser_root.primary.parser
-        root_path = self.config.parser_root.primary.metadata["augeaspath"]
-        # Get last child
-        last = parser.aug.match("{}/*[last()]".format(root_path))
-        self.assertTrue(last[0].endswith("VeryLast"))
-
-    def test_add_child_block_append_alt(self):
-        self.config.parser_root.add_child_block(
-            "VeryLastAlt",
-            position=99999
-        )
-        parser = self.config.parser_root.primary.parser
-        root_path = self.config.parser_root.primary.metadata["augeaspath"]
-        # Get last child
-        last = parser.aug.match("{}/*[last()]".format(root_path))
-        self.assertTrue(last[0].endswith("VeryLastAlt"))
-
-    def test_add_child_block_middle(self):
-        self.config.parser_root.add_child_block(
-            "Middle",
-            position=5
-        )
-        parser = self.config.parser_root.primary.parser
-        root_path = self.config.parser_root.primary.metadata["augeaspath"]
-        # Augeas indices start at 1 :(
-        middle = parser.aug.match("{}/*[6]".format(root_path))
-        self.assertTrue(middle[0].endswith("Middle"))
-
-    def test_add_child_block_existing_name(self):
-        parser = self.config.parser_root.primary.parser
-        root_path = self.config.parser_root.primary.metadata["augeaspath"]
-        # There already exists a single VirtualHost in the base config
-        new_block = parser.aug.match("{}/VirtualHost[2]".format(root_path))
-        self.assertEqual(len(new_block), 0)
-        vh = self.config.parser_root.add_child_block(
-            "VirtualHost",
-        )
-        new_block = parser.aug.match("{}/VirtualHost[2]".format(root_path))
-        self.assertEqual(len(new_block), 1)
-        self.assertTrue(vh.primary.metadata["augeaspath"].endswith("VirtualHost[2]"))
-
-    def test_node_init_error_bad_augeaspath(self):
-        from certbot_apache._internal.augeasparser import AugeasBlockNode
-        parameters = {
-            "name": assertions.PASS,
-            "ancestor": None,
-            "filepath": assertions.PASS,
-            "metadata": {
-                "augeasparser": mock.Mock(),
-                "augeaspath": "/files/path/endswith/slash/"
-            }
-        }
-        self.assertRaises(
-            errors.PluginError,
-            AugeasBlockNode,
-            **parameters
-        )
-
-    def test_node_init_error_missing_augeaspath(self):
-        from certbot_apache._internal.augeasparser import AugeasBlockNode
-        parameters = {
-            "name": assertions.PASS,
-            "ancestor": None,
-            "filepath": assertions.PASS,
-            "metadata": {
-                "augeasparser": mock.Mock(),
-            }
-        }
-        self.assertRaises(
-            errors.PluginError,
-            AugeasBlockNode,
-            **parameters
-        )
-
-    def test_add_child_directive(self):
-        self.config.parser_root.add_child_directive(
-            "ThisWasAdded",
-            ["with", "parameters"],
-            position=0
-        )
-        dirs = self.config.parser_root.find_directives("ThisWasAdded")
-        self.assertEqual(len(dirs), 1)
-        self.assertEqual(dirs[0].parameters, ("with", "parameters"))
-        # The new directive was added to the very first line of the config
-        self.assertTrue(dirs[0].primary.metadata["augeaspath"].endswith("[1]"))
-
-    def test_add_child_directive_exception(self):
-        self.assertRaises(
-            errors.PluginError,
-            self.config.parser_root.add_child_directive,
-            "ThisRaisesErrorBecauseMissingParameters"
-        )
-
-    def test_parsed_paths(self):
-        paths = self.config.parser_root.parsed_paths()
-        self.assertEqual(len(paths), 6)
-
-    def test_find_ancestors(self):
-        vhsblocks = self.config.parser_root.find_blocks("VirtualHost")
-        macro_test = False
-        nonmacro_test = False
-        for vh in vhsblocks:
-            if "/macro/" in vh.metadata["augeaspath"].lower():
-                ancs = vh.find_ancestors("Macro")
-                self.assertEqual(len(ancs), 1)
-                macro_test = True
-            else:
-                ancs = vh.find_ancestors("Macro")
-                self.assertEqual(len(ancs), 0)
-                nonmacro_test = True
-        self.assertTrue(macro_test)
-        self.assertTrue(nonmacro_test)
-
-    def test_find_ancestors_bad_path(self):
-        self.config.parser_root.primary.metadata["augeaspath"] = ""
-        ancs = self.config.parser_root.primary.find_ancestors("Anything")
-        self.assertEqual(len(ancs), 0)

certbot-apache/tests/centos_test.py

@@ -106,7 +106,7 @@ class MultipleVhostsTestCentOS(util.ApacheTest):
     def test_get_parser(self):
         self.assertIsInstance(self.config.parser, override_centos.CentOSParser)
 
-    @mock.patch("certbot_apache._internal.apache_util._get_runtime_cfg")
+    @mock.patch("certbot_apache._internal.parser.ApacheParser._get_runtime_cfg")
     def test_opportunistic_httpd_runtime_parsing(self, mock_get):
         define_val = (
             'Define: TEST1\n'
@@ -155,7 +155,7 @@ class MultipleVhostsTestCentOS(util.ApacheTest):
                 raise Exception("Missed: %s" % vhost)  # pragma: no cover
         self.assertEqual(found, 2)
 
-    @mock.patch("certbot_apache._internal.apache_util._get_runtime_cfg")
+    @mock.patch("certbot_apache._internal.parser.ApacheParser._get_runtime_cfg")
     def test_get_sysconfig_vars(self, mock_cfg):
         """Make sure we read the sysconfig OPTIONS variable correctly"""
         # Return nothing for the process calls

certbot-apache/tests/configurator_test.py

@@ -75,8 +75,7 @@ class MultipleVhostsTest(util.ApacheTest):
 
     @mock.patch("certbot_apache._internal.parser.ApacheParser")
     @mock.patch("certbot_apache._internal.configurator.util.exe_exists")
-    @mock.patch("certbot_apache._internal.configurator.ApacheConfigurator.get_parsernode_root")
-    def _test_prepare_locked(self, _node, _exists, _parser):
+    def _test_prepare_locked(self, unused_parser, unused_exe_exists):
         try:
             self.config.prepare()
         except errors.PluginError as err:
@@ -800,7 +799,7 @@ class MultipleVhostsTest(util.ApacheTest):
         self.assertEqual(mock_restart.call_count, 1)
 
     @mock.patch("certbot_apache._internal.configurator.ApacheConfigurator.restart")
-    @mock.patch("certbot_apache._internal.apache_util._get_runtime_cfg")
+    @mock.patch("certbot_apache._internal.parser.ApacheParser._get_runtime_cfg")
     def test_cleanup(self, mock_cfg, mock_restart):
         mock_cfg.return_value = ""
         _, achalls = self.get_key_and_achalls()
@@ -816,7 +815,7 @@ class MultipleVhostsTest(util.ApacheTest):
                 self.assertFalse(mock_restart.called)
 
     @mock.patch("certbot_apache._internal.configurator.ApacheConfigurator.restart")
-    @mock.patch("certbot_apache._internal.apache_util._get_runtime_cfg")
+    @mock.patch("certbot_apache._internal.parser.ApacheParser._get_runtime_cfg")
     def test_cleanup_no_errors(self, mock_cfg, mock_restart):
         mock_cfg.return_value = ""
         _, achalls = self.get_key_and_achalls()

certbot-apache/tests/debian_test.py

@@ -46,7 +46,7 @@ class MultipleVhostsTestDebian(util.ApacheTest):
 
     @mock.patch("certbot.util.run_script")
     @mock.patch("certbot.util.exe_exists")
-    @mock.patch("certbot_apache._internal.apache_util.subprocess.Popen")
+    @mock.patch("certbot_apache._internal.parser.subprocess.Popen")
     def test_enable_mod(self, mock_popen, mock_exe_exists, mock_run_script):
         mock_popen().communicate.return_value = ("Define: DUMP_RUN_CFG", "")
         mock_popen().returncode = 0

certbot-apache/tests/dualnode_test.py

@@ -1,443 +0,0 @@
-"""Tests for DualParserNode implementation"""
-import unittest
-
-import mock
-
-from certbot_apache._internal import assertions
-from certbot_apache._internal import augeasparser
-from certbot_apache._internal import dualparser
-
-
-class DualParserNodeTest(unittest.TestCase):  # pylint: disable=too-many-public-methods
-    """DualParserNode tests"""
-
-    def setUp(self):  # pylint: disable=arguments-differ
-        parser_mock = mock.MagicMock()
-        parser_mock.aug.match.return_value = []
-        parser_mock.get_arg.return_value = []
-        ast_mock = mock.MagicMock()
-        self.metadata = {"augeasparser": parser_mock, "augeaspath": "/invalid", "ac_ast": ast_mock}
-        self.block = dualparser.DualBlockNode(name="block",
-                                              ancestor=None,
-                                              filepath="/tmp/something",
-                                              metadata=self.metadata)
-        self.block_two = dualparser.DualBlockNode(name="block",
-                                                  ancestor=self.block,
-                                                  filepath="/tmp/something",
-                                                  metadata=self.metadata)
-        self.directive = dualparser.DualDirectiveNode(name="directive",
-                                                      ancestor=self.block,
-                                                      filepath="/tmp/something",
-                                                      metadata=self.metadata)
-        self.comment = dualparser.DualCommentNode(comment="comment",
-                                                  ancestor=self.block,
-                                                  filepath="/tmp/something",
-                                                  metadata=self.metadata)
-
-    def test_create_with_precreated(self):
-        cnode = dualparser.DualCommentNode(comment="comment",
-                                           ancestor=self.block,
-                                           filepath="/tmp/something",
-                                           primary=self.comment.secondary,
-                                           secondary=self.comment.primary)
-        dnode = dualparser.DualDirectiveNode(name="directive",
-                                             ancestor=self.block,
-                                             filepath="/tmp/something",
-                                             primary=self.directive.secondary,
-                                             secondary=self.directive.primary)
-        bnode = dualparser.DualBlockNode(name="block",
-                                         ancestor=self.block,
-                                         filepath="/tmp/something",
-                                         primary=self.block.secondary,
-                                         secondary=self.block.primary)
-        # Switched around
-        self.assertTrue(cnode.primary is self.comment.secondary)
-        self.assertTrue(cnode.secondary is self.comment.primary)
-        self.assertTrue(dnode.primary is self.directive.secondary)
-        self.assertTrue(dnode.secondary is self.directive.primary)
-        self.assertTrue(bnode.primary is self.block.secondary)
-        self.assertTrue(bnode.secondary is self.block.primary)
-
-    def test_set_params(self):
-        params = ("first", "second")
-        self.directive.primary.set_parameters = mock.Mock()
-        self.directive.secondary.set_parameters = mock.Mock()
-        self.directive.set_parameters(params)
-        self.assertTrue(self.directive.primary.set_parameters.called)
-        self.assertTrue(self.directive.secondary.set_parameters.called)
-
-    def test_set_parameters(self):
-        pparams = mock.MagicMock()
-        sparams = mock.MagicMock()
-        pparams.parameters = ("a", "b")
-        sparams.parameters = ("a", "b")
-        self.directive.primary.set_parameters = pparams
-        self.directive.secondary.set_parameters = sparams
-        self.directive.set_parameters(("param", "seq"))
-        self.assertTrue(pparams.called)
-        self.assertTrue(sparams.called)
-
-    def test_delete_child(self):
-        pdel = mock.MagicMock()
-        sdel = mock.MagicMock()
-        self.block.primary.delete_child = pdel
-        self.block.secondary.delete_child = sdel
-        self.block.delete_child(self.comment)
-        self.assertTrue(pdel.called)
-        self.assertTrue(sdel.called)
-
-    def test_unsaved_files(self):
-        puns = mock.MagicMock()
-        suns = mock.MagicMock()
-        puns.return_value = assertions.PASS
-        suns.return_value = assertions.PASS
-        self.block.primary.unsaved_files = puns
-        self.block.secondary.unsaved_files = suns
-        self.block.unsaved_files()
-        self.assertTrue(puns.called)
-        self.assertTrue(suns.called)
-
-    def test_getattr_equality(self):
-        self.directive.primary.variableexception = "value"
-        self.directive.secondary.variableexception = "not_value"
-        with self.assertRaises(AssertionError):
-            _ = self.directive.variableexception
-
-        self.directive.primary.variable = "value"
-        self.directive.secondary.variable = "value"
-        try:
-            self.directive.variable
-        except AssertionError: # pragma: no cover
-            self.fail("getattr check raised an AssertionError where it shouldn't have")
-
-    def test_parsernode_dirty_assert(self):
-        # disable assertion pass
-        self.comment.primary.comment = "value"
-        self.comment.secondary.comment = "value"
-        self.comment.primary.filepath = "x"
-        self.comment.secondary.filepath = "x"
-
-        self.comment.primary.dirty = False
-        self.comment.secondary.dirty = True
-        with self.assertRaises(AssertionError):
-            assertions.assertEqual(self.comment.primary, self.comment.secondary)
-
-    def test_parsernode_filepath_assert(self):
-        # disable assertion pass
-        self.comment.primary.comment = "value"
-        self.comment.secondary.comment = "value"
-
-        self.comment.primary.filepath = "first"
-        self.comment.secondary.filepath = "second"
-        with self.assertRaises(AssertionError):
-            assertions.assertEqual(self.comment.primary, self.comment.secondary)
-
-    def test_add_child_block(self):
-        mock_first = mock.MagicMock(return_value=self.block.primary)
-        mock_second = mock.MagicMock(return_value=self.block.secondary)
-        self.block.primary.add_child_block = mock_first
-        self.block.secondary.add_child_block = mock_second
-        self.block.add_child_block("Block")
-        self.assertTrue(mock_first.called)
-        self.assertTrue(mock_second.called)
-
-    def test_add_child_directive(self):
-        mock_first = mock.MagicMock(return_value=self.directive.primary)
-        mock_second = mock.MagicMock(return_value=self.directive.secondary)
-        self.block.primary.add_child_directive = mock_first
-        self.block.secondary.add_child_directive = mock_second
-        self.block.add_child_directive("Directive")
-        self.assertTrue(mock_first.called)
-        self.assertTrue(mock_second.called)
-
-    def test_add_child_comment(self):
-        mock_first = mock.MagicMock(return_value=self.comment.primary)
-        mock_second = mock.MagicMock(return_value=self.comment.secondary)
-        self.block.primary.add_child_comment = mock_first
-        self.block.secondary.add_child_comment = mock_second
-        self.block.add_child_comment("Comment")
-        self.assertTrue(mock_first.called)
-        self.assertTrue(mock_second.called)
-
-    def test_find_comments(self):
-        pri_comments = [augeasparser.AugeasCommentNode(comment="some comment",
-                                                       ancestor=self.block,
-                                                       filepath="/path/to/whatever",
-                                                       metadata=self.metadata)]
-        sec_comments = [augeasparser.AugeasCommentNode(comment=assertions.PASS,
-                                                       ancestor=self.block,
-                                                       filepath=assertions.PASS,
-                                                       metadata=self.metadata)]
-        find_coms_primary = mock.MagicMock(return_value=pri_comments)
-        find_coms_secondary = mock.MagicMock(return_value=sec_comments)
-        self.block.primary.find_comments = find_coms_primary
-        self.block.secondary.find_comments = find_coms_secondary
-
-        dcoms = self.block.find_comments("comment")
-        p_dcoms = [d.primary for d in dcoms]
-        s_dcoms = [d.secondary for d in dcoms]
-        p_coms = self.block.primary.find_comments("comment")
-        s_coms = self.block.secondary.find_comments("comment")
-        # Check that every comment response is represented in the list of
-        # DualParserNode instances.
-        for p in p_dcoms:
-            self.assertTrue(p in p_coms)
-        for s in s_dcoms:
-            self.assertTrue(s in s_coms)
-
-    def test_find_blocks_first_passing(self):
-        youshallnotpass = [augeasparser.AugeasBlockNode(name="notpassing",
-                                                        ancestor=self.block,
-                                                        filepath="/path/to/whatever",
-                                                        metadata=self.metadata)]
-        youshallpass = [augeasparser.AugeasBlockNode(name=assertions.PASS,
-                                                     ancestor=self.block,
-                                                     filepath=assertions.PASS,
-                                                     metadata=self.metadata)]
-        find_blocks_primary = mock.MagicMock(return_value=youshallpass)
-        find_blocks_secondary = mock.MagicMock(return_value=youshallnotpass)
-        self.block.primary.find_blocks = find_blocks_primary
-        self.block.secondary.find_blocks = find_blocks_secondary
-
-        blocks = self.block.find_blocks("something")
-        for block in blocks:
-            try:
-                assertions.assertEqual(block.primary, block.secondary)
-            except AssertionError: # pragma: no cover
-                self.fail("Assertion should have passed")
-            self.assertTrue(assertions.isPassDirective(block.primary))
-            self.assertFalse(assertions.isPassDirective(block.secondary))
-
-    def test_find_blocks_second_passing(self):
-        youshallnotpass = [augeasparser.AugeasBlockNode(name="notpassing",
-                                                        ancestor=self.block,
-                                                        filepath="/path/to/whatever",
-                                                        metadata=self.metadata)]
-        youshallpass = [augeasparser.AugeasBlockNode(name=assertions.PASS,
-                                                     ancestor=self.block,
-                                                     filepath=assertions.PASS,
-                                                     metadata=self.metadata)]
-        find_blocks_primary = mock.MagicMock(return_value=youshallnotpass)
-        find_blocks_secondary = mock.MagicMock(return_value=youshallpass)
-        self.block.primary.find_blocks = find_blocks_primary
-        self.block.secondary.find_blocks = find_blocks_secondary
-
-        blocks = self.block.find_blocks("something")
-        for block in blocks:
-            try:
-                assertions.assertEqual(block.primary, block.secondary)
-            except AssertionError: # pragma: no cover
-                self.fail("Assertion should have passed")
-            self.assertFalse(assertions.isPassDirective(block.primary))
-            self.assertTrue(assertions.isPassDirective(block.secondary))
-
-    def test_find_dirs_first_passing(self):
-        notpassing = [augeasparser.AugeasDirectiveNode(name="notpassing",
-                                                       ancestor=self.block,
-                                                       filepath="/path/to/whatever",
-                                                       metadata=self.metadata)]
-        passing = [augeasparser.AugeasDirectiveNode(name=assertions.PASS,
-                                                    ancestor=self.block,
-                                                    filepath=assertions.PASS,
-                                                    metadata=self.metadata)]
-        find_dirs_primary = mock.MagicMock(return_value=passing)
-        find_dirs_secondary = mock.MagicMock(return_value=notpassing)
-        self.block.primary.find_directives = find_dirs_primary
-        self.block.secondary.find_directives = find_dirs_secondary
-
-        directives = self.block.find_directives("something")
-        for directive in directives:
-            try:
-                assertions.assertEqual(directive.primary, directive.secondary)
-            except AssertionError: # pragma: no cover
-                self.fail("Assertion should have passed")
-            self.assertTrue(assertions.isPassDirective(directive.primary))
-            self.assertFalse(assertions.isPassDirective(directive.secondary))
-
-    def test_find_dirs_second_passing(self):
-        notpassing = [augeasparser.AugeasDirectiveNode(name="notpassing",
-                                                       ancestor=self.block,
-                                                       filepath="/path/to/whatever",
-                                                       metadata=self.metadata)]
-        passing = [augeasparser.AugeasDirectiveNode(name=assertions.PASS,
-                                                    ancestor=self.block,
-                                                    filepath=assertions.PASS,
-                                                    metadata=self.metadata)]
-        find_dirs_primary = mock.MagicMock(return_value=notpassing)
-        find_dirs_secondary = mock.MagicMock(return_value=passing)
-        self.block.primary.find_directives = find_dirs_primary
-        self.block.secondary.find_directives = find_dirs_secondary
-
-        directives = self.block.find_directives("something")
-        for directive in directives:
-            try:
-                assertions.assertEqual(directive.primary, directive.secondary)
-            except AssertionError: # pragma: no cover
-                self.fail("Assertion should have passed")
-            self.assertFalse(assertions.isPassDirective(directive.primary))
-            self.assertTrue(assertions.isPassDirective(directive.secondary))
-
-    def test_find_coms_first_passing(self):
-        notpassing = [augeasparser.AugeasCommentNode(comment="notpassing",
-                                                     ancestor=self.block,
-                                                     filepath="/path/to/whatever",
-                                                     metadata=self.metadata)]
-        passing = [augeasparser.AugeasCommentNode(comment=assertions.PASS,
-                                                  ancestor=self.block,
-                                                  filepath=assertions.PASS,
-                                                  metadata=self.metadata)]
-        find_coms_primary = mock.MagicMock(return_value=passing)
-        find_coms_secondary = mock.MagicMock(return_value=notpassing)
-        self.block.primary.find_comments = find_coms_primary
-        self.block.secondary.find_comments = find_coms_secondary
-
-        comments = self.block.find_comments("something")
-        for comment in comments:
-            try:
-                assertions.assertEqual(comment.primary, comment.secondary)
-            except AssertionError: # pragma: no cover
-                self.fail("Assertion should have passed")
-            self.assertTrue(assertions.isPassComment(comment.primary))
-            self.assertFalse(assertions.isPassComment(comment.secondary))
-
-    def test_find_coms_second_passing(self):
-        notpassing = [augeasparser.AugeasCommentNode(comment="notpassing",
-                                                     ancestor=self.block,
-                                                     filepath="/path/to/whatever",
-                                                     metadata=self.metadata)]
-        passing = [augeasparser.AugeasCommentNode(comment=assertions.PASS,
-                                                  ancestor=self.block,
-                                                  filepath=assertions.PASS,
-                                                  metadata=self.metadata)]
-        find_coms_primary = mock.MagicMock(return_value=notpassing)
-        find_coms_secondary = mock.MagicMock(return_value=passing)
-        self.block.primary.find_comments = find_coms_primary
-        self.block.secondary.find_comments = find_coms_secondary
-
-        comments = self.block.find_comments("something")
-        for comment in comments:
-            try:
-                assertions.assertEqual(comment.primary, comment.secondary)
-            except AssertionError: # pragma: no cover
-                self.fail("Assertion should have passed")
-            self.assertFalse(assertions.isPassComment(comment.primary))
-            self.assertTrue(assertions.isPassComment(comment.secondary))
-
-    def test_find_blocks_no_pass_equal(self):
-        notpassing1 = [augeasparser.AugeasBlockNode(name="notpassing",
-                                                    ancestor=self.block,
-                                                    filepath="/path/to/whatever",
-                                                    metadata=self.metadata)]
-        notpassing2 = [augeasparser.AugeasBlockNode(name="notpassing",
-                                                    ancestor=self.block,
-                                                    filepath="/path/to/whatever",
-                                                    metadata=self.metadata)]
-        find_blocks_primary = mock.MagicMock(return_value=notpassing1)
-        find_blocks_secondary = mock.MagicMock(return_value=notpassing2)
-        self.block.primary.find_blocks = find_blocks_primary
-        self.block.secondary.find_blocks = find_blocks_secondary
-
-        blocks = self.block.find_blocks("anything")
-        for block in blocks:
-            self.assertEqual(block.primary, block.secondary)
-            self.assertTrue(block.primary is not block.secondary)
-
-    def test_find_dirs_no_pass_equal(self):
-        notpassing1 = [augeasparser.AugeasDirectiveNode(name="notpassing",
-                                                        ancestor=self.block,
-                                                        filepath="/path/to/whatever",
-                                                        metadata=self.metadata)]
-        notpassing2 = [augeasparser.AugeasDirectiveNode(name="notpassing",
-                                                        ancestor=self.block,
-                                                        filepath="/path/to/whatever",
-                                                        metadata=self.metadata)]
-        find_dirs_primary = mock.MagicMock(return_value=notpassing1)
-        find_dirs_secondary = mock.MagicMock(return_value=notpassing2)
-        self.block.primary.find_directives = find_dirs_primary
-        self.block.secondary.find_directives = find_dirs_secondary
-
-        directives = self.block.find_directives("anything")
-        for directive in directives:
-            self.assertEqual(directive.primary, directive.secondary)
-            self.assertTrue(directive.primary is not directive.secondary)
-
-    def test_find_comments_no_pass_equal(self):
-        notpassing1 = [augeasparser.AugeasCommentNode(comment="notpassing",
-                                                      ancestor=self.block,
-                                                      filepath="/path/to/whatever",
-                                                      metadata=self.metadata)]
-        notpassing2 = [augeasparser.AugeasCommentNode(comment="notpassing",
-                                                      ancestor=self.block,
-                                                      filepath="/path/to/whatever",
-                                                      metadata=self.metadata)]
-        find_coms_primary = mock.MagicMock(return_value=notpassing1)
-        find_coms_secondary = mock.MagicMock(return_value=notpassing2)
-        self.block.primary.find_comments = find_coms_primary
-        self.block.secondary.find_comments = find_coms_secondary
-
-        comments = self.block.find_comments("anything")
-        for comment in comments:
-            self.assertEqual(comment.primary, comment.secondary)
-            self.assertTrue(comment.primary is not comment.secondary)
-
-    def test_find_blocks_no_pass_notequal(self):
-        notpassing1 = [augeasparser.AugeasBlockNode(name="notpassing",
-                                                    ancestor=self.block,
-                                                    filepath="/path/to/whatever",
-                                                    metadata=self.metadata)]
-        notpassing2 = [augeasparser.AugeasBlockNode(name="different",
-                                                    ancestor=self.block,
-                                                    filepath="/path/to/whatever",
-                                                    metadata=self.metadata)]
-        find_blocks_primary = mock.MagicMock(return_value=notpassing1)
-        find_blocks_secondary = mock.MagicMock(return_value=notpassing2)
-        self.block.primary.find_blocks = find_blocks_primary
-        self.block.secondary.find_blocks = find_blocks_secondary
-
-        with self.assertRaises(AssertionError):
-            _ = self.block.find_blocks("anything")
-
-    def test_parsernode_notequal(self):
-        ne_block = augeasparser.AugeasBlockNode(name="different",
-                                                ancestor=self.block,
-                                                filepath="/path/to/whatever",
-                                                metadata=self.metadata)
-        ne_directive = augeasparser.AugeasDirectiveNode(name="different",
-                                                        ancestor=self.block,
-                                                        filepath="/path/to/whatever",
-                                                        metadata=self.metadata)
-        ne_comment = augeasparser.AugeasCommentNode(comment="different",
-                                                    ancestor=self.block,
-                                                    filepath="/path/to/whatever",
-                                                    metadata=self.metadata)
-        self.assertFalse(self.block == ne_block)
-        self.assertFalse(self.directive == ne_directive)
-        self.assertFalse(self.comment == ne_comment)
-
-    def test_parsed_paths(self):
-        mock_p = mock.MagicMock(return_value=['/path/file.conf',
-                                              '/another/path',
-                                              '/path/other.conf'])
-        mock_s = mock.MagicMock(return_value=['/path/*.conf', '/another/path'])
-        self.block.primary.parsed_paths = mock_p
-        self.block.secondary.parsed_paths = mock_s
-        self.block.parsed_paths()
-        self.assertTrue(mock_p.called)
-        self.assertTrue(mock_s.called)
-
-    def test_parsed_paths_error(self):
-        mock_p = mock.MagicMock(return_value=['/path/file.conf'])
-        mock_s = mock.MagicMock(return_value=['/path/*.conf', '/another/path'])
-        self.block.primary.parsed_paths = mock_p
-        self.block.secondary.parsed_paths = mock_s
-        with self.assertRaises(AssertionError):
-            self.block.parsed_paths()
-
-    def test_find_ancestors(self):
-        primarymock = mock.MagicMock(return_value=[])
-        secondarymock = mock.MagicMock(return_value=[])
-        self.block.primary.find_ancestors = primarymock
-        self.block.secondary.find_ancestors = secondarymock
-        self.block.find_ancestors("anything")
-        self.assertTrue(primarymock.called)
-        self.assertTrue(secondarymock.called)

certbot-apache/tests/fedora_test.py

@@ -100,7 +100,7 @@ class MultipleVhostsTestFedora(util.ApacheTest):
     def test_get_parser(self):
         self.assertIsInstance(self.config.parser, override_fedora.FedoraParser)
 
-    @mock.patch("certbot_apache._internal.apache_util._get_runtime_cfg")
+    @mock.patch("certbot_apache._internal.parser.ApacheParser._get_runtime_cfg")
     def test_opportunistic_httpd_runtime_parsing(self, mock_get):
         define_val = (
             'Define: TEST1\n'
@@ -155,7 +155,7 @@ class MultipleVhostsTestFedora(util.ApacheTest):
                 raise Exception("Missed: %s" % vhost)  # pragma: no cover
         self.assertEqual(found, 2)
 
-    @mock.patch("certbot_apache._internal.apache_util._get_runtime_cfg")
+    @mock.patch("certbot_apache._internal.parser.ApacheParser._get_runtime_cfg")
     def test_get_sysconfig_vars(self, mock_cfg):
         """Make sure we read the sysconfig OPTIONS variable correctly"""
         # Return nothing for the process calls

certbot-apache/tests/gentoo_test.py

@@ -90,7 +90,7 @@ class MultipleVhostsTestGentoo(util.ApacheTest):
         for define in defines:
             self.assertTrue(define in self.config.parser.variables.keys())
 
-    @mock.patch("certbot_apache._internal.apache_util.parse_from_subprocess")
+    @mock.patch("certbot_apache._internal.parser.ApacheParser.parse_from_subprocess")
     def test_no_binary_configdump(self, mock_subprocess):
         """Make sure we don't call binary dumps other than modules from Apache
         as this is not supported in Gentoo currently"""
@@ -104,7 +104,7 @@ class MultipleVhostsTestGentoo(util.ApacheTest):
         self.config.parser.reset_modules()
         self.assertTrue(mock_subprocess.called)
 
-    @mock.patch("certbot_apache._internal.apache_util._get_runtime_cfg")
+    @mock.patch("certbot_apache._internal.parser.ApacheParser._get_runtime_cfg")
     def test_opportunistic_httpd_runtime_parsing(self, mock_get):
         mod_val = (
             'Loaded Modules:\n'

certbot-apache/tests/parser_test.py

@@ -165,7 +165,7 @@ class BasicParserTest(util.ParserTest):
             self.assertTrue(mock_logger.debug.called)
 
     @mock.patch("certbot_apache._internal.parser.ApacheParser.find_dir")
-    @mock.patch("certbot_apache._internal.apache_util._get_runtime_cfg")
+    @mock.patch("certbot_apache._internal.parser.ApacheParser._get_runtime_cfg")
     def test_update_runtime_variables(self, mock_cfg, _):
         define_val = (
             'ServerRoot: "/etc/apache2"\n'
@@ -271,7 +271,7 @@ class BasicParserTest(util.ParserTest):
             self.assertEqual(mock_parse.call_count, 25)
 
     @mock.patch("certbot_apache._internal.parser.ApacheParser.find_dir")
-    @mock.patch("certbot_apache._internal.apache_util._get_runtime_cfg")
+    @mock.patch("certbot_apache._internal.parser.ApacheParser._get_runtime_cfg")
     def test_update_runtime_variables_alt_values(self, mock_cfg, _):
         inc_val = (
             'Included configuration files:\n'
@@ -293,7 +293,7 @@ class BasicParserTest(util.ParserTest):
             # path derived from root configuration Include statements
             self.assertEqual(mock_parse.call_count, 1)
 
-    @mock.patch("certbot_apache._internal.apache_util._get_runtime_cfg")
+    @mock.patch("certbot_apache._internal.parser.ApacheParser._get_runtime_cfg")
     def test_update_runtime_vars_bad_output(self, mock_cfg):
         mock_cfg.return_value = "Define: TLS=443=24"
         self.parser.update_runtime_variables()
@@ -303,7 +303,7 @@ class BasicParserTest(util.ParserTest):
             errors.PluginError, self.parser.update_runtime_variables)
 
     @mock.patch("certbot_apache._internal.configurator.ApacheConfigurator.option")
-    @mock.patch("certbot_apache._internal.apache_util.subprocess.Popen")
+    @mock.patch("certbot_apache._internal.parser.subprocess.Popen")
     def test_update_runtime_vars_bad_ctl(self, mock_popen, mock_opt):
         mock_popen.side_effect = OSError
         mock_opt.return_value = "nonexistent"
@@ -311,7 +311,7 @@ class BasicParserTest(util.ParserTest):
             errors.MisconfigurationError,
             self.parser.update_runtime_variables)
 
-    @mock.patch("certbot_apache._internal.apache_util.subprocess.Popen")
+    @mock.patch("certbot_apache._internal.parser.subprocess.Popen")
     def test_update_runtime_vars_bad_exit(self, mock_popen):
         mock_popen().communicate.return_value = ("", "")
         mock_popen.returncode = -1
@@ -355,7 +355,7 @@ class ParserInitTest(util.ApacheTest):
                 ApacheParser, os.path.relpath(self.config_path),
                 "/dummy/vhostpath", version=(2, 4, 22), configurator=self.config)
 
-    @mock.patch("certbot_apache._internal.apache_util._get_runtime_cfg")
+    @mock.patch("certbot_apache._internal.parser.ApacheParser._get_runtime_cfg")
     def test_unparseable(self, mock_cfg):
         from certbot_apache._internal.parser import ApacheParser
         mock_cfg.return_value = ('Define: TEST')

certbot-apache/tests/parsernode_configurator_test.py

@@ -1,44 +0,0 @@
-"""Tests for ApacheConfigurator for AugeasParserNode classes"""
-import unittest
-
-import mock
-
-import util
-
-try:
-    import apacheconfig
-    HAS_APACHECONFIG = True
-except ImportError:  # pragma: no cover
-    HAS_APACHECONFIG = False
-
-
-@unittest.skipIf(not HAS_APACHECONFIG, reason='Tests require apacheconfig dependency')
-class ConfiguratorParserNodeTest(util.ApacheTest):  # pylint: disable=too-many-public-methods
-    """Test AugeasParserNode using available test configurations"""
-
-    def setUp(self):  # pylint: disable=arguments-differ
-        super(ConfiguratorParserNodeTest, self).setUp()
-
-        self.config = util.get_apache_configurator(
-            self.config_path, self.vhost_path, self.config_dir,
-            self.work_dir, use_parsernode=True)
-        self.vh_truth = util.get_vh_truth(
-            self.temp_dir, "debian_apache_2_4/multiple_vhosts")
-
-    def test_parsernode_get_vhosts(self):
-        self.config.USE_PARSERNODE = True
-        vhosts = self.config.get_virtual_hosts()
-        # Legacy get_virtual_hosts() do not set the node
-        self.assertTrue(vhosts[0].node is not None)
-
-    def test_parsernode_get_vhosts_mismatch(self):
-        vhosts = self.config.get_virtual_hosts_v2()
-        # One of the returned VirtualHost objects differs
-        vhosts[0].name = "IdidntExpectThat"
-        self.config.get_virtual_hosts_v2 = mock.MagicMock(return_value=vhosts)
-        with self.assertRaises(AssertionError):
-            _ = self.config.get_virtual_hosts()
-
-
-if __name__ == "__main__":
-    unittest.main()  # pragma: no cover

certbot-apache/tests/parsernode_test.py

@@ -1,128 +0,0 @@
-""" Tests for ParserNode interface """
-
-import unittest
-
-from certbot_apache._internal import interfaces
-from certbot_apache._internal import parsernode_util as util
-
-
-class DummyParserNode(interfaces.ParserNode):
-    """ A dummy class implementing ParserNode interface """
-
-    def __init__(self, **kwargs):
-        """
-        Initializes the ParserNode instance.
-        """
-        ancestor, dirty, filepath, metadata = util.parsernode_kwargs(kwargs)
-        self.ancestor = ancestor
-        self.dirty = dirty
-        self.filepath = filepath
-        self.metadata = metadata
-        super(DummyParserNode, self).__init__(**kwargs)
-
-    def save(self, msg):  # pragma: no cover
-        """Save"""
-        pass
-
-    def find_ancestors(self, name):  # pragma: no cover
-        """ Find ancestors """
-        return []
-
-
-class DummyCommentNode(DummyParserNode):
-    """ A dummy class implementing CommentNode interface """
-
-    def __init__(self, **kwargs):
-        """
-        Initializes the CommentNode instance and sets its instance variables.
-        """
-        comment, kwargs = util.commentnode_kwargs(kwargs)
-        self.comment = comment
-        super(DummyCommentNode, self).__init__(**kwargs)
-
-
-class DummyDirectiveNode(DummyParserNode):
-    """ A dummy class implementing DirectiveNode interface """
-
-    # pylint: disable=too-many-arguments
-    def __init__(self, **kwargs):
-        """
-        Initializes the DirectiveNode instance and sets its instance variables.
-        """
-        name, parameters, enabled, kwargs = util.directivenode_kwargs(kwargs)
-        self.name = name
-        self.parameters = parameters
-        self.enabled = enabled
-
-        super(DummyDirectiveNode, self).__init__(**kwargs)
-
-    def set_parameters(self, parameters):  # pragma: no cover
-        """Set parameters"""
-        pass
-
-
-class DummyBlockNode(DummyDirectiveNode):
-    """ A dummy class implementing BlockNode interface """
-
-    def add_child_block(self, name, parameters=None, position=None):  # pragma: no cover
-        """Add child block"""
-        pass
-
-    def add_child_directive(self, name, parameters=None, position=None):  # pragma: no cover
-        """Add child directive"""
-        pass
-
-    def add_child_comment(self, comment="", position=None):  # pragma: no cover
-        """Add child comment"""
-        pass
-
-    def find_blocks(self, name, exclude=True):  # pragma: no cover
-        """Find blocks"""
-        pass
-
-    def find_directives(self, name, exclude=True):  # pragma: no cover
-        """Find directives"""
-        pass
-
-    def find_comments(self, comment, exact=False):  # pragma: no cover
-        """Find comments"""
-        pass
-
-    def delete_child(self, child):  # pragma: no cover
-        """Delete child"""
-        pass
-
-    def unsaved_files(self):  # pragma: no cover
-        """Unsaved files"""
-        pass
-
-
-interfaces.CommentNode.register(DummyCommentNode)
-interfaces.DirectiveNode.register(DummyDirectiveNode)
-interfaces.BlockNode.register(DummyBlockNode)
-
-class ParserNodeTest(unittest.TestCase):
-    """Dummy placeholder test case for ParserNode interfaces"""
-
-    def test_dummy(self):
-        dummyblock = DummyBlockNode(
-            name="None",
-            parameters=(),
-            ancestor=None,
-            dirty=False,
-            filepath="/some/random/path"
-        )
-        dummydirective = DummyDirectiveNode(
-            name="Name",
-            ancestor=None,
-            filepath="/another/path"
-        )
-        dummycomment = DummyCommentNode(
-            comment="Comment",
-            ancestor=dummyblock,
-            filepath="/some/file"
-        )
-
-
-if __name__ == "__main__":
-    unittest.main()  # pragma: no cover

certbot-apache/tests/parsernode_util_test.py

@@ -1,115 +0,0 @@
-""" Tests for ParserNode utils """
-import unittest
-
-from certbot_apache._internal import parsernode_util as util
-
-
-class ParserNodeUtilTest(unittest.TestCase):
-    """Tests for ParserNode utils"""
-
-    def _setup_parsernode(self):
-        """ Sets up kwargs dict for ParserNode """
-        return {
-            "ancestor": None,
-            "dirty": False,
-            "filepath": "/tmp",
-        }
-
-    def _setup_commentnode(self):
-        """ Sets up kwargs dict for CommentNode """
-
-        pn = self._setup_parsernode()
-        pn["comment"] = "x"
-        return pn
-
-    def _setup_directivenode(self):
-        """ Sets up kwargs dict for DirectiveNode """
-
-        pn = self._setup_parsernode()
-        pn["name"] = "Name"
-        pn["parameters"] = ("first",)
-        pn["enabled"] = True
-        return pn
-
-    def test_unknown_parameter(self):
-        params = self._setup_parsernode()
-        params["unknown"] = "unknown"
-        self.assertRaises(TypeError, util.parsernode_kwargs, params)
-
-        params = self._setup_commentnode()
-        params["unknown"] = "unknown"
-        self.assertRaises(TypeError, util.commentnode_kwargs, params)
-
-        params = self._setup_directivenode()
-        params["unknown"] = "unknown"
-        self.assertRaises(TypeError, util.directivenode_kwargs, params)
-
-    def test_parsernode(self):
-        params = self._setup_parsernode()
-        ctrl = self._setup_parsernode()
-
-        ancestor, dirty, filepath, metadata = util.parsernode_kwargs(params)
-        self.assertEqual(ancestor, ctrl["ancestor"])
-        self.assertEqual(dirty, ctrl["dirty"])
-        self.assertEqual(filepath, ctrl["filepath"])
-        self.assertEqual(metadata, {})
-
-    def test_parsernode_from_metadata(self):
-        params = self._setup_parsernode()
-        params.pop("filepath")
-        md = {"some": "value"}
-        params["metadata"] = md
-
-        # Just testing that error from missing required parameters is not raised
-        _, _, _, metadata = util.parsernode_kwargs(params)
-        self.assertEqual(metadata, md)
-
-    def test_commentnode(self):
-        params = self._setup_commentnode()
-        ctrl = self._setup_commentnode()
-
-        comment, _ = util.commentnode_kwargs(params)
-        self.assertEqual(comment, ctrl["comment"])
-
-    def test_commentnode_from_metadata(self):
-        params = self._setup_commentnode()
-        params.pop("comment")
-        params["metadata"] = {}
-
-        # Just testing that error from missing required parameters is not raised
-        util.commentnode_kwargs(params)
-
-    def test_directivenode(self):
-        params = self._setup_directivenode()
-        ctrl = self._setup_directivenode()
-
-        name, parameters, enabled, _ = util.directivenode_kwargs(params)
-        self.assertEqual(name, ctrl["name"])
-        self.assertEqual(parameters, ctrl["parameters"])
-        self.assertEqual(enabled, ctrl["enabled"])
-
-    def test_directivenode_from_metadata(self):
-        params = self._setup_directivenode()
-        params.pop("filepath")
-        params.pop("name")
-        params["metadata"] = {"irrelevant": "value"}
-
-        # Just testing that error from missing required parameters is not raised
-        util.directivenode_kwargs(params)
-
-    def test_missing_required(self):
-        c_params = self._setup_commentnode()
-        c_params.pop("comment")
-        self.assertRaises(TypeError, util.commentnode_kwargs, c_params)
-
-        d_params = self._setup_directivenode()
-        d_params.pop("ancestor")
-        self.assertRaises(TypeError, util.directivenode_kwargs, d_params)
-
-        p_params = self._setup_parsernode()
-        p_params.pop("filepath")
-        self.assertRaises(TypeError, util.parsernode_kwargs, p_params)
-
-
-if __name__ == "__main__":
-    unittest.main()  # pragma: no cover

certbot-apache/tests/testdata/centos6_apache/apache/httpd/conf.d/ssl.conf

@@ -26,7 +26,7 @@ Listen 443
 
 #   Pass Phrase Dialog:
 #   Configure the pass phrase gathering process.
-#   The filtering dialog program (`builtin' is a internal
+#   The filtering dialog program (`builtin' is an internal
 #   terminal dialog) has to provide the pass phrase on stdout.
 SSLPassPhraseDialog  builtin
 

certbot-apache/tests/testdata/centos6_apache/apache/httpd/conf/httpd.conf

@@ -702,7 +702,7 @@ IndexIgnore .??* *~ *# HEADER* README* RCS CVS *,v *,t
 # English (en) - Esperanto (eo) - Estonian (et) - French (fr) - German (de)
 # Greek-Modern (el) - Hebrew (he) - Italian (it) - Japanese (ja)
 # Korean (ko) - Luxembourgeois* (ltz) - Norwegian Nynorsk (nn)
-# Norwegian (no) - Polish (pl) - Portugese (pt)
+# Norwegian (no) - Polish (pl) - Portuguese (pt)
 # Brazilian Portuguese (pt-BR) - Russian (ru) - Swedish (sv)
 # Simplified Chinese (zh-CN) - Spanish (es) - Traditional Chinese (zh-TW)
 #

certbot-apache/tests/testdata/centos7_apache/apache/httpd/conf.d/ssl.conf

@@ -13,7 +13,7 @@ Listen 443 https
 
 #   Pass Phrase Dialog:
 #   Configure the pass phrase gathering process.
-#   The filtering dialog program (`builtin' is a internal
+#   The filtering dialog program (`builtin' is an internal
 #   terminal dialog) has to provide the pass phrase on stdout.
 SSLPassPhraseDialog exec:/usr/libexec/httpd-ssl-pass-dialog
 

certbot-apache/tests/testdata/debian_apache_2_4/augeas_vhosts/apache2/mods-available/ssl.conf

@@ -31,7 +31,7 @@
 
 	#   Pass Phrase Dialog:
 	#   Configure the pass phrase gathering process.
-	#   The filtering dialog program (`builtin' is a internal
+	#   The filtering dialog program (`builtin' is an internal
 	#   terminal dialog) has to provide the pass phrase on stdout.
 	SSLPassPhraseDialog exec:/usr/share/apache2/ask-for-passphrase
 

certbot-apache/tests/testdata/debian_apache_2_4/default_vhost/apache2/mods-available/ssl.conf

@@ -31,7 +31,7 @@
 
 	#   Pass Phrase Dialog:
 	#   Configure the pass phrase gathering process.
-	#   The filtering dialog program (`builtin' is a internal
+	#   The filtering dialog program (`builtin' is an internal
 	#   terminal dialog) has to provide the pass phrase on stdout.
 	SSLPassPhraseDialog exec:/usr/share/apache2/ask-for-passphrase
 

certbot-apache/tests/testdata/debian_apache_2_4/multiple_vhosts/apache2/mods-available/ssl.conf

@@ -31,7 +31,7 @@
 
 	#   Pass Phrase Dialog:
 	#   Configure the pass phrase gathering process.
-	#   The filtering dialog program (`builtin' is a internal
+	#   The filtering dialog program (`builtin' is an internal
 	#   terminal dialog) has to provide the pass phrase on stdout.
 	SSLPassPhraseDialog exec:/usr/share/apache2/ask-for-passphrase
 

certbot-apache/tests/testdata/gentoo_apache/apache/apache2/modules.d/00_languages.conf

@@ -33,7 +33,7 @@
 # English (en) - Esperanto (eo) - Estonian (et) - French (fr) - German (de)
 # Greek-Modern (el) - Hebrew (he) - Italian (it) - Japanese (ja)
 # Korean (ko) - Luxembourgeois* (ltz) - Norwegian Nynorsk (nn)
-# Norwegian (no) - Polish (pl) - Portugese (pt)
+# Norwegian (no) - Polish (pl) - Portuguese (pt)
 # Brazilian Portuguese (pt-BR) - Russian (ru) - Swedish (sv)
 # Simplified Chinese (zh-CN) - Spanish (es) - Traditional Chinese (zh-TW)
 AddLanguage ca .ca

certbot-apache/tests/testdata/gentoo_apache/apache/apache2/modules.d/40_mod_ssl.conf

@@ -43,7 +43,7 @@ SSLRandomSeed connect builtin
 
 ## Pass Phrase Dialog:
 # Configure the pass phrase gathering process. The filtering dialog program 
-# (`builtin' is a internal terminal dialog) has to provide the pass phrase on
+# (`builtin' is an internal terminal dialog) has to provide the pass phrase on
 # stdout.
 SSLPassPhraseDialog  builtin
 

certbot-apache/tests/util.py

@@ -84,8 +84,7 @@ def get_apache_configurator(
         config_path, vhost_path,
         config_dir, work_dir, version=(2, 4, 7),
         os_info="generic",
-        conf_vhost_path=None,
-        use_parsernode=False):
+        conf_vhost_path=None):
     """Create an Apache Configurator with the specified options.
 
     :param conf: Function that returns binary paths. self.conf in Configurator
@@ -111,21 +110,19 @@ def get_apache_configurator(
             mock_exe_exists.return_value = True
             with mock.patch("certbot_apache._internal.parser.ApacheParser."
                             "update_runtime_variables"):
-                with mock.patch("certbot_apache._internal.apache_util.parse_from_subprocess") as mock_sp:
-                    mock_sp.return_value = []
-                    try:
-                        config_class = entrypoint.OVERRIDE_CLASSES[os_info]
-                    except KeyError:
-                        config_class = configurator.ApacheConfigurator
-                    config = config_class(config=mock_le_config, name="apache",
-                                          version=version, use_parsernode=use_parsernode)
-                    if not conf_vhost_path:
-                        config_class.OS_DEFAULTS["vhost_root"] = vhost_path
-                    else:
-                        # Custom virtualhost path was requested
-                        config.config.apache_vhost_root = conf_vhost_path
-                    config.config.apache_ctl = config_class.OS_DEFAULTS["ctl"]
-                    config.prepare()
+                try:
+                    config_class = entrypoint.OVERRIDE_CLASSES[os_info]
+                except KeyError:
+                    config_class = configurator.ApacheConfigurator
+                config = config_class(config=mock_le_config, name="apache",
+                    version=version)
+                if not conf_vhost_path:
+                    config_class.OS_DEFAULTS["vhost_root"] = vhost_path
+                else:
+                    # Custom virtualhost path was requested
+                    config.config.apache_vhost_root = conf_vhost_path
+                config.config.apache_ctl = config_class.OS_DEFAULTS["ctl"]
+                config.prepare()
     return config
 
 

certbot-auto

@@ -31,7 +31,7 @@ if [ -z "$VENV_PATH" ]; then
 fi
 VENV_BIN="$VENV_PATH/bin"
 BOOTSTRAP_VERSION_PATH="$VENV_PATH/certbot-auto-bootstrap-version.txt"
-LE_AUTO_VERSION="1.0.0"
+LE_AUTO_VERSION="1.1.0"
 BASENAME=$(basename $0)
 USAGE="Usage: $BASENAME [OPTIONS]
 A self-updating wrapper script for the Certbot ACME client. When run, updates
@@ -256,20 +256,28 @@ DeprecationBootstrap() {
   fi
 }
 
-MIN_PYTHON_VERSION="2.7"
-MIN_PYVER=$(echo "$MIN_PYTHON_VERSION" | sed 's/\.//')
+MIN_PYTHON_2_VERSION="2.7"
+MIN_PYVER2=$(echo "$MIN_PYTHON_2_VERSION" | sed 's/\.//')
+MIN_PYTHON_3_VERSION="3.5"
+MIN_PYVER3=$(echo "$MIN_PYTHON_3_VERSION" | sed 's/\.//')
 # Sets LE_PYTHON to Python version string and PYVER to the first two
-# digits of the python version
+# digits of the python version.
+# MIN_PYVER and MIN_PYTHON_VERSION are also set by this function, and their
+# values depend on if we try to use Python 3 or Python 2.
 DeterminePythonVersion() {
   # Arguments: "NOCRASH" if we shouldn't crash if we don't find a good python
   #
   # If no Python is found, PYVER is set to 0.
   if [ "$USE_PYTHON_3" = 1 ]; then
+    MIN_PYVER=$MIN_PYVER3
+    MIN_PYTHON_VERSION=$MIN_PYTHON_3_VERSION
     for LE_PYTHON in "$LE_PYTHON" python3; do
       # Break (while keeping the LE_PYTHON value) if found.
       $EXISTS "$LE_PYTHON" > /dev/null && break
     done
   else
+    MIN_PYVER=$MIN_PYVER2
+    MIN_PYTHON_VERSION=$MIN_PYTHON_2_VERSION
     for LE_PYTHON in "$LE_PYTHON" python2.7 python27 python2 python; do
       # Break (while keeping the LE_PYTHON value) if found.
       $EXISTS "$LE_PYTHON" > /dev/null && break
@@ -285,7 +293,7 @@ DeterminePythonVersion() {
     fi
   fi
 
-  PYVER=`"$LE_PYTHON" -V 2>&1 | cut -d" " -f 2 | cut -d. -f1,2 | sed 's/\.//'`
+  PYVER=$("$LE_PYTHON" -V 2>&1 | cut -d" " -f 2 | cut -d. -f1,2 | sed 's/\.//')
   if [ "$PYVER" -lt "$MIN_PYVER" ]; then
     if [ "$1" != "NOCRASH" ]; then
       error "You have an ancient version of Python entombed in your operating system..."
@@ -368,7 +376,9 @@ BootstrapDebCommon() {
 
 # Sets TOOL to the name of the package manager
 # Sets appropriate values for YES_FLAG and QUIET_FLAG based on $ASSUME_YES and $QUIET_FLAG.
-# Enables EPEL if applicable and possible.
+# Note: this function is called both while selecting the bootstrap scripts and
+# during the actual bootstrap. Some things like prompting to user can be done in the latter
+# case, but not in the former one.
 InitializeRPMCommonBase() {
   if type dnf 2>/dev/null
   then
@@ -388,26 +398,6 @@ InitializeRPMCommonBase() {
   if [ "$QUIET" = 1 ]; then
     QUIET_FLAG='--quiet'
   fi
-
-  if ! $TOOL list *virtualenv >/dev/null 2>&1; then
-    echo "To use Certbot, packages from the EPEL repository need to be installed."
-    if ! $TOOL list epel-release >/dev/null 2>&1; then
-      error "Enable the EPEL repository and try running Certbot again."
-      exit 1
-    fi
-    if [ "$ASSUME_YES" = 1 ]; then
-      /bin/echo -n "Enabling the EPEL repository in 3 seconds..."
-      sleep 1s
-      /bin/echo -ne "\e[0K\rEnabling the EPEL repository in 2 seconds..."
-      sleep 1s
-      /bin/echo -e "\e[0K\rEnabling the EPEL repository in 1 second..."
-      sleep 1s
-    fi
-    if ! $TOOL install $YES_FLAG $QUIET_FLAG epel-release; then
-      error "Could not enable EPEL. Aborting bootstrap!"
-      exit 1
-    fi
-  fi
 }
 
 BootstrapRpmCommonBase() {
@@ -488,13 +478,91 @@ BootstrapRpmCommon() {
   BootstrapRpmCommonBase "$python_pkgs"
 }
 
+# If new packages are installed by BootstrapRpmPython3 below, this version
+# number must be increased.
+BOOTSTRAP_RPM_PYTHON3_LEGACY_VERSION=1
+
+# Checks if rh-python36 can be installed.
+Python36SclIsAvailable() {
+  InitializeRPMCommonBase >/dev/null 2>&1;
+
+  if "${TOOL}" list rh-python36 >/dev/null 2>&1; then
+    return 0
+  fi
+  if "${TOOL}" list centos-release-scl >/dev/null 2>&1; then
+    return 0
+  fi
+  return 1
+}
+
+# Try to enable rh-python36 from SCL if it is necessary and possible.
+EnablePython36SCL() {
+  if "$EXISTS" python3.6 > /dev/null 2> /dev/null; then
+      return 0
+  fi
+  if [ ! -f /opt/rh/rh-python36/enable ]; then
+      return 0
+  fi
+  set +e
+  if ! . /opt/rh/rh-python36/enable; then
+    error 'Unable to enable rh-python36!'
+    exit 1
+  fi
+  set -e
+}
+
+# This bootstrap concerns old RedHat-based distributions that do not ship by default
+# with Python 2.7, but only Python 2.6. We bootstrap them by enabling SCL and installing
+# Python 3.6. Some of these distributions are: CentOS/RHEL/OL/SL 6.
+BootstrapRpmPython3Legacy() {
+  # Tested with:
+  #   - CentOS 6
+
+  InitializeRPMCommonBase
+
+  if ! "${TOOL}" list rh-python36 >/dev/null 2>&1; then
+    echo "To use Certbot on this operating system, packages from the SCL repository need to be installed."
+    if ! "${TOOL}" list centos-release-scl >/dev/null 2>&1; then
+      error "Enable the SCL repository and try running Certbot again."
+      exit 1
+    fi
+    if [ "${ASSUME_YES}" = 1 ]; then
+      /bin/echo -n "Enabling the SCL repository in 3 seconds... (Press Ctrl-C to cancel)"
+      sleep 1s
+      /bin/echo -ne "\e[0K\rEnabling the SCL repository in 2 seconds... (Press Ctrl-C to cancel)"
+      sleep 1s
+      /bin/echo -e "\e[0K\rEnabling the SCL repository in 1 second... (Press Ctrl-C to cancel)"
+      sleep 1s
+    fi
+    if ! "${TOOL}" install "${YES_FLAG}" "${QUIET_FLAG}" centos-release-scl; then
+      error "Could not enable SCL. Aborting bootstrap!"
+      exit 1
+    fi
+  fi
+
+  # CentOS 6 must use rh-python36 from SCL
+  if "${TOOL}" list rh-python36 >/dev/null 2>&1; then
+    python_pkgs="rh-python36-python
+      rh-python36-python-virtualenv
+      rh-python36-python-devel
+    "
+  else
+    error "No supported Python package available to install. Aborting bootstrap!"
+    exit 1
+  fi
+
+  BootstrapRpmCommonBase "${python_pkgs}"
+
+  # Enable SCL rh-python36 after bootstrapping.
+  EnablePython36SCL
+}
+
 # If new packages are installed by BootstrapRpmPython3 below, this version
 # number must be increased.
 BOOTSTRAP_RPM_PYTHON3_VERSION=1
 
 BootstrapRpmPython3() {
   # Tested with:
-  #   - CentOS 6
   #   - Fedora 29
 
   InitializeRPMCommonBase
@@ -505,12 +573,6 @@ BootstrapRpmPython3() {
       python3-virtualenv
       python3-devel
     "
-  # EPEL uses python34
-  elif $TOOL list python34 >/dev/null 2>&1; then
-    python_pkgs="python34
-      python34-devel
-      python34-tools
-    "
   else
     error "No supported Python package available to install. Aborting bootstrap!"
     exit 1
@@ -758,6 +820,11 @@ elif [ -f /etc/redhat-release ]; then
 
   RPM_DIST_NAME=`(. /etc/os-release 2> /dev/null && echo $ID) || echo "unknown"`
 
+  if [ "$PYVER" -eq 26 -a $(uname -m) != 'x86_64' ]; then
+    # 32 bits CentOS 6 and affiliates are not supported anymore by certbot-auto.
+    DEPRECATED_OS=1
+  fi
+
   # Set RPM_DIST_VERSION to VERSION_ID from /etc/os-release after splitting on
   # '.' characters (e.g. "8.0" becomes "8"). If the command exits with an
   # error, RPM_DIST_VERSION is set to "unknown".
@@ -769,31 +836,50 @@ elif [ -f /etc/redhat-release ]; then
      RPM_DIST_VERSION=0
   fi
 
-  # Starting to Fedora 29, python2 is on a deprecation path. Let's move to python3 then.
-  # RHEL 8 also uses python3 by default.
-  if [ "$RPM_DIST_NAME" = "fedora" -a "$RPM_DIST_VERSION" -ge 29 -o "$PYVER" -eq 26 ]; then
-    RPM_USE_PYTHON_3=1
-  elif [ "$RPM_DIST_NAME" = "rhel" -a "$RPM_DIST_VERSION" -ge 8 ]; then
-    RPM_USE_PYTHON_3=1
-  elif [ "$RPM_DIST_NAME" = "centos" -a "$RPM_DIST_VERSION" -ge 8 ]; then
-    RPM_USE_PYTHON_3=1
-  else
-    RPM_USE_PYTHON_3=0
-  fi
+  # Handle legacy RPM distributions
+  if [ "$PYVER" -eq 26 ]; then
+    # Check if an automated bootstrap can be achieved on this system.
+    if ! Python36SclIsAvailable; then
+      INTERACTIVE_BOOTSTRAP=1
+    fi
 
-  if [ "$RPM_USE_PYTHON_3" = 1 ]; then
     Bootstrap() {
-      BootstrapMessage "RedHat-based OSes that will use Python3"
-      BootstrapRpmPython3
+      BootstrapMessage "Legacy RedHat-based OSes that will use Python3"
+      BootstrapRpmPython3Legacy
     }
     USE_PYTHON_3=1
-    BOOTSTRAP_VERSION="BootstrapRpmPython3 $BOOTSTRAP_RPM_PYTHON3_VERSION"
+    BOOTSTRAP_VERSION="BootstrapRpmPython3Legacy $BOOTSTRAP_RPM_PYTHON3_LEGACY_VERSION"
+
+    # Try now to enable SCL rh-python36 for systems already bootstrapped
+    # NB: EnablePython36SCL has been defined along with BootstrapRpmPython3Legacy in certbot-auto
+    EnablePython36SCL
   else
-    Bootstrap() {
-      BootstrapMessage "RedHat-based OSes"
-      BootstrapRpmCommon
-    }
-    BOOTSTRAP_VERSION="BootstrapRpmCommon $BOOTSTRAP_RPM_COMMON_VERSION"
+    # Starting to Fedora 29, python2 is on a deprecation path. Let's move to python3 then.
+    # RHEL 8 also uses python3 by default.
+    if [ "$RPM_DIST_NAME" = "fedora" -a "$RPM_DIST_VERSION" -ge 29 ]; then
+      RPM_USE_PYTHON_3=1
+    elif [ "$RPM_DIST_NAME" = "rhel" -a "$RPM_DIST_VERSION" -ge 8 ]; then
+      RPM_USE_PYTHON_3=1
+    elif [ "$RPM_DIST_NAME" = "centos" -a "$RPM_DIST_VERSION" -ge 8 ]; then
+      RPM_USE_PYTHON_3=1
+    else
+      RPM_USE_PYTHON_3=0
+    fi
+
+    if [ "$RPM_USE_PYTHON_3" = 1 ]; then
+      Bootstrap() {
+        BootstrapMessage "RedHat-based OSes that will use Python3"
+        BootstrapRpmPython3
+      }
+      USE_PYTHON_3=1
+      BOOTSTRAP_VERSION="BootstrapRpmPython3 $BOOTSTRAP_RPM_PYTHON3_VERSION"
+    else
+      Bootstrap() {
+        BootstrapMessage "RedHat-based OSes"
+        BootstrapRpmCommon
+      }
+      BOOTSTRAP_VERSION="BootstrapRpmCommon $BOOTSTRAP_RPM_COMMON_VERSION"
+    fi
   fi
 
   LE_PYTHON="$prev_le_python"
@@ -870,6 +956,13 @@ if [ "$NO_BOOTSTRAP" = 1 ]; then
   unset BOOTSTRAP_VERSION
 fi
 
+if [ "$DEPRECATED_OS" = 1 ]; then
+  Bootstrap() {
+    error "Skipping bootstrap because certbot-auto is deprecated on this system."
+  }
+  unset BOOTSTRAP_VERSION
+fi
+
 # Sets PREV_BOOTSTRAP_VERSION to the identifier for the bootstrap script used
 # to install OS dependencies on this system. PREV_BOOTSTRAP_VERSION isn't set
 # if it is unknown how OS dependencies were installed on this system.
@@ -1067,6 +1160,28 @@ if [ "$1" = "--le-auto-phase2" ]; then
   # Phase 2: Create venv, install LE, and run.
 
   shift 1  # the --le-auto-phase2 arg
+
+  if [ "$DEPRECATED_OS" = 1 ]; then
+    # Phase 2 damage control mode for deprecated OSes.
+    # In this situation, we bypass any bootstrap or certbot venv setup.
+    error "Your system is not supported by certbot-auto anymore."
+
+    if [ ! -d "$VENV_PATH" ] && OldVenvExists; then
+      VENV_BIN="$OLD_VENV_PATH/bin"
+    fi
+
+    if [ -f "$VENV_BIN/letsencrypt" -a "$INSTALL_ONLY" != 1 ]; then
+      error "Certbot will no longer receive updates."
+      error "Please visit https://certbot.eff.org/ to check for other alternatives."
+      "$VENV_BIN/letsencrypt" "$@"
+      exit 0
+    else
+      error "Certbot cannot be installed."
+      error "Please visit https://certbot.eff.org/ to check for other alternatives."
+      exit 1
+    fi
+  fi
+
   SetPrevBootstrapVersion
 
   if [ -z "$PHASE_1_VERSION" -a "$USE_PYTHON_3" = 1 ]; then
@@ -1078,8 +1193,15 @@ if [ "$1" = "--le-auto-phase2" ]; then
     # If the selected Bootstrap function isn't a noop and it differs from the
     # previously used version
     if [ -n "$BOOTSTRAP_VERSION" -a "$BOOTSTRAP_VERSION" != "$PREV_BOOTSTRAP_VERSION" ]; then
-      # if non-interactive mode or stdin and stdout are connected to a terminal
-      if [ \( "$NONINTERACTIVE" = 1 \) -o \( \( -t 0 \) -a \( -t 1 \) \) ]; then
+      # Check if we can rebootstrap without manual user intervention: this requires that
+      # certbot-auto is in non-interactive mode AND selected bootstrap does not claim to
+      # require a manual user intervention.
+      if [ "$NONINTERACTIVE" = 1 -a "$INTERACTIVE_BOOTSTRAP" != 1 ]; then
+        CAN_REBOOTSTRAP=1
+      fi
+      # Check if rebootstrap can be done non-interactively and current shell is non-interactive
+      # (true if stdin and stdout are not attached to a terminal).
+      if [ \( "$CAN_REBOOTSTRAP" = 1 \) -o \( \( -t 0 \) -a \( -t 1 \) \) ]; then
         if [ -d "$VENV_PATH" ]; then
           rm -rf "$VENV_PATH"
         fi
@@ -1090,12 +1212,21 @@ if [ "$1" = "--le-auto-phase2" ]; then
           ln -s "$VENV_PATH" "$OLD_VENV_PATH"
         fi
         RerunWithArgs "$@"
+      # Otherwise bootstrap needs to be done manually by the user.
       else
-        error "Skipping upgrade because new OS dependencies may need to be installed."
-        error
-        error "To upgrade to a newer version, please run this script again manually so you can"
-        error "approve changes or with --non-interactive on the command line to automatically"
-        error "install any required packages."
+        # If it is because bootstrapping is interactive, --non-interactive will be of no use.
+        if [ "$INTERACTIVE_BOOTSTRAP" = 1 ]; then
+          error "Skipping upgrade because new OS dependencies may need to be installed."
+          error "This requires manual user intervention: please run this script again manually."
+        # If this is because of the environment (eg. non interactive shell without
+        # --non-interactive flag set), help the user in that direction.
+        else
+          error "Skipping upgrade because new OS dependencies may need to be installed."
+          error
+          error "To upgrade to a newer version, please run this script again manually so you can"
+          error "approve changes or with --non-interactive on the command line to automatically"
+          error "install any required packages."
+        fi
         # Set INSTALLED_VERSION to be the same so we don't update the venv
         INSTALLED_VERSION="$LE_AUTO_VERSION"
         # Continue to use OLD_VENV_PATH if the new venv doesn't exist
@@ -1372,18 +1503,18 @@ letsencrypt==0.7.0 \
     --hash=sha256:105a5fb107e45bcd0722eb89696986dcf5f08a86a321d6aef25a0c7c63375ade \
     --hash=sha256:c36e532c486a7e92155ee09da54b436a3c420813ec1c590b98f635d924720de9
 
-certbot==1.0.0 \
-    --hash=sha256:8d074cff89dee002dec1c47cb0da04ea8e0ede8d68838b6d54aa41580d9262df \
-    --hash=sha256:86b82d31db19fffffb0d6b218951e2121ef514e3ff659aa042deaf92a33e302a
-acme==1.0.0 \
-    --hash=sha256:f6972e436e76f7f1e395e81e149f8713ca8462d465b14993bddc53fb18a40644 \
-    --hash=sha256:6a08f12f848ce563b50bca421ba9db653df9f82cfefeaf8aba517f046d1386c2
-certbot-apache==1.0.0 \
-    --hash=sha256:e591d0cf773ad33ee978f7adb1b69288eac2c8847c643b06e70260e707626f8e \
-    --hash=sha256:7335ab5687a0a47d9041d9e13f3a2d67d0e8372da97ab639edb31c14b787cd68
-certbot-nginx==1.0.0 \
-    --hash=sha256:ce8a2e51165da7c15bfdc059cd6572d0f368c078f1e1a77633a2773310b2f231 \
-    --hash=sha256:63b4ae09d4f1c9ef0a1a2a49c3f651d8a7cb30303ec6f954239e987c5da45dc4
+certbot==1.1.0 \
+    --hash=sha256:66a5cab9267349941604c2c98082bfef85877653c023fc324b1c3869fb16add6 \
+    --hash=sha256:46e93661a0db53f416c0f5476d8d2e62bc7259b7660dd983453b85df9ef6e8b8
+acme==1.1.0 \
+    --hash=sha256:11b9beba706fb8f652c8910d46dd1939d670cac8169f3c66c18c080ed3353e71 \
+    --hash=sha256:c305a20eeb9cb02240347703d497891c13d43a47c794fa100d4dbb479a5370d9
+certbot-apache==1.1.0 \
+    --hash=sha256:9c847ff223c2e465e241c78d22f97cee77d5e551df608bed06c55f8627f4cbd2 \
+    --hash=sha256:05e84dfe96b72582cde97c490977d8e2d33d440c927a320debb4cf287f6fadcc
+certbot-nginx==1.1.0 \
+    --hash=sha256:bf06fa2f5059f0fdb7d352c8739e1ed0830db4f0d89e812dab4f081bda6ec7d6 \
+    --hash=sha256:0a80ecbd2a30f3757c7652cabfff854ca07873b1cf02ebbe1892786c3b3a5874
 
 UNLIKELY_EOF
     # -------------------------------------------------------------------------
@@ -1617,6 +1748,9 @@ UNLIKELY_EOF
     say "Installation succeeded."
   fi
 
+  # If you're modifying any of the code after this point in this current `if` block, you
+  # may need to update the "$DEPRECATED_OS" = 1 case at the beginning of phase 2 as well.
+
   if [ "$INSTALL_ONLY" = 1 ]; then
     say "Certbot is installed."
     exit 0
@@ -1828,30 +1962,35 @@ UNLIKELY_EOF
       error "WARNING: unable to check for updates."
     fi
 
-    LE_VERSION_STATE=`CompareVersions "$LE_PYTHON" "$LE_AUTO_VERSION" "$REMOTE_VERSION"`
-    if [ "$LE_VERSION_STATE" = "UNOFFICIAL" ]; then
-      say "Unofficial certbot-auto version detected, self-upgrade is disabled: $LE_AUTO_VERSION"
-    elif [ "$LE_VERSION_STATE" = "OUTDATED" ]; then
-      say "Upgrading certbot-auto $LE_AUTO_VERSION to $REMOTE_VERSION..."
+    # If for any reason REMOTE_VERSION is not set, let's assume certbot-auto is up-to-date,
+    # and do not go into the self-upgrading process.
+    if [ -n "$REMOTE_VERSION" ]; then
+      LE_VERSION_STATE=`CompareVersions "$LE_PYTHON" "$LE_AUTO_VERSION" "$REMOTE_VERSION"`
 
-      # Now we drop into Python so we don't have to install even more
-      # dependencies (curl, etc.), for better flow control, and for the option of
-      # future Windows compatibility.
-      "$LE_PYTHON" "$TEMP_DIR/fetch.py" --le-auto-script "v$REMOTE_VERSION"
+      if [ "$LE_VERSION_STATE" = "UNOFFICIAL" ]; then
+        say "Unofficial certbot-auto version detected, self-upgrade is disabled: $LE_AUTO_VERSION"
+      elif [ "$LE_VERSION_STATE" = "OUTDATED" ]; then
+        say "Upgrading certbot-auto $LE_AUTO_VERSION to $REMOTE_VERSION..."
 
-      # Install new copy of certbot-auto.
-      # TODO: Deal with quotes in pathnames.
-      say "Replacing certbot-auto..."
-      # Clone permissions with cp. chmod and chown don't have a --reference
-      # option on macOS or BSD, and stat -c on Linux is stat -f on macOS and BSD:
-      cp -p "$0" "$TEMP_DIR/letsencrypt-auto.permission-clone"
-      cp "$TEMP_DIR/letsencrypt-auto" "$TEMP_DIR/letsencrypt-auto.permission-clone"
-      # Using mv rather than cp leaves the old file descriptor pointing to the
-      # original copy so the shell can continue to read it unmolested. mv across
-      # filesystems is non-atomic, doing `rm dest, cp src dest, rm src`, but the
-      # cp is unlikely to fail if the rm doesn't.
-      mv -f "$TEMP_DIR/letsencrypt-auto.permission-clone" "$0"
-    fi  # A newer version is available.
+        # Now we drop into Python so we don't have to install even more
+        # dependencies (curl, etc.), for better flow control, and for the option of
+        # future Windows compatibility.
+        "$LE_PYTHON" "$TEMP_DIR/fetch.py" --le-auto-script "v$REMOTE_VERSION"
+
+        # Install new copy of certbot-auto.
+        # TODO: Deal with quotes in pathnames.
+        say "Replacing certbot-auto..."
+        # Clone permissions with cp. chmod and chown don't have a --reference
+        # option on macOS or BSD, and stat -c on Linux is stat -f on macOS and BSD:
+        cp -p "$0" "$TEMP_DIR/letsencrypt-auto.permission-clone"
+        cp "$TEMP_DIR/letsencrypt-auto" "$TEMP_DIR/letsencrypt-auto.permission-clone"
+        # Using mv rather than cp leaves the old file descriptor pointing to the
+        # original copy so the shell can continue to read it unmolested. mv across
+        # filesystems is non-atomic, doing `rm dest, cp src dest, rm src`, but the
+        # cp is unlikely to fail if the rm doesn't.
+        mv -f "$TEMP_DIR/letsencrypt-auto.permission-clone" "$0"
+      fi  # A newer version is available.
+    fi
   fi  # Self-upgrading is allowed.
 
   RerunWithArgs --le-auto-phase2 "$@"

certbot-ci/certbot_integration_tests/conftest.py

@@ -62,7 +62,7 @@ def _setup_primary_node(config):
     """
     Setup the environment for integration tests.
     Will:
-        - check runtime compatiblity (Docker, docker-compose, Nginx)
+        - check runtime compatibility (Docker, docker-compose, Nginx)
         - create a temporary workspace and the persistent GIT repositories space
         - configure and start paralleled ACME CA servers using Docker
         - transfer ACME CA servers configurations to pytest nodes using env variables

certbot-ci/certbot_integration_tests/utils/acme_server.py

@@ -189,7 +189,7 @@ class ACMEServer(object):
         print('=> Finished configuring the HTTP proxy.')
 
     def _launch_process(self, command, cwd=os.getcwd(), env=None):
-        """Launch silently an subprocess OS command"""
+        """Launch silently a subprocess OS command"""
         if not env:
             env = os.environ
         process = subprocess.Popen(command, stdout=self._stdout, stderr=subprocess.STDOUT, cwd=cwd, env=env)

certbot-compatibility-test/certbot_compatibility_test/validator_test.py

@@ -39,7 +39,7 @@ class ValidatorTest(unittest.TestCase):
             cert, "test.com", "127.0.0.1"))
 
     @mock.patch("certbot_compatibility_test.validator.requests.get")
-    def test_succesful_redirect(self, mock_get_request):
+    def test_successful_redirect(self, mock_get_request):
         mock_get_request.return_value = create_response(
             301, {"location": "https://test.com"})
         self.assertTrue(self.validator.redirect("test.com"))

certbot-compatibility-test/setup.py

@@ -3,7 +3,7 @@ import sys
 from setuptools import find_packages
 from setuptools import setup
 
-version = '1.1.0.dev0'
+version = '1.2.0.dev0'
 
 install_requires = [
     'certbot',

certbot-dns-cloudflare/docs/conf.py

@@ -38,7 +38,7 @@ extensions = ['sphinx.ext.autodoc',
     'sphinx.ext.viewcode']
 
 autodoc_member_order = 'bysource'
-autodoc_default_flags = ['show-inheritance', 'private-members']
+autodoc_default_flags = ['show-inheritance']
 
 # Add any paths that contain templates here, relative to this directory.
 templates_path = ['_templates']

certbot-dns-cloudflare/local-oldest-requirements.txt

@@ -1,3 +1,3 @@
 # Remember to update setup.py to match the package versions below.
 acme[dev]==0.29.0
--e certbot[dev]
+certbot[dev]==1.1.0

certbot-dns-cloudflare/setup.py

@@ -4,13 +4,13 @@ from setuptools import find_packages
 from setuptools import setup
 from setuptools.command.test import test as TestCommand
 
-version = '1.1.0.dev0'
+version = '1.2.0.dev0'
 
 # Remember to update local-oldest-requirements.txt when changing the minimum
 # acme/certbot version.
 install_requires = [
     'acme>=0.29.0',
-    'certbot>=1.0.0.dev0',
+    'certbot>=1.1.0',
     'cloudflare>=1.5.1',
     'mock',
     'setuptools',

certbot-dns-cloudxns/docs/conf.py

@@ -38,7 +38,7 @@ extensions = ['sphinx.ext.autodoc',
     'sphinx.ext.viewcode']
 
 autodoc_member_order = 'bysource'
-autodoc_default_flags = ['show-inheritance', 'private-members']
+autodoc_default_flags = ['show-inheritance']
 
 # Add any paths that contain templates here, relative to this directory.
 templates_path = ['_templates']

certbot-dns-cloudxns/local-oldest-requirements.txt

@@ -1,3 +1,3 @@
 # Remember to update setup.py to match the package versions below.
 acme[dev]==0.31.0
--e certbot[dev]
+certbot[dev]==1.1.0

certbot-dns-cloudxns/setup.py

@@ -4,13 +4,13 @@ from setuptools import find_packages
 from setuptools import setup
 from setuptools.command.test import test as TestCommand
 
-version = '1.1.0.dev0'
+version = '1.2.0.dev0'
 
 # Remember to update local-oldest-requirements.txt when changing the minimum
 # acme/certbot version.
 install_requires = [
     'acme>=0.31.0',
-    'certbot>=1.0.0.dev0',
+    'certbot>=1.1.0',
     'dns-lexicon>=2.2.1',  # Support for >1 TXT record per name
     'mock',
     'setuptools',

certbot-dns-digitalocean/docs/conf.py

@@ -38,7 +38,7 @@ extensions = ['sphinx.ext.autodoc',
     'sphinx.ext.viewcode']
 
 autodoc_member_order = 'bysource'
-autodoc_default_flags = ['show-inheritance', 'private-members']
+autodoc_default_flags = ['show-inheritance']
 
 # Add any paths that contain templates here, relative to this directory.
 templates_path = ['_templates']

certbot-dns-digitalocean/local-oldest-requirements.txt

@@ -1,3 +1,3 @@
 # Remember to update setup.py to match the package versions below.
 acme[dev]==0.29.0
--e certbot[dev]
+certbot[dev]==1.1.0

certbot-dns-digitalocean/setup.py

@@ -4,13 +4,13 @@ from setuptools import find_packages
 from setuptools import setup
 from setuptools.command.test import test as TestCommand
 
-version = '1.1.0.dev0'
+version = '1.2.0.dev0'
 
 # Remember to update local-oldest-requirements.txt when changing the minimum
 # acme/certbot version.
 install_requires = [
     'acme>=0.29.0',
-    'certbot>=1.0.0.dev0',
+    'certbot>=1.1.0',
     'mock',
     'python-digitalocean>=1.11',
     'setuptools',

certbot-dns-dnsimple/docs/conf.py

@@ -38,7 +38,7 @@ extensions = ['sphinx.ext.autodoc',
     'sphinx.ext.viewcode']
 
 autodoc_member_order = 'bysource'
-autodoc_default_flags = ['show-inheritance', 'private-members']
+autodoc_default_flags = ['show-inheritance']
 
 # Add any paths that contain templates here, relative to this directory.
 templates_path = ['_templates']

certbot-dns-dnsimple/local-oldest-requirements.txt

@@ -1,3 +1,3 @@
 # Remember to update setup.py to match the package versions below.
 acme[dev]==0.31.0
--e certbot[dev]
+certbot[dev]==1.1.0

certbot-dns-dnsimple/setup.py

@@ -5,13 +5,13 @@ from setuptools import find_packages
 from setuptools import setup
 from setuptools.command.test import test as TestCommand
 
-version = '1.1.0.dev0'
+version = '1.2.0.dev0'
 
 # Remember to update local-oldest-requirements.txt when changing the minimum
 # acme/certbot version.
 install_requires = [
     'acme>=0.31.0',
-    'certbot>=1.0.0.dev0',
+    'certbot>=1.1.0',
     'mock',
     'setuptools',
     'zope.interface',

certbot-dns-dnsmadeeasy/docs/conf.py

@@ -38,7 +38,7 @@ extensions = ['sphinx.ext.autodoc',
     'sphinx.ext.viewcode']
 
 autodoc_member_order = 'bysource'
-autodoc_default_flags = ['show-inheritance', 'private-members']
+autodoc_default_flags = ['show-inheritance']
 
 # Add any paths that contain templates here, relative to this directory.
 templates_path = ['_templates']

certbot-dns-dnsmadeeasy/local-oldest-requirements.txt

@@ -1,3 +1,3 @@
 # Remember to update setup.py to match the package versions below.
 acme[dev]==0.31.0
--e certbot[dev]
+certbot[dev]==1.1.0

certbot-dns-dnsmadeeasy/setup.py

@@ -4,13 +4,13 @@ from setuptools import find_packages
 from setuptools import setup
 from setuptools.command.test import test as TestCommand
 
-version = '1.1.0.dev0'
+version = '1.2.0.dev0'
 
 # Remember to update local-oldest-requirements.txt when changing the minimum
 # acme/certbot version.
 install_requires = [
     'acme>=0.31.0',
-    'certbot>=1.0.0.dev0',
+    'certbot>=1.1.0',
     'dns-lexicon>=2.2.1',  # Support for >1 TXT record per name
     'mock',
     'setuptools',

certbot-dns-gehirn/README.rst

@@ -1 +1 @@
-Gehirn Infrastracture Service DNS Authenticator plugin for Certbot
+Gehirn Infrastructure Service DNS Authenticator plugin for Certbot

certbot-dns-gehirn/certbot_dns_gehirn/__init__.py

@@ -1,14 +1,14 @@
 """
 The `~certbot_dns_gehirn.dns_gehirn` plugin automates the process of completing
 a ``dns-01`` challenge (`~acme.challenges.DNS01`) by creating, and subsequently
-removing, TXT records using the Gehirn Infrastracture Service DNS API.
+removing, TXT records using the Gehirn Infrastructure Service DNS API.
 
 
 Named Arguments
 ---------------
 
 ========================================  =====================================
-``--dns-gehirn-credentials``              Gehirn Infrastracture Service
+``--dns-gehirn-credentials``              Gehirn Infrastructure Service
                                           credentials_ INI file.
                                           (Required)
 ``--dns-gehirn-propagation-seconds``      The number of seconds to wait for DNS
@@ -22,15 +22,15 @@ Credentials
 -----------
 
 Use of this plugin requires a configuration file containing
-Gehirn Infrastracture Service DNS API credentials,
-obtained from your Gehirn Infrastracture Service
+Gehirn Infrastructure Service DNS API credentials,
+obtained from your Gehirn Infrastructure Service
 `dashboard <https://gis.gehirn.jp/>`_.
 
 .. code-block:: ini
    :name: credentials.ini
    :caption: Example credentials file:
 
-   # Gehirn Infrastracture Service API credentials used by Certbot
+   # Gehirn Infrastructure Service API credentials used by Certbot
    dns_gehirn_api_token  = 00000000-0000-0000-0000-000000000000
    dns_gehirn_api_secret = MDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAw
 
@@ -40,7 +40,7 @@ to this file for use during renewal, but does not store the file's contents.
 
 .. caution::
    You should protect these API credentials as you would the password to your
-   Gehirn Infrastracture Service account. Users who can read this file can use
+   Gehirn Infrastructure Service account. Users who can read this file can use
    these credentials to issue arbitrary API calls on your behalf. Users who can
    cause Certbot to run using these credentials can complete a ``dns-01``
    challenge to acquire new certificates or revoke existing certificates for

certbot-dns-gehirn/certbot_dns_gehirn/_internal/dns_gehirn.py

@@ -1,4 +1,4 @@
-"""DNS Authenticator for Gehirn Infrastracture Service DNS."""
+"""DNS Authenticator for Gehirn Infrastructure Service DNS."""
 import logging
 
 from lexicon.providers import gehirn
@@ -15,14 +15,14 @@ DASHBOARD_URL = "https://gis.gehirn.jp/"
 @zope.interface.implementer(interfaces.IAuthenticator)
 @zope.interface.provider(interfaces.IPluginFactory)
 class Authenticator(dns_common.DNSAuthenticator):
-    """DNS Authenticator for Gehirn Infrastracture Service DNS
+    """DNS Authenticator for Gehirn Infrastructure Service DNS
 
-    This Authenticator uses the Gehirn Infrastracture Service API to fulfill
+    This Authenticator uses the Gehirn Infrastructure Service API to fulfill
     a dns-01 challenge.
     """
 
     description = 'Obtain certificates using a DNS TXT record ' + \
-                  '(if you are using Gehirn Infrastracture Service for DNS).'
+                  '(if you are using Gehirn Infrastructure Service for DNS).'
     ttl = 60
 
     def __init__(self, *args, **kwargs):
@@ -32,20 +32,20 @@ class Authenticator(dns_common.DNSAuthenticator):
     @classmethod
     def add_parser_arguments(cls, add):  # pylint: disable=arguments-differ
         super(Authenticator, cls).add_parser_arguments(add, default_propagation_seconds=30)
-        add('credentials', help='Gehirn Infrastracture Service credentials file.')
+        add('credentials', help='Gehirn Infrastructure Service credentials file.')
 
     def more_info(self):  # pylint: disable=missing-docstring,no-self-use
         return 'This plugin configures a DNS TXT record to respond to a dns-01 challenge using ' + \
-               'the Gehirn Infrastracture Service API.'
+               'the Gehirn Infrastructure Service API.'
 
     def _setup_credentials(self):
         self.credentials = self._configure_credentials(
             'credentials',
-            'Gehirn Infrastracture Service credentials file',
+            'Gehirn Infrastructure Service credentials file',
             {
-                'api-token': 'API token for Gehirn Infrastracture Service ' + \
+                'api-token': 'API token for Gehirn Infrastructure Service ' + \
                              'API obtained from {0}'.format(DASHBOARD_URL),
-                'api-secret': 'API secret for Gehirn Infrastracture Service ' + \
+                'api-secret': 'API secret for Gehirn Infrastructure Service ' + \
                               'API obtained from {0}'.format(DASHBOARD_URL),
             }
         )
@@ -66,7 +66,7 @@ class Authenticator(dns_common.DNSAuthenticator):
 
 class _GehirnLexiconClient(dns_common_lexicon.LexiconClient):
     """
-    Encapsulates all communication with the Gehirn Infrastracture Service via Lexicon.
+    Encapsulates all communication with the Gehirn Infrastructure Service via Lexicon.
     """
 
     def __init__(self, api_token, api_secret, ttl):

certbot-dns-gehirn/docs/conf.py

@@ -38,7 +38,7 @@ extensions = ['sphinx.ext.autodoc',
     'sphinx.ext.viewcode']
 
 autodoc_member_order = 'bysource'
-autodoc_default_flags = ['show-inheritance', 'private-members']
+autodoc_default_flags = ['show-inheritance']
 
 # Add any paths that contain templates here, relative to this directory.
 templates_path = ['_templates']

certbot-dns-gehirn/local-oldest-requirements.txt

@@ -1,3 +1,3 @@
 # Remember to update setup.py to match the package versions below.
 acme[dev]==0.31.0
--e certbot[dev]
+certbot[dev]==1.1.0

certbot-dns-gehirn/setup.py

@@ -4,12 +4,12 @@ from setuptools import find_packages
 from setuptools import setup
 from setuptools.command.test import test as TestCommand
 
-version = '1.1.0.dev0'
+version = '1.2.0.dev0'
 
 # Please update tox.ini when modifying dependency version requirements
 install_requires = [
     'acme>=0.31.0',
-    'certbot>=1.0.0.dev0',
+    'certbot>=1.1.0',
     'dns-lexicon>=2.1.22',
     'mock',
     'setuptools',
@@ -38,7 +38,7 @@ class PyTest(TestCommand):
 setup(
     name='certbot-dns-gehirn',
     version=version,
-    description="Gehirn Infrastracture Service DNS Authenticator plugin for Certbot",
+    description="Gehirn Infrastructure Service DNS Authenticator plugin for Certbot",
     url='https://github.com/certbot/certbot',
     author="Certbot Project",
     author_email='client-dev@letsencrypt.org',

certbot-dns-google/docs/conf.py

@@ -39,7 +39,7 @@ extensions = ['sphinx.ext.autodoc',
     'jsonlexer']
 
 autodoc_member_order = 'bysource'
-autodoc_default_flags = ['show-inheritance', 'private-members']
+autodoc_default_flags = ['show-inheritance']
 
 # Add any paths that contain templates here, relative to this directory.
 templates_path = ['_templates']

certbot-dns-google/local-oldest-requirements.txt

@@ -1,3 +1,3 @@
 # Remember to update setup.py to match the package versions below.
 acme[dev]==0.29.0
--e certbot[dev]
+certbot[dev]==1.1.0

certbot-dns-google/setup.py

@@ -4,13 +4,13 @@ from setuptools import find_packages
 from setuptools import setup
 from setuptools.command.test import test as TestCommand
 
-version = '1.1.0.dev0'
+version = '1.2.0.dev0'
 
 # Remember to update local-oldest-requirements.txt when changing the minimum
 # acme/certbot version.
 install_requires = [
     'acme>=0.29.0',
-    'certbot>=1.0.0.dev0',
+    'certbot>=1.1.0',
     'google-api-python-client>=1.5.5',
     'mock',
     'oauth2client>=4.0',

certbot-dns-linode/docs/conf.py

@@ -38,7 +38,7 @@ extensions = ['sphinx.ext.autodoc',
     'sphinx.ext.viewcode']
 
 autodoc_member_order = 'bysource'
-autodoc_default_flags = ['show-inheritance', 'private-members']
+autodoc_default_flags = ['show-inheritance']
 
 # Add any paths that contain templates here, relative to this directory.
 templates_path = ['_templates']

certbot-dns-linode/local-oldest-requirements.txt

@@ -1,4 +1,4 @@
 # Remember to update setup.py to match the package versions below.
 acme[dev]==0.31.0
--e certbot[dev]
+certbot[dev]==1.1.0
 dns-lexicon==2.2.3

certbot-dns-linode/setup.py

@@ -4,12 +4,12 @@ from setuptools import find_packages
 from setuptools import setup
 from setuptools.command.test import test as TestCommand
 
-version = '1.1.0.dev0'
+version = '1.2.0.dev0'
 
 # Please update tox.ini when modifying dependency version requirements
 install_requires = [
     'acme>=0.31.0',
-    'certbot>=1.0.0.dev0',
+    'certbot>=1.1.0',
     'dns-lexicon>=2.2.3',
     'mock',
     'setuptools',

certbot-dns-luadns/docs/conf.py

@@ -38,7 +38,7 @@ extensions = ['sphinx.ext.autodoc',
     'sphinx.ext.viewcode']
 
 autodoc_member_order = 'bysource'
-autodoc_default_flags = ['show-inheritance', 'private-members']
+autodoc_default_flags = ['show-inheritance']
 
 # Add any paths that contain templates here, relative to this directory.
 templates_path = ['_templates']

certbot-dns-luadns/local-oldest-requirements.txt

@@ -1,3 +1,3 @@
 # Remember to update setup.py to match the package versions below.
 acme[dev]==0.31.0
--e certbot[dev]
+certbot[dev]==1.1.0

certbot-dns-luadns/setup.py

@@ -4,13 +4,13 @@ from setuptools import find_packages
 from setuptools import setup
 from setuptools.command.test import test as TestCommand
 
-version = '1.1.0.dev0'
+version = '1.2.0.dev0'
 
 # Remember to update local-oldest-requirements.txt when changing the minimum
 # acme/certbot version.
 install_requires = [
     'acme>=0.31.0',
-    'certbot>=1.0.0.dev0',
+    'certbot>=1.1.0',
     'dns-lexicon>=2.2.1',  # Support for >1 TXT record per name
     'mock',
     'setuptools',

certbot-dns-nsone/docs/conf.py

@@ -38,7 +38,7 @@ extensions = ['sphinx.ext.autodoc',
     'sphinx.ext.viewcode']
 
 autodoc_member_order = 'bysource'
-autodoc_default_flags = ['show-inheritance', 'private-members']
+autodoc_default_flags = ['show-inheritance']
 
 # Add any paths that contain templates here, relative to this directory.
 templates_path = ['_templates']

certbot-dns-nsone/local-oldest-requirements.txt

@@ -1,3 +1,3 @@
 # Remember to update setup.py to match the package versions below.
 acme[dev]==0.31.0
--e certbot[dev]
+certbot[dev]==1.1.0

certbot-dns-nsone/setup.py

@@ -4,13 +4,13 @@ from setuptools import find_packages
 from setuptools import setup
 from setuptools.command.test import test as TestCommand
 
-version = '1.1.0.dev0'
+version = '1.2.0.dev0'
 
 # Remember to update local-oldest-requirements.txt when changing the minimum
 # acme/certbot version.
 install_requires = [
     'acme>=0.31.0',
-    'certbot>=1.0.0.dev0',
+    'certbot>=1.1.0',
     'dns-lexicon>=2.2.1',  # Support for >1 TXT record per name
     'mock',
     'setuptools',

certbot-dns-ovh/docs/conf.py

@@ -38,7 +38,7 @@ extensions = ['sphinx.ext.autodoc',
     'sphinx.ext.viewcode']
 
 autodoc_member_order = 'bysource'
-autodoc_default_flags = ['show-inheritance', 'private-members']
+autodoc_default_flags = ['show-inheritance']
 
 # Add any paths that contain templates here, relative to this directory.
 templates_path = ['_templates']

certbot-dns-ovh/local-oldest-requirements.txt

@@ -1,4 +1,4 @@
 # Remember to update setup.py to match the package versions below.
 acme[dev]==0.31.0
--e certbot[dev]
+certbot[dev]==1.1.0
 dns-lexicon==2.7.14

certbot-dns-ovh/setup.py

@@ -4,13 +4,13 @@ from setuptools import find_packages
 from setuptools import setup
 from setuptools.command.test import test as TestCommand
 
-version = '1.1.0.dev0'
+version = '1.2.0.dev0'
 
 # Remember to update local-oldest-requirements.txt when changing the minimum
 # acme/certbot version.
 install_requires = [
     'acme>=0.31.0',
-    'certbot>=1.0.0.dev0',
+    'certbot>=1.1.0',
     'dns-lexicon>=2.7.14',  # Correct proxy use on OVH provider
     'mock',
     'setuptools',

certbot-dns-rfc2136/certbot_dns_rfc2136/_internal/dns_rfc2136.py

@@ -129,7 +129,7 @@ class _RFC2136Client(object):
         rcode = response.rcode()
 
         if rcode == dns.rcode.NOERROR:
-            logger.debug('Successfully added TXT record')
+            logger.debug('Successfully added TXT record %s', record_name)
         else:
             raise errors.PluginError('Received response from server: {0}'
                                      .format(dns.rcode.to_text(rcode)))
@@ -164,7 +164,7 @@ class _RFC2136Client(object):
         rcode = response.rcode()
 
         if rcode == dns.rcode.NOERROR:
-            logger.debug('Successfully deleted TXT record')
+            logger.debug('Successfully deleted TXT record %s', record_name)
         else:
             raise errors.PluginError('Received response from server: {0}'
                                      .format(dns.rcode.to_text(rcode)))

certbot-dns-rfc2136/docs/conf.py

@@ -38,7 +38,7 @@ extensions = ['sphinx.ext.autodoc',
     'sphinx.ext.viewcode']
 
 autodoc_member_order = 'bysource'
-autodoc_default_flags = ['show-inheritance', 'private-members']
+autodoc_default_flags = ['show-inheritance']
 
 # Add any paths that contain templates here, relative to this directory.
 templates_path = ['_templates']

certbot-dns-rfc2136/local-oldest-requirements.txt

@@ -1,3 +1,3 @@
 # Remember to update setup.py to match the package versions below.
 acme[dev]==0.29.0
--e certbot[dev]
+certbot[dev]==1.1.0

certbot-dns-rfc2136/setup.py

@@ -4,13 +4,13 @@ from setuptools import find_packages
 from setuptools import setup
 from setuptools.command.test import test as TestCommand
 
-version = '1.1.0.dev0'
+version = '1.2.0.dev0'
 
 # Remember to update local-oldest-requirements.txt when changing the minimum
 # acme/certbot version.
 install_requires = [
     'acme>=0.29.0',
-    'certbot>=1.0.0.dev0',
+    'certbot>=1.1.0',
     'dnspython',
     'mock',
     'setuptools',

certbot-dns-route53/docs/conf.py

@@ -38,7 +38,7 @@ extensions = ['sphinx.ext.autodoc',
     'sphinx.ext.viewcode']
 
 autodoc_member_order = 'bysource'
-autodoc_default_flags = ['show-inheritance', 'private-members']
+autodoc_default_flags = ['show-inheritance']
 
 # Add any paths that contain templates here, relative to this directory.
 templates_path = ['_templates']

certbot-dns-route53/local-oldest-requirements.txt

@@ -1,3 +1,3 @@
 # Remember to update setup.py to match the package versions below.
 acme[dev]==0.29.0
--e certbot[dev]
+certbot[dev]==1.1.0

certbot-dns-route53/setup.py

@@ -4,13 +4,13 @@ from setuptools import find_packages
 from setuptools import setup
 from setuptools.command.test import test as TestCommand
 
-version = '1.1.0.dev0'
+version = '1.2.0.dev0'
 
 # Remember to update local-oldest-requirements.txt when changing the minimum
 # acme/certbot version.
 install_requires = [
     'acme>=0.29.0',
-    'certbot>=1.0.0.dev0',
+    'certbot>=1.1.0',
     'boto3',
     'mock',
     'setuptools',

certbot-dns-sakuracloud/docs/conf.py

@@ -38,7 +38,7 @@ extensions = ['sphinx.ext.autodoc',
     'sphinx.ext.viewcode']
 
 autodoc_member_order = 'bysource'
-autodoc_default_flags = ['show-inheritance', 'private-members']
+autodoc_default_flags = ['show-inheritance']
 
 # Add any paths that contain templates here, relative to this directory.
 templates_path = ['_templates']

certbot-dns-sakuracloud/local-oldest-requirements.txt

@@ -1,3 +1,3 @@
 # Remember to update setup.py to match the package versions below.
 acme[dev]==0.31.0
--e certbot[dev]
+certbot[dev]==1.1.0

certbot-dns-sakuracloud/setup.py

@@ -4,12 +4,12 @@ from setuptools import find_packages
 from setuptools import setup
 from setuptools.command.test import test as TestCommand
 
-version = '1.1.0.dev0'
+version = '1.2.0.dev0'
 
 # Please update tox.ini when modifying dependency version requirements
 install_requires = [
     'acme>=0.31.0',
-    'certbot>=1.0.0.dev0',
+    'certbot>=1.1.0',
     'dns-lexicon>=2.1.23',
     'mock',
     'setuptools',

certbot-nginx/local-oldest-requirements.txt

@@ -1,3 +1,3 @@
 # Remember to update setup.py to match the package versions below.
 acme[dev]==1.0.0
--e certbot[dev]
+certbot[dev]==1.1.0

certbot-nginx/setup.py

@@ -4,13 +4,13 @@ from setuptools import find_packages
 from setuptools import setup
 from setuptools.command.test import test as TestCommand
 
-version = '1.1.0.dev0'
+version = '1.2.0.dev0'
 
 # Remember to update local-oldest-requirements.txt when changing the minimum
 # acme/certbot version.
 install_requires = [
     'acme>=1.0.0',
-    'certbot>=1.0.0.dev0',
+    'certbot>=1.1.0',
     'mock',
     'PyOpenSSL',
     'pyparsing>=1.5.5',  # Python3 support; perhaps unnecessary?

certbot/CHANGELOG.md

@@ -2,7 +2,23 @@
 
 Certbot adheres to [Semantic Versioning](https://semver.org/).
 
-## 1.1.0 - master
+## 1.2.0 - master
+
+### Added
+
+*
+
+### Changed
+
+* Add directory field to error message when field is missing.
+
+### Fixed
+
+*
+
+More details about these changes can be found on our GitHub repo.
+
+## 1.1.0 - 2020-01-14
 
 ### Added
 
@@ -13,6 +29,15 @@ Certbot adheres to [Semantic Versioning](https://semver.org/).
 * Removed the fallback introduced with 0.34.0 in `acme` to retry a POST-as-GET
   request as a GET request when the targeted ACME CA server seems to not support
   POST-as-GET requests.
+* certbot-auto no longer supports architectures other than x86_64 on RHEL 6
+  based systems. Existing certbot-auto installations affected by this will
+  continue to work, but they will no longer receive updates. To install a
+  newer version of Certbot on these systems, you should update your OS.
+* Support for Python 3.4 in Certbot and its ACME library is deprecated and will be
+  removed in the next release of Certbot. certbot-auto users on x86_64 systems running
+  RHEL 6 or derivatives will be asked to enable Software Collections (SCL) repository
+  so Python 3.6 can be installed. certbot-auto can enable the SCL repo for you on CentOS 6
+  while users on other RHEL 6 based systems will be asked to do this manually.
 
 ### Fixed
 
@@ -223,7 +248,7 @@ More details about these changes can be found on our GitHub repo.
 
 ### Added
 
-* dns_rfc2136 plugin now supports explicitly specifing an authorative
+* dns_rfc2136 plugin now supports explicitly specifying an authoritative
   base domain for cases when the automatic method does not work (e.g.
   Split horizon DNS)
 
@@ -607,7 +632,7 @@ https://github.com/certbot/certbot/milestone/62?closed=1
 * Log warning about TLS-SNI deprecation in Certbot
 * Stop preferring TLS-SNI in the Apache, Nginx, and standalone plugins
 * OVH DNS plugin now relies on Lexicon>=2.7.14 to support HTTP proxies
-* Default time the Linode plugin waits for DNS changes to propogate is now 1200 seconds.
+* Default time the Linode plugin waits for DNS changes to propagate is now 1200 seconds.
 
 ### Fixed
 
@@ -726,7 +751,7 @@ https://github.com/certbot/certbot/milestone/58?closed=1
   increased over time. The max-age value is not increased to a large value
   until you've successfully managed to renew your certificate. This enhancement
   can be requested with the --auto-hsts flag.
-* New official DNS plugins have been created for Gehirn Infrastracture Service,
+* New official DNS plugins have been created for Gehirn Infrastructure Service,
   Linode, OVH, and Sakura Cloud. These plugins can be found on our Docker Hub
   page at https://hub.docker.com/u/certbot and on PyPI.
 * The ability to reuse ACME accounts from Let's Encrypt's ACMEv1 endpoint on

certbot/certbot/__init__.py

@@ -1,4 +1,4 @@
 """Certbot client."""
 
 # version number like 1.2.3a0, must have at least 2 parts, like 1.2
-__version__ = '1.1.0.dev0'
+__version__ = '1.2.0.dev0'

certbot/certbot/_internal/cli.py

@@ -92,8 +92,8 @@ obtain, install, and renew certificates:
 
 manage certificates:
     certificates    Display information about certificates you have from Certbot
-    revoke          Revoke a certificate (supply --cert-path or --cert-name)
-    delete          Delete a certificate
+    revoke          Revoke a certificate (supply --cert-name or --cert-path)
+    delete          Delete a certificate (supply --cert-name)
 
 manage your account:
     register        Create an ACME account
@@ -1414,7 +1414,7 @@ def _plugins_parsing(helpful, plugins):
     helpful.add(["plugins", "certonly"], "--dns-gehirn", action="store_true",
                 default=flag_default("dns_gehirn"),
                 help=("Obtain certificates using a DNS TXT record "
-                     "(if you are using Gehirn Infrastracture Service for DNS)."))
+                     "(if you are using Gehirn Infrastructure Service for DNS)."))
     helpful.add(["plugins", "certonly"], "--dns-google", action="store_true",
                 default=flag_default("dns_google"),
                 help=("Obtain certificates using a DNS TXT record (if you are "

certbot/certbot/_internal/main.py

@@ -1337,6 +1337,10 @@ def main(cli_args=None):
         if config.func != plugins_cmd:  # pylint: disable=comparison-with-callable
             raise
 
+    if sys.version_info[:2] == (3, 4):
+        logger.warning("Python 3.4 support will be dropped in the next release "
+                       "of Certbot - please upgrade your Python version to 3.5+.")
+
     set_displayer(config)
 
     # Reporter

certbot/certbot/_internal/ocsp.py

@@ -192,7 +192,7 @@ def _check_ocsp_cryptography(cert_path, chain_path, url):
 
 
 def _check_ocsp_response(response_ocsp, request_ocsp, issuer_cert, cert_path):
-    """Verify that the OCSP is valid for serveral criterias"""
+    """Verify that the OCSP is valid for serveral criteria"""
     # Assert OCSP response corresponds to the certificate we are talking about
     if response_ocsp.serial_number != request_ocsp.serial_number:
         raise AssertionError('the certificate in response does not correspond '

certbot/certbot/_internal/renewal.py

@@ -192,7 +192,7 @@ def _restore_pref_challs(unused_name, value):
     :returns: converted option value to be stored in the runtime config
     :rtype: `list` of `str`
 
-    :raises errors.Error: if value can't be converted to an bool
+    :raises errors.Error: if value can't be converted to a bool
 
     """
     # If pref_challs has only one element, configobj saves the value
@@ -203,7 +203,7 @@ def _restore_pref_challs(unused_name, value):
 
 
 def _restore_bool(name, value):
-    """Restores an boolean key-value pair from a renewal config file.
+    """Restores a boolean key-value pair from a renewal config file.
 
     :param str name: option name
     :param str value: option value
@@ -211,7 +211,7 @@ def _restore_bool(name, value):
     :returns: converted option value to be stored in the runtime config
     :rtype: bool
 
-    :raises errors.Error: if value can't be converted to an bool
+    :raises errors.Error: if value can't be converted to a bool
 
     """
     lowercase_value = value.lower()
@@ -244,7 +244,7 @@ def _restore_int(name, value):
 
 
 def _restore_str(unused_name, value):
-    """Restores an string key-value pair from a renewal config file.
+    """Restores a string key-value pair from a renewal config file.
 
     :param str unused_name: option name
     :param str value: option value