trigger 2.0.0__py3-none-any.whl

trigger/utils/__init__.py

@@ -0,0 +1,88 @@
+"""
+A collection of CLI tools and utilities used by Trigger.
+"""
+
+__author__ = "Jathan McCollum, Mike Biancaniello"
+__maintainer__ = "Jathan McCollum"
+__email__ = "jathan.mccollum@teamaol.com"
+__copyright__ = "Copyright 2008-2013, AOL Inc."
+
+import re
+from collections import namedtuple
+
+from .cli import get_user
+
+
+def crypt_md5(passwd):
+    """
+    Returns an md5-crypt hash of a clear-text password.
+
+    To get md5-crypt from ``crypt(3)`` you must pass an 8-char string starting with
+    '$1$' and ending with '$', resulting in a 12-char salt. This only works on
+    systems where md5-crypt is default and is currently assumed to be Linux.
+
+    :param passwd:
+        Password string to be encrypted
+    """
+    import platform
+
+    if platform.system() == "Linux":
+        import crypt
+        import hashlib
+        import time
+
+        salt = "$1$" + hashlib.md5(str(time.time())).hexdigest()[0:8] + "$"
+        crypted = crypt.crypt(passwd, salt)
+
+    else:
+        try:
+            from passlib.hash import md5_crypt
+        except ImportError:
+            raise RuntimeError(
+                """When not using Linux, generating md5-crypt password hashes requires the `passlib` module."""
+            )
+        else:
+            crypted = md5_crypt.encrypt(passwd)
+
+    return crypted
+
+
+JuniperElement = namedtuple("JuniperElement", "key value")
+
+
+def strip_juniper_namespace(path, key, value):
+    """
+    Given a Juniper XML element, strip the namespace and return a 2-tuple.
+
+    This is designed to be used as a ``postprocessor`` with
+    `~trigger.utils.xmltodict.parse()`.
+
+    :param key:
+        The attribute name of the element.
+
+    :param value:
+        The value of the element.
+    """
+    marr = re.match(r"(ns1:|ns0:)", key)
+    if marr:
+        ns = marr.group(0)
+        key = key.replace(ns, "")
+
+    return JuniperElement(key, value)
+
+
+NodePort = namedtuple("HostPort", "nodeName nodePort")
+
+
+def parse_node_port(nodeport, delimiter=":"):
+    """
+    Parse a string in format 'hostname' or 'hostname:port'  and return them
+    as a 2-tuple.
+    """
+    node, _, port = nodeport.partition(delimiter)
+    if port.isdigit():
+        port = int(port)
+    else:
+        port = None
+
+    return NodePort(str(node), port)

trigger/utils/cli.py

@@ -0,0 +1,349 @@
+"""
+Command-line interface utilities for Trigger tools. Intended for re-usable
+pieces of code like user prompts, that don't fit in other utils modules.
+"""
+
+__author__ = "Jathan McCollum"
+__maintainer__ = "Jathan McCollum"
+__email__ = "jathan.mccollum@teamaol.com"
+__copyright__ = "Copyright 2006-2012, AOL Inc.; 2013 Salesforce.com"
+
+import datetime
+import os
+import pwd
+import struct
+import sys
+import termios
+import time
+import tty
+from fcntl import ioctl
+
+from pytz import UTC, timezone
+
+# Exports
+__all__ = (
+    "yesno",
+    "get_terminal_width",
+    "get_terminal_size",
+    "Whirlygig",
+    "NullDevice",
+    "print_severed_head",
+    "min_sec",
+    "pretty_time",
+    "proceed",
+    "get_user",
+)
+
+
+# Functions
+def yesno(prompt, default=False, autoyes=False):
+    """
+    Present a yes-or-no prompt, get input, and return a boolean.
+
+    The ``default`` argument is ignored if ``autoyes`` is set.
+
+    :param prompt:
+        Prompt text
+
+    :param default:
+        Yes if True; No if False
+
+    :param autoyes:
+        Automatically return True
+
+    Default behavior (hitting "enter" returns ``False``)::
+
+        >>> yesno('Blow up the moon?')
+        Blow up the moon? (y/N)
+        False
+
+    Reversed behavior (hitting "enter" returns ``True``)::
+
+        >>> yesno('Blow up the moon?', default=True)
+        Blow up the moon? (Y/n)
+        True
+
+    Automatically return ``True`` with ``autoyes``; no prompt is displayed::
+
+        >>> yesno('Blow up the moon?', autoyes=True)
+        True
+    """
+    if autoyes:
+        return True
+
+    sys.stdout.write(prompt)
+    if default:
+        sys.stdout.write(" (Y/n) ")
+    else:
+        sys.stdout.write(" (y/N) ")
+    sys.stdout.flush()
+
+    fd = sys.stdin.fileno()
+    attr = termios.tcgetattr(fd)
+
+    try:
+        tty.setraw(fd)
+        yn = sys.stdin.read(1)
+    finally:
+        termios.tcsetattr(fd, termios.TCSANOW, attr)
+        print("")
+
+    if yn in ("y", "Y"):
+        return True
+    elif yn in ("n", "N"):
+        return False
+    else:
+        return default
+
+
+def proceed():
+    """Present a proceed prompt. Return ``True`` if Y, else ``False``"""
+    return input("\nDo you wish to proceed? [y/N] ").lower().startswith("y")
+
+
+def get_terminal_width():
+    """Find and return stdout's terminal width, if applicable."""
+    try:
+        width = struct.unpack("hhhh", ioctl(1, termios.TIOCGWINSZ, " " * 8))[1]
+    except OSError:
+        width = sys.maxsize
+
+    return width
+
+
+def get_terminal_size():
+    """Find and return stdouts terminal size as (height, width)"""
+    rows, cols = os.popen("stty size", "r").read().split()
+    return rows, cols
+
+
+def get_user():
+    """Return the name of the current user."""
+    return pwd.getpwuid(os.getuid())[0]
+
+
+def print_severed_head():
+    """
+    Prints a demon holding a severed head. Best used when things go wrong, like
+    production-impacting network outages caused by fat-fingered ACL changes.
+
+    Thanks to Jeff Sullivan for this best error message ever.
+    """
+    print(r"""
+
+                                                                _( (~\
+         _ _                        /                          ( \> > \
+     -/~/ / ~\                     :;                \       _  > /(~\/
+    || | | /\ ;\                   |l      _____     |;     ( \/    > >
+    _\\)\)\)/ ;;;                  `8o __-~     ~\   d|      \      //
+   ///(())(__/~;;\                  "88p;.  -. _\_;.oP        (_._/ /
+  (((__   __ \\   \                  `>,% (\  (\./)8"         ;:'  i
+  )))--`.'-- (( ;,8 \               ,;%%%:  ./V^^^V'          ;.   ;.
+  ((\   |   /)) .,88  `: ..,,;;;;,-::::::'_::\   ||\         ;[8:   ;
+   )|  ~-~  |(|(888; ..``'::::8888oooooo.  :\`^^^/,,~--._    |88::  |
+   |\ -===- /|  \8;; ``:.      oo.8888888888:`((( o.ooo8888Oo;:;:'  |
+   |_~-___-~_|   `-\.   `        `o`88888888b` )) 888b88888P""'     ;
+   ; ~~~~;~~         "`--_`.       b`888888888;(.,"888b888"  ..::;-'
+     ;      ;              ~"-....  b`8888888:::::.`8888. .:;;;''
+        ;    ;                 `:::. `:::OOO:::::::.`OO' ;;;''
+   :       ;                     `.      "``::::::''    .'
+      ;                           `.   \_              /
+    ;       ;                       +:   ~~--  `:'  -';    ACL LOADS FAILED
+                                     `:         : .::/
+        ;                            ;;+_  :::. :..;;;         YOU LOSE
+                                     ;;;;;;,;;;;;;;;,;
+
+""")
+
+
+def pretty_time(t):
+    """
+    Print a pretty version of timestamp, including timezone info. Expects
+    the incoming datetime object to have proper tzinfo.
+
+    :param t:
+        A ``datetime.datetime`` object
+
+    >>> import datetime
+    >>> from pytz import timezone
+    >>> localzone = timezone('US/Eastern')
+    <DstTzInfo 'US/Eastern' EST-1 day, 19:00:00 STD>
+    >>> t = datetime.datetime.now(localzone)
+    >>> print t
+    2011-07-19 12:40:30.820920-04:00
+    >>> print pretty_time(t)
+    09:40 PDT
+    >>> t = localzone.localize(datetime.datetime(2011,07,20,04,13))
+    >>> print t
+    2011-07-20 04:13:00-05:00
+    >>> print pretty_time(t)
+    tomorrow 02:13 PDT
+    """
+    from trigger.conf import settings
+
+    localzone = timezone(os.environ.get("TZ", settings.BOUNCE_DEFAULT_TZ))
+    t = t.astimezone(localzone)
+    ct = t.replace(tzinfo=None)  # convert to naive time
+    # to make the following calculations easier
+    # calculate naive 'now' in local time
+    # passing localzone into datetime.now directly can cause
+    # problems, see the 'pytz' docs if curious
+    now = datetime.datetime.now(UTC)
+    now = now.astimezone(localzone)
+    now = now.replace(tzinfo=None)
+    # and compute midnight
+    midnight = datetime.datetime.combine(now, datetime.time())
+    midnight += datetime.timedelta(1)
+    tomorrow = midnight + datetime.timedelta(1)
+    thisweek = midnight + datetime.timedelta(6)
+    if ct < midnight:
+        return t.strftime("%H:%M %Z")
+    elif ct < tomorrow:
+        return t.strftime("tomorrow %H:%M %Z")
+    elif ct < thisweek:
+        return t.strftime("%A %H:%M %Z")
+    else:
+        return t.strftime("%Y-%m-%d %H:%M %Z")
+
+
+def min_sec(secs):
+    """
+    Takes an epoch timestamp and returns string of minutes:seconds.
+
+    :param secs:
+        Timestamp (in seconds)
+
+    >>> import time
+    >>> start = time.time()  # Wait a few seconds
+    >>> finish = time.time()
+    >>> min_sec(finish - start)
+    '0:11'
+    """
+    secs = int(secs)
+    return "%d:%02d" % (secs / 60, secs % 60)
+
+
+def setup_tty_for_pty(func):
+    """
+    Sets up tty for raw mode while retaining original tty settings and then
+    starts the reactor to connect to the pty. Upon exiting pty, restores
+    original tty settings.
+
+    :param func:
+        The callable to run after the tty is ready, such as ``reactor.run``
+    """
+    # Preserve original tty settings
+    stdin_fileno = sys.stdin.fileno()
+    old_ttyattr = tty.tcgetattr(stdin_fileno)
+
+    try:
+        # Enter raw mode on the local tty.
+        tty.setraw(stdin_fileno)
+        raw_ta = tty.tcgetattr(stdin_fileno)
+        raw_ta[tty.LFLAG] |= tty.ISIG
+        raw_ta[tty.OFLAG] |= tty.OPOST | tty.ONLCR
+
+        # Pass ^C through so we can abort traceroute, etc.
+        raw_ta[tty.CC][tty.VINTR] = "\x18"  # ^X is the new ^C
+
+        # Ctrl-Z is used by a lot of vendors to exit config mode
+        raw_ta[tty.CC][tty.VSUSP] = 0  # disable ^Z
+        tty.tcsetattr(stdin_fileno, tty.TCSANOW, raw_ta)
+
+        # Execute our callable here
+        func()
+
+    finally:
+        # Restore original tty settings
+        tty.tcsetattr(stdin_fileno, tty.TCSANOW, old_ttyattr)
+
+
+def update_password_and_reconnect(hostname):
+    """
+    Prompts the user to update their password and reconnect to the target
+    device
+
+    :param hostname: Hostname of the device to connect to.
+    """
+    if yesno(
+        "Authentication failed, would you like to update your password?", default=True
+    ):
+        from trigger import tacacsrc
+
+        tacacsrc.update_credentials(hostname)
+        if yesno(f"\nReconnect to {hostname}?", default=True):
+            # Replaces the current process w/ same pid
+            args = [sys.argv[0]]
+            for arg in ("-o", "--oob"):
+                if arg in sys.argv:
+                    idx = sys.argv.index(arg)
+                    args.append(sys.argv[idx])
+                    break
+            args.append(hostname)
+            os.execl(sys.executable, sys.executable, *args)
+
+
+# Classes
+class NullDevice:
+    """
+    Used to supress output to ``sys.stdout`` (aka ``print``).
+
+    Example::
+
+        >>> from trigger.utils.cli import NullDevice
+        >>> import sys
+        >>> print "1 - this will print to STDOUT"
+        1 - this will print to STDOUT
+        >>> original_stdout = sys.stdout  # keep a reference to STDOUT
+        >>> sys.stdout = NullDevice()     # redirect the real STDOUT
+        >>> print "2 - this won't print"
+        >>>
+        >>> sys.stdout = original_stdout  # turn STDOUT back on
+        >>> print "3 - this will print to SDTDOUT"
+        3 - this will print to SDTDOUT
+    """
+
+    def write(self, s):
+        pass
+
+
+class Whirlygig:
+    """
+    Prints a whirlygig for use in displaying pending operation in a command-line tool.
+    Guaranteed to make the user feel warm and fuzzy and be 1000% bug-free.
+
+    :param start_msg: The status message displayed to the user (e.g. "Doing stuff:")
+    :param done_msg: The completion message displayed upon completion (e.g. "Done.")
+    :param max: Integer of the number of whirlygig repetitions to perform
+
+    Example::
+
+        >>> Whirlygig("Doing stuff:", "Done.", 12).run()
+    """
+
+    def __init__(self, start_msg="", done_msg="", max=100):
+        self.unbuff = os.fdopen(sys.stdout.fileno(), "w", 0)
+        self.start_msg = start_msg
+        self.done_msg = done_msg
+        self.max = max
+        self.whirlygig = ["|", "/", "-", "\\"]
+        self.whirl = self.whirlygig[:]
+        self.first = False
+
+    def do_whirl(self, whirl):
+        if not self.first:
+            self.unbuff.write(self.start_msg + "  ")
+            self.first = True
+        self.unbuff.write(f"\b{whirl.pop(0)}")
+
+    def run(self):
+        """Executes the whirlygig!"""
+        cnt = 1
+        while cnt <= self.max:
+            try:
+                self.do_whirl(self.whirl)
+            except IndexError:
+                self.whirl = self.whirlygig[:]
+            time.sleep(0.1)
+            cnt += 1
+        print("\b" + self.done_msg)

trigger/utils/importlib.py

@@ -0,0 +1,77 @@
+"""
+Utils to import modules.
+
+Taken verbatim from ``django.utils.importlib`` in Django 1.4.
+"""
+
+import os
+import sys
+
+# Exports
+__all__ = ("import_module", "import_module_from_path")
+
+
+# Functions
+def _resolve_name(name, package, level):
+    """Return the absolute name of the module to be imported."""
+    if not hasattr(package, "rindex"):
+        raise ValueError("'package' not set to a string")
+    dot = len(package)
+    for x in range(level, 1, -1):
+        try:
+            dot = package.rindex(".", 0, dot)
+        except ValueError:
+            raise ValueError("attempted relative import beyond top-level package")
+    return f"{package[:dot]}.{name}"
+
+
+def import_module(name, package=None):
+    """
+    Import a module and return the module object.
+
+    The ``package`` argument is required when performing a relative import. It
+    specifies the package to use as the anchor point from which to resolve the
+    relative import to an absolute import.
+
+    """
+    if name.startswith("."):
+        if not package:
+            raise TypeError("relative imports require the 'package' argument")
+        level = 0
+        for character in name:
+            if character != ".":
+                break
+            level += 1
+        name = _resolve_name(name[level:], package, level)
+    __import__(name)
+    return sys.modules[name]
+
+
+def import_module_from_path(full_path, global_name):
+    """
+    Import a module from a file path and return the module object.
+
+    Allows one to import from anywhere, something ``__import__()`` does not do.
+    The module is added to ``sys.modules`` as ``global_name``.
+
+    :param full_path:
+        The absolute path to the module .py file
+
+    :param global_name:
+        The name assigned to the module in sys.modules. To avoid
+        confusion, the global_name should be the same as the variable to which
+        you're assigning the returned module.
+    """
+    path, filename = os.path.split(full_path)
+    module, ext = os.path.splitext(filename)
+    sys.path.append(path)
+
+    try:
+        mymodule = __import__(module)
+        sys.modules[global_name] = mymodule
+    except ImportError:
+        raise ImportError(f"Module could not be imported from {full_path}.")
+    finally:
+        del sys.path[-1]
+
+    return mymodule

trigger/utils/network.py

@@ -0,0 +1,157 @@
+"""
+Functions that perform network-based things like ping, port tests, etc.
+"""
+
+import os
+import shlex
+import socket
+import subprocess
+
+from trigger.conf import settings
+
+# Exports
+__all__ = ("ping", "test_tcp_port", "test_ssh", "address_is_internal")
+
+
+# Constants
+# SSH version strings used to validate SSH banners.
+SSH_VERSION_STRINGS = (
+    "SSH-1.99",
+    "SSH-2.0",
+    "dcos_sshd run in non-FIPS mode",  # Cisco Nexus not in FIPS mode
+)
+
+
+# Functions
+def ping(host, count=1, timeout=5):
+    """
+    Returns pass/fail for a ping. Supports POSIX only.
+
+    :param host:
+        Hostname or address
+
+    :param count:
+        Repeat count
+
+    :param timeout:
+        Timeout in seconds
+
+    >>> from trigger.utils import network
+    >>> network.ping('aol.com')
+    True
+    >>> network.ping('192.168.199.253')
+    False
+    """
+
+    ping_command = "ping -q -c%d -W%d %s" % (count, timeout, host)
+    status = None
+    with open(os.devnull, "w") as devnull_fd:
+        status = subprocess.call(
+            shlex.split(ping_command),
+            stdout=devnull_fd,
+            stderr=devnull_fd,
+            close_fds=True,
+        )
+
+    # Linux RC: 0 = success, 256 = failure, 512 = unknown host
+    # Darwin RC: 0 = success, 512 = failure, 17408 = unknown host
+    return status == 0
+
+
+def test_tcp_port(host, port=23, timeout=5, check_result=False, expected_result=""):
+    """
+    Attempts to connect to a TCP port. Returns a Boolean.
+
+    If ``check_result`` is set, the first line of output is retreived from the
+    connection and the starting characters must match ``expected_result``.
+
+    :param host:
+        Hostname or address
+
+    :param port:
+        Destination port
+
+    :param timeout:
+        Timeout in seconds
+
+    :param check_result:
+        Whether or not to do a string check (e.g. version banner)
+
+    :param expected_result:
+        The expected result!
+
+    >>> test_tcp_port('aol.com', 80)
+    True
+    >>> test_tcp_port('aol.com', 12345)
+    False
+    """
+    # Python 3: Use socket instead of deprecated telnetlib for port testing
+    sock = None
+    try:
+        sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
+        sock.settimeout(timeout)
+        sock.connect((host, port))
+
+        if check_result:
+            # Read the initial banner/response
+            sock.settimeout(2)  # Short timeout for reading
+            result = sock.recv(1024)
+            return result.startswith(
+                expected_result.encode()
+                if isinstance(expected_result, str)
+                else expected_result
+            )
+
+        return True
+    except (TimeoutError, OSError):
+        return False
+    finally:
+        if sock:
+            sock.close()
+
+
+def test_ssh(host, port=22, timeout=5, version=SSH_VERSION_STRINGS):
+    """
+    Connect to a TCP port and confirm the SSH version. Defaults to SSHv2.
+
+    Note that the default of ('SSH-1.99', 'SSH-2.0') both indicate SSHv2 per
+    RFC 4253. (Ref: http://en.wikipedia.org/wiki/Secure_Shell#Version_1.99)
+
+    :param host:
+        Hostname or address
+
+    :param port:
+        Destination port
+
+    :param timeout:
+        Timeout in seconds
+
+    :param version:
+        The SSH version prefix (e.g. "SSH-2.0"). This may also be a tuple of
+        prefixes.
+
+    >>> test_ssh('localhost')
+    True
+    >>> test_ssh('localhost', version='SSH-1.5')
+    False
+    """
+    return test_tcp_port(
+        host, port, timeout, check_result=True, expected_result=version
+    )
+
+
+def address_is_internal(ip):
+    """
+    Determines if an IP address is internal to your network. Relies on
+    networks specified in :mod:`settings.INTERNAL_NETWORKS`.
+
+    :param ip:
+        IP address to test.
+
+    >>> address_is_internal('1.1.1.1')
+    False
+    """
+    for i in settings.INTERNAL_NETWORKS:
+        if ip in i:
+            return True
+    return False