Move letsencrypt.client to letsencrypt

letsencrypt/display/__init__.py

@@ -0,0 +1 @@
+"""Let's Encrypt display utilities."""

letsencrypt/display/enhancements.py

@@ -0,0 +1,60 @@
+"""Let's Encrypt Enhancement Display"""
+import logging
+
+import zope.component
+
+from letsencrypt import errors
+from letsencrypt import interfaces
+from letsencrypt.display import util as display_util
+
+
+# Define a helper function to avoid verbose code
+util = zope.component.getUtility  # pylint: disable=invalid-name
+
+
+def ask(enhancement):
+    """Display the enhancement to the user.
+
+    :param str enhancement: One of the
+        :class:`letsencrypt.CONFIG.ENHANCEMENTS` enhancements
+
+    :returns: True if feature is desired, False otherwise
+    :rtype: bool
+
+    :raises letsencrypt.errors.LetsEncryptClientError: If
+        the enhancement provided is not supported.
+
+    """
+    try:
+        # Call the appropriate function based on the enhancement
+        return DISPATCH[enhancement]()
+    except KeyError:
+        logging.error("Unsupported enhancement given to ask(): %s", enhancement)
+        raise errors.LetsEncryptClientError("Unsupported Enhancement")
+
+
+def redirect_by_default():
+    """Determines whether the user would like to redirect to HTTPS.
+
+    :returns: True if redirect is desired, False otherwise
+    :rtype: bool
+
+    """
+    choices = [
+        ("Easy", "Allow both HTTP and HTTPS access to these sites"),
+        ("Secure", "Make all requests redirect to secure HTTPS access"),
+    ]
+
+    code, selection = util(interfaces.IDisplay).menu(
+        "Please choose whether HTTPS access is required or optional.",
+        choices)
+
+    if code != display_util.OK:
+        return False
+
+    return selection == 1
+
+
+DISPATCH = {
+    "redirect": redirect_by_default
+}

letsencrypt/display/ops.py

@@ -0,0 +1,230 @@
+"""Contains UI methods for LE user operations."""
+import logging
+import os
+
+import zope.component
+
+from letsencrypt import interfaces
+from letsencrypt.display import util as display_util
+
+
+# Define a helper function to avoid verbose code
+util = zope.component.getUtility  # pylint: disable=invalid-name
+
+
+def choose_plugin(prepared, question):
+    """Allow the user to choose ther plugin.
+
+    :param list prepared: List of `~.PluginEntryPoint`.
+    :param str question: Question to be presented to the user.
+
+    :returns: Plugin entry point chosen by the user.
+    :rtype: `~.PluginEntryPoint`
+
+    """
+    opts = [plugin_ep.name_with_description
+            + (" [Misconfigured]" if plugin_ep.misconfigured else "")
+            for plugin_ep in prepared]
+
+    while True:
+        code, index = util(interfaces.IDisplay).menu(
+            question, opts, help_label="More Info")
+
+        if code == display_util.OK:
+            return prepared[index]
+        elif code == display_util.HELP:
+            if prepared[index].misconfigured:
+                msg = "Reported Error: %s" % prepared[index].prepare()
+            else:
+                msg = prepared[index].init().more_info()
+            util(interfaces.IDisplay).notification(
+                msg, height=display_util.HEIGHT)
+        else:
+            return None
+
+
+def pick_plugin(config, default, plugins, question, ifaces):
+    """Pick plugin.
+
+    :param letsencrypt.interfaces.IConfig: Configuration
+    :param str default: Plugin name supplied by user or ``None``.
+    :param letsencrypt.plugins.disco.PluginsRegistry plugins:
+        All plugins registered as entry points.
+    :param str question: Question to be presented to the user in case
+        multiple candidates are found.
+    :param list ifaces: Interfaces that plugins must provide.
+
+    :returns: Initialized plugin.
+    :rtype: IPlugin
+
+    """
+    if default is not None:
+        # throw more UX-friendly error if default not in plugins
+        filtered = plugins.filter(lambda p_ep: p_ep.name == default)
+    else:
+        filtered = plugins.ifaces(ifaces)
+
+    filtered.init(config)
+    verified = filtered.verify(ifaces)
+    verified.prepare()
+    prepared = verified.available()
+
+    if len(prepared) > 1:
+        logging.debug("Multiple candidate plugins: %s", prepared)
+        plugin_ep = choose_plugin(prepared.values(), question)
+        if plugin_ep is None:
+            return None
+        else:
+            return plugin_ep.init()
+    elif len(prepared) == 1:
+        plugin_ep = prepared.values()[0]
+        logging.debug("Single candidate plugin: %s", plugin_ep)
+        return plugin_ep.init()
+    else:
+        logging.debug("No candidate plugin")
+        return None
+
+
+def pick_authenticator(
+        config, default, plugins, question="How would you "
+        "like to authenticate with Let's Encrypt CA?"):
+    """Pick authentication plugin."""
+    return pick_plugin(
+        config, default, plugins, question, (interfaces.IAuthenticator,))
+
+
+def pick_installer(config, default, plugins,
+                   question="How would you like to install certificates?"):
+    """Pick installer plugin."""
+    return pick_plugin(
+        config, default, plugins, question, (interfaces.IInstaller,))
+
+
+def pick_configurator(
+        config, default, plugins,
+        question="How would you like to authenticate and install "
+                 "certificates?"):
+    """Pick configurator plugin."""
+    return pick_plugin(
+        config, default, plugins, question,
+        (interfaces.IAuthenticator, interfaces.IInstaller))
+
+
+def choose_account(accounts):
+    """Choose an account.
+
+    :param list accounts: Containing at least one
+        :class:`~letsencrypt.account.Account`
+
+    """
+    # Note this will get more complicated once we start recording authorizations
+    labels = [
+        "%s | %s" % (acc.email.ljust(display_util.WIDTH - 39),
+                     acc.phone if acc.phone is not None else "")
+        for acc in accounts
+    ]
+
+    code, index = util(interfaces.IDisplay).menu(
+        "Please choose an account", labels)
+    if code == display_util.OK:
+        return accounts[index]
+    else:
+        return None
+
+
+def choose_names(installer):
+    """Display screen to select domains to validate.
+
+    :param installer: An installer object
+    :type installer: :class:`letsencrypt.interfaces.IInstaller`
+
+    :returns: List of selected names
+    :rtype: `list` of `str`
+
+    """
+    if installer is None:
+        logging.debug("No installer, picking names manually")
+        return _choose_names_manually()
+
+    names = list(installer.get_all_names())
+
+    if not names:
+        manual = util(interfaces.IDisplay).yesno(
+            "No names were found in your configuration files.{0}You should "
+            "specify ServerNames in your config files in order to allow for "
+            "accurate installation of your certificate.{0}"
+            "If you do use the default vhost, you may specify the name "
+            "manually. Would you like to continue?{0}".format(os.linesep))
+
+        if manual:
+            return _choose_names_manually()
+        else:
+            return []
+
+    code, names = _filter_names(names)
+    if code == display_util.OK and names:
+        return names
+    else:
+        return []
+
+
+def _filter_names(names):
+    """Determine which names the user would like to select from a list.
+
+    :param list names: domain names
+
+    :returns: tuple of the form (`code`, `names`) where
+        `code` - str display exit code
+        `names` - list of names selected
+    :rtype: tuple
+
+    """
+    code, names = util(interfaces.IDisplay).checklist(
+        "Which names would you like to activate HTTPS for?",
+        tags=names)
+    return code, [str(s) for s in names]
+
+
+def _choose_names_manually():
+    """Manually input names for those without an installer."""
+
+    code, input_ = util(interfaces.IDisplay).input(
+        "Please enter in your domain name(s) (comma and/or space separated) ")
+
+    if code == display_util.OK:
+        return display_util.separate_list_input(input_)
+    return []
+
+
+def success_installation(domains):
+    """Display a box confirming the installation of HTTPS.
+
+    .. todo:: This should be centered on the screen
+
+    :param list domains: domain names which were enabled
+
+    """
+    util(interfaces.IDisplay).notification(
+        "Congratulations! You have successfully enabled "
+        "%s!" % _gen_https_names(domains), pause=False)
+
+
+def _gen_https_names(domains):
+    """Returns a string of the https domains.
+
+    Domains are formatted nicely with https:// prepended to each.
+
+    :param list domains: Each domain is a 'str'
+
+    """
+    if len(domains) == 1:
+        return "https://{0}".format(domains[0])
+    elif len(domains) == 2:
+        return "https://{dom[0]} and https://{dom[1]}".format(dom=domains)
+    elif len(domains) > 2:
+        return "{0}{1}{2}".format(
+            ", ".join("https://%s" % dom for dom in domains[:-1]),
+            ", and https://",
+            domains[-1])
+
+    return ""

letsencrypt/display/revocation.py

@@ -0,0 +1,77 @@
+"""Revocation UI class."""
+import os
+
+import zope.component
+
+from letsencrypt import interfaces
+from letsencrypt.display import util as display_util
+
+# Define a helper function to avoid verbose code
+util = zope.component.getUtility  # pylint: disable=invalid-name
+
+
+def display_certs(certs):
+    """Display the certificates in a menu for revocation.
+
+    :param list certs: each is a :class:`letsencrypt.revoker.Cert`
+
+    :returns: tuple of the form (code, selection) where
+        code is a display exit code
+        selection is the user's int selection
+    :rtype: tuple
+
+    """
+    list_choices = [
+        "%s | %s | %s" % (
+            str(cert.get_cn().ljust(display_util.WIDTH - 39)),
+            cert.get_not_before().strftime("%m-%d-%y"),
+            "Installed" if cert.installed and cert.installed != ["Unknown"]
+            else "") for cert in certs
+    ]
+
+    code, tag = util(interfaces.IDisplay).menu(
+        "Which certificates would you like to revoke?",
+        list_choices, help_label="More Info", ok_label="Revoke",
+        cancel_label="Exit")
+
+    return code, tag
+
+
+def confirm_revocation(cert):
+    """Confirm revocation screen.
+
+    :param cert: certificate object
+    :type cert: :class:
+
+    :returns: True if user would like to revoke, False otherwise
+    :rtype: bool
+
+    """
+    return util(interfaces.IDisplay).yesno(
+        "Are you sure you would like to revoke the following "
+        "certificate:{0}{cert}This action cannot be reversed!".format(
+            os.linesep, cert=cert.pretty_print()))
+
+
+def more_info_cert(cert):
+    """Displays more info about the cert.
+
+    :param dict cert: cert dict used throughout revoker.py
+
+    """
+    util(interfaces.IDisplay).notification(
+        "Certificate Information:{0}{1}".format(
+            os.linesep, cert.pretty_print()),
+        height=display_util.HEIGHT)
+
+
+def success_revocation(cert):
+    """Display a success message.
+
+    :param cert: cert that was revoked
+    :type cert: :class:`letsencrypt.revoker.Cert`
+
+    """
+    util(interfaces.IDisplay).notification(
+        "You have successfully revoked the certificate for "
+        "%s" % cert.get_cn())

letsencrypt/display/util.py

@@ -0,0 +1,421 @@
+"""Let's Encrypt display."""
+import os
+import textwrap
+
+import dialog
+import zope.interface
+
+from letsencrypt import interfaces
+
+
+WIDTH = 72
+HEIGHT = 20
+
+# Display exit codes
+OK = "ok"
+"""Display exit code indicating user acceptance."""
+
+CANCEL = "cancel"
+"""Display exit code for a user canceling the display."""
+
+HELP = "help"
+"""Display exit code when for when the user requests more help."""
+
+
+class NcursesDisplay(object):
+    """Ncurses-based display."""
+
+    zope.interface.implements(interfaces.IDisplay)
+
+    def __init__(self, width=WIDTH, height=HEIGHT):
+        super(NcursesDisplay, self).__init__()
+        self.dialog = dialog.Dialog()
+        self.width = width
+        self.height = height
+
+    def notification(self, message, height=10, pause=False):
+        # pylint: disable=unused-argument
+        """Display a notification to the user and wait for user acceptance.
+
+        .. todo:: It probably makes sense to use one of the transient message
+            types for pause. It isn't straightforward how best to approach
+            the matter though given the context of our messages.
+            http://pythondialog.sourceforge.net/doc/widgets.html#displaying-transient-messages
+
+        :param str message: Message to display
+        :param int height: Height of the dialog box
+        :param bool pause: Not applicable to NcursesDisplay
+
+        """
+        self.dialog.msgbox(message, height, width=self.width)
+
+    def menu(self, message, choices,
+             ok_label="OK", cancel_label="Cancel", help_label=""):
+        """Display a menu.
+
+        :param str message: title of menu
+
+        :param choices: menu lines, len must be > 0
+        :type choices: list of tuples (`tag`, `item`) tags must be unique or
+            list of items (tags will be enumerated)
+
+        :param str ok_label: label of the OK button
+        :param str help_label: label of the help button
+
+        :returns: tuple of the form (`code`, `tag`) where
+            `code` - `str` display_util exit code
+            `tag` - `int` index corresponding to the item chosen
+        :rtype: tuple
+
+        """
+        menu_options = {
+            "choices": choices,
+            "ok_label": ok_label,
+            "cancel_label": cancel_label,
+            "help_button": bool(help_label),
+            "help_label": help_label,
+            "width": self.width,
+            "height": self.height,
+            "menu_height": self.height-6,
+        }
+
+        # Can accept either tuples or just the actual choices
+        if choices and isinstance(choices[0], tuple):
+            # pylint: disable=star-args
+            code, selection = self.dialog.menu(message, **menu_options)
+
+            # Return the selection index
+            for i, choice in enumerate(choices):
+                if choice[0] == selection:
+                    return code, i
+
+            return code, -1
+
+        else:
+            # "choices" is not formatted the way the dialog.menu expects...
+            menu_options["choices"] = [
+                (str(i), choice) for i, choice in enumerate(choices, 1)
+            ]
+            # pylint: disable=star-args
+            code, tag = self.dialog.menu(message, **menu_options)
+
+            if code == CANCEL:
+                return code, -1
+
+            return code, int(tag) - 1
+
+    def input(self, message):
+        """Display an input box to the user.
+
+        :param str message: Message to display that asks for input.
+
+        :returns: tuple of the form (code, string) where
+            `code` - int display exit code
+            `string` - input entered by the user
+
+        """
+        return self.dialog.inputbox(message, width=self.width)
+
+    def yesno(self, message, yes_label="Yes", no_label="No"):
+        """Display a Yes/No dialog box.
+
+        Yes and No label must begin with different letters.
+
+        :param str message: message to display to user
+        :param str yes_label: label on the "yes" button
+        :param str no_label: label on the "no" button
+
+        :returns: if yes_label was selected
+        :rtype: bool
+
+        """
+        return self.dialog.DIALOG_OK == self.dialog.yesno(
+            message, self.height, self.width,
+            yes_label=yes_label, no_label=no_label)
+
+    def checklist(self, message, tags, default_status=True):
+        """Displays a checklist.
+
+        :param message: Message to display before choices
+        :param list tags: where each is of type :class:`str` len(tags) > 0
+        :param bool default_status: If True, items are in a selected state by
+            default.
+
+
+        :returns: tuple of the form (code, list_tags) where
+            `code` - int display exit code
+            `list_tags` - list of str tags selected by the user
+
+        """
+        choices = [(tag, "", default_status) for tag in tags]
+        return self.dialog.checklist(
+            message, width=self.width, height=self.height, choices=choices)
+
+
+class FileDisplay(object):
+    """File-based display."""
+
+    zope.interface.implements(interfaces.IDisplay)
+
+    def __init__(self, outfile):
+        super(FileDisplay, self).__init__()
+        self.outfile = outfile
+
+    def notification(self, message, height=10, pause=True):
+        # pylint: disable=unused-argument
+        """Displays a notification and waits for user acceptance.
+
+        :param str message: Message to display
+        :param int height: No effect for FileDisplay
+        :param bool pause: Whether or not the program should pause for the
+            user's confirmation
+
+        """
+        side_frame = "-" * 79
+        message = self._wrap_lines(message)
+        self.outfile.write(
+            "{line}{frame}{line}{msg}{line}{frame}{line}".format(
+                line=os.linesep, frame=side_frame, msg=message))
+        if pause:
+            raw_input("Press Enter to Continue")
+
+    def menu(self, message, choices,
+             ok_label="", cancel_label="", help_label=""):
+        # pylint: disable=unused-argument
+        """Display a menu.
+
+        .. todo:: This doesn't enable the help label/button (I wasn't sold on
+           any interface I came up with for this). It would be a nice feature
+
+        :param str message: title of menu
+        :param choices: Menu lines, len must be > 0
+        :type choices: list of tuples (tag, item) or
+            list of descriptions (tags will be enumerated)
+
+        :returns: tuple of the form (code, tag) where
+            code - int display exit code
+            tag - str corresponding to the item chosen
+        :rtype: tuple
+
+        """
+        self._print_menu(message, choices)
+
+        code, selection = self._get_valid_int_ans(len(choices))
+
+        return code, selection - 1
+
+    def input(self, message):
+        # pylint: disable=no-self-use
+        """Accept input from the user.
+
+        :param str message: message to display to the user
+
+        :returns: tuple of (`code`, `input`) where
+            `code` - str display exit code
+            `input` - str of the user's input
+        :rtype: tuple
+
+        """
+        ans = raw_input(
+            textwrap.fill("%s (Enter 'c' to cancel): " % message, 80))
+
+        if ans == "c" or ans == "C":
+            return CANCEL, "-1"
+        else:
+            return OK, ans
+
+    def yesno(self, message, yes_label="Yes", no_label="No"):
+        """Query the user with a yes/no question.
+
+        Yes and No label must begin with different letters, and must contain at
+        least one letter each.
+
+        :param str message: question for the user
+        :param str yes_label: Label of the "Yes" parameter
+        :param str no_label: Label of the "No" parameter
+
+        :returns: True for "Yes", False for "No"
+        :rtype: bool
+
+        """
+        side_frame = ("-" * 79) + os.linesep
+
+        message = self._wrap_lines(message)
+
+        self.outfile.write("{0}{frame}{msg}{0}{frame}".format(
+            os.linesep, frame=side_frame, msg=message))
+
+        while True:
+            ans = raw_input("{yes}/{no}: ".format(
+                yes=_parens_around_char(yes_label),
+                no=_parens_around_char(no_label)))
+
+            # Couldn't get pylint indentation right with elif
+            # elif doesn't matter in this situation
+            if (ans.startswith(yes_label[0].lower()) or
+                    ans.startswith(yes_label[0].upper())):
+                return True
+            if (ans.startswith(no_label[0].lower()) or
+                    ans.startswith(no_label[0].upper())):
+                return False
+
+    def checklist(self, message, tags, default_status=True):
+        # pylint: disable=unused-argument
+        """Display a checklist.
+
+        :param str message: Message to display to user
+        :param list tags: `str` tags to select, len(tags) > 0
+        :param bool default_status: Not used for FileDisplay
+
+        :returns: tuple of (`code`, `tags`) where
+            `code` - str display exit code
+            `tags` - list of selected tags
+        :rtype: tuple
+
+        """
+        while True:
+            self._print_menu(message, tags)
+
+            code, ans = self.input("Select the appropriate numbers separated "
+                                   "by commas and/or spaces")
+
+            if code == OK:
+                indices = separate_list_input(ans)
+                selected_tags = self._scrub_checklist_input(indices, tags)
+                if selected_tags:
+                    return code, selected_tags
+                else:
+                    self.outfile.write(
+                        "** Error - Invalid selection **%s" % os.linesep)
+            else:
+                return code, []
+
+    def _scrub_checklist_input(self, indices, tags):
+        # pylint: disable=no-self-use
+        """Validate input and transform indices to appropriate tags.
+
+        :param list indices: input
+        :param list tags: Original tags of the checklist
+
+        :returns: valid tags the user selected
+        :rtype: :class:`list` of :class:`str`
+
+        """
+        # They should all be of type int
+        try:
+            indices = [int(index) for index in indices]
+        except ValueError:
+            return []
+
+        # Remove duplicates
+        indices = list(set(indices))
+
+        # Check all input is within range
+        for index in indices:
+            if index < 1 or index > len(tags):
+                return []
+        # Transform indices to appropriate tags
+        return [tags[index-1] for index in indices]
+
+    def _print_menu(self, message, choices):
+        """Print a menu on the screen.
+
+        :param str message: title of menu
+        :param choices: Menu lines
+        :type choices: list of tuples (tag, item) or
+            list of descriptions (tags will be enumerated)
+
+        """
+        # Can take either tuples or single items in choices list
+        if choices and isinstance(choices[0], tuple):
+            choices = ["%s - %s" % (c[0], c[1]) for c in choices]
+
+        # Write out the message to the user
+        self.outfile.write(
+            "{new}{msg}{new}".format(new=os.linesep, msg=message))
+        side_frame = ("-" * 79) + os.linesep
+        self.outfile.write(side_frame)
+
+        # Write out the menu choices
+        for i, desc in enumerate(choices, 1):
+            self.outfile.write(
+                textwrap.fill("{num}: {desc}".format(num=i, desc=desc), 80))
+
+            # Keep this outside of the textwrap
+            self.outfile.write(os.linesep)
+
+        self.outfile.write(side_frame)
+
+    def _wrap_lines(self, msg):  # pylint: disable=no-self-use
+        """Format lines nicely to 80 chars.
+
+        :param str msg: Original message
+
+        :returns: Formatted message respecting newlines in message
+        :rtype: str
+
+        """
+        lines = msg.splitlines()
+        fixed_l = []
+        for line in lines:
+            fixed_l.append(textwrap.fill(line, 80))
+
+        return os.linesep.join(fixed_l)
+
+    def _get_valid_int_ans(self, max_):
+        """Get a numerical selection.
+
+        :param int max: The maximum entry (len of choices), must be positive
+
+        :returns: tuple of the form (`code`, `selection`) where
+            `code` - str display exit code ('ok' or cancel')
+            `selection` - int user's selection
+        :rtype: tuple
+
+        """
+        selection = -1
+        if max_ > 1:
+            input_msg = ("Select the appropriate number "
+                         "[1-{max_}] then [enter] (press 'c' to "
+                         "cancel): ".format(max_=max_))
+        else:
+            input_msg = ("Press 1 [enter] to confirm the selection "
+                         "(press 'c' to cancel): ")
+        while selection < 1:
+            ans = raw_input(input_msg)
+            if ans.startswith("c") or ans.startswith("C"):
+                return CANCEL, -1
+            try:
+                selection = int(ans)
+                if selection < 1 or selection > max_:
+                    selection = -1
+                    raise ValueError
+
+            except ValueError:
+                self.outfile.write(
+                    "{0}** Invalid input **{0}".format(os.linesep))
+
+        return OK, selection
+
+
+def separate_list_input(input_):
+    """Separate a comma or space separated list.
+
+    :param str input_: input from the user
+
+    :returns: strings
+    :rtype: list
+
+    """
+    no_commas = input_.replace(",", " ")
+    # Each string is naturally unicode, this causes problems with M2Crypto SANs
+    return [str(string) for string in no_commas.split()]
+
+
+def _parens_around_char(label):
+    """Place parens around first character of label.
+
+    :param str label: Must contain at least one character
+
+    """
+    return "({first}){rest}".format(first=label[0], rest=label[1:])