trigger 2.0.0__py3-none-any.whl

trigger/utils/rcs.py

@@ -0,0 +1,178 @@
+"""
+Provides a CVS like wrapper for local RCS (Revision Control System) with common commands.
+"""
+
+__author__ = "Jathan McCollum"
+__maintainer__ = "Jathan McCollum"
+__email__ = "jathan.mccollum@teamaol.com"
+__copyright__ = "Copyright 2009-2011, AOL Inc."
+
+import os
+import time
+
+import commands
+
+# Exports
+__all__ = ("RCS",)
+
+
+# Classes
+class RCS:
+    """
+    Simple wrapper for CLI ``rcs`` command. An instance is bound to a file.
+
+    :param file: The filename (or path) to use
+    :param create: If set, create the file if it doesn't exist
+
+    >>> from trigger.utils.rcs import RCS
+    >>> rcs = RCS('foo')
+    >>> rcs.lock()
+    True
+    >>> f = open('foo', 'w')
+    >>> f.write('bar\\n')
+    >>> f.close()
+    >>> rcs.checkin('This is my commit message')
+    True
+    >>> print rcs.log()
+    RCS file: RCS/foo,v
+    Working file: foo
+    head: 1.2
+    branch:
+    locks: strict
+    access list:
+    symbolic names:
+    keyword substitution: kv
+    total revisions: 2;     selected revisions: 2
+    description:
+    ----------------------------
+    revision 1.2
+    date: 2011/07/08 21:01:28;  author: jathan;  state: Exp;  lines: +1 -0
+    This is my commit message
+    ----------------------------
+    revision 1.1
+    date: 2011/07/08 20:56:53;  author: jathan;  state: Exp;
+    first commit
+    """
+
+    def __init__(self, filename, create=True):
+        self.locked = False
+        self.filename = filename
+
+        if not os.path.exists(filename):
+            if not create:
+                self.filename = None
+                return None
+            try:
+                f = open(self.filename, "w")
+            except:
+                return None
+            f.close()
+            if not self.checkin(initial=True):
+                return None
+
+    def checkin(self, logmsg="none", initial=False, verbose=False):
+        """
+        Perform an RCS checkin. If successful this also unlocks the file, so
+        there is no need to unlock it afterward.
+
+        :param logmsg: The RCS commit message
+        :param initial: Initialize a new RCS file, but do not deposit any revision
+        :param verbose: Print command output
+
+        >>> rcs.checkin('This is my commit message')
+        True
+        """
+        if initial:
+            cmd = f'ci -m"first commit" -t- -i {self.filename}'
+        else:
+            cmd = f'ci -u -m"{logmsg}" {self.filename}'
+        status, output = commands.getstatusoutput(cmd)
+
+        if verbose:
+            print(output)
+
+        if status > 0:
+            return False
+
+        return True
+
+    def lock(self, verbose=False):
+        """
+        Perform an RCS checkout with lock. Returns boolean of whether lock
+        was sucessful.
+
+        :param verbose: Print command output
+
+        >>> rcs.lock()
+        True
+        """
+        cmd = f"co -f -l {self.filename}"
+        status, output = commands.getstatusoutput(cmd)
+
+        if verbose:
+            print(output)
+
+        if status > 0:
+            return False
+
+        self.locked = True
+        return True
+
+    def unlock(self, verbose=False):
+        """
+        Perform an RCS checkout with unlock (for cancelling changes).
+
+        :param verbose: Print command output
+
+        >>> rcs.unlock()
+        True
+        """
+        cmd = f"co -f -u {self.filename}"
+        status, output = commands.getstatusoutput(cmd)
+
+        if verbose:
+            print(output)
+
+        if status > 0:
+            return False
+
+        self.locked = False
+        return True
+
+    def lock_loop(self, callback=None, timeout=5, verbose=False):
+        """
+        Keep trying to lock the file until a lock is obtained.
+
+        :param callback: The function to call after lock is complete
+        :param timeout: How long to sleep between lock attempts
+        :param verbose: Print command output
+
+        Default:
+            >>> rcs.lock_loop(timeout=1)
+            Sleeping to wait for the lock on the file: foo
+            Sleeping to wait for the lock on the file: foo
+
+        Verbose:
+            >>> rcs.lock_loop(timeout=1, verbose=True)
+            RCS/foo,v  -->  foo
+            co: RCS/foo,v: Revision 1.2 is already locked by joe.
+            Sleeping to wait for the lock on the file: foo
+            RCS/foo,v  -->  foo
+            co: RCS/foo,v: Revision 1.2 is already locked by joe.
+        """
+        while not self.lock(verbose=verbose):
+            print(f"Sleeping to wait for the lock on the file: {self.filename}")
+            time.sleep(timeout)
+            if callback:
+                callback()
+        return True
+
+    def log(self):
+        """Returns the RCS log as a string (see above)."""
+        cmd = f"rlog {self.filename} 2>&1"
+        status, output = commands.getstatusoutput(cmd)
+
+        if status > 0:
+            return None
+
+        return output

trigger/utils/templates.py

@@ -0,0 +1,81 @@
+"""
+Templating functions for unstructured CLI output.
+"""
+
+__author__ = "Thomas Cuthbert"
+__maintainer__ = "Thomas Cuthbert"
+__email__ = "tcuthbert90@gmail.com"
+__copyright__ = "Copyright 2016 Trigger Org"
+
+
+import os
+
+from twisted.python import log
+
+from trigger.conf import settings
+
+try:
+    import textfsm
+except ImportError:
+    print("""
+    Woops, looks like you're missing the textfsm library.
+
+    Try installing it like this::
+
+        >>> pip install textfsm
+    """)
+
+
+# Exports
+__all__ = ("get_template_path", "load_cmd_template", "get_textfsm_object")
+
+
+def get_template_path(cmd, dev_type=None):
+    """
+    Return textfsm templates from the directory pointed to by the TEXTFSM_TEMPLATE_DIR trigger variable.
+
+    :param dev_type: Type of device ie cisco_ios, arista_eos
+    :type  dev_type: str
+    :param cmd: CLI command to load template.
+    :type  cmd: str
+    :returns: String template path
+    """
+    t_dir = settings.TEXTFSM_TEMPLATE_DIR
+    return (
+        os.path.join(
+            t_dir, "{1}_{2}.template".format(t_dir, dev_type, cmd.replace(" ", "_"))
+        )
+        or None
+    )
+
+
+def load_cmd_template(cmd, dev_type=None):
+    """
+    :param dev_type: Type of device ie cisco_ios, arista_eos
+    :type  dev_type: str
+    :param cmd: CLI command to load template.
+    :type  cmd: str
+    :returns: String template path
+    """
+    try:
+        with open(get_template_path(cmd, dev_type=dev_type), "rb") as f:
+            return textfsm.TextFSM(f)
+    except:
+        log.msg(f"Unable to load template:\n{cmd} :: {dev_type}")
+
+
+def get_textfsm_object(re_table, cli_output):
+    "Returns structure object from TextFSM data."
+    from collections import defaultdict
+
+    rv = defaultdict(list)
+    keys = re_table.header
+    values = re_table.ParseText(cli_output)
+    l = []
+    for item in values:
+        l.extend(zip(map(lambda x: x.lower(), keys), item))
+
+    for k, v in l:
+        rv[k].append(v)
+
+    return dict(rv)

trigger/utils/url.py

@@ -0,0 +1,78 @@
+"""
+Utilities for parsing/handling URLs
+"""
+
+__author__ = "Jathan McCollum"
+__maintainer__ = "Jathan McCollum"
+__email__ = "jathan.mccollum@teamaol.com"
+__copyright__ = "Copyright 2013, AOL Inc."
+__version__ = "0.1"
+
+from urllib.parse import parse_qsl, unquote, urlparse
+
+
+def _parse_url(url):
+    """
+    Guts for `~trigger.utils.url.parse_url`.
+
+    Based on Kombu's ``kombu.utils.url``.
+    Source: http://bit.ly/11UFcfH
+    """
+    parts = urlparse(url)
+    scheme = parts.scheme
+    port = parts.port or None
+    hostname = parts.hostname
+    path = parts.path or ""
+    virtual_host = path[1:] if path and path[0] == "/" else path
+    return (
+        scheme,
+        unquote(hostname or "") or None,
+        port,
+        unquote(parts.username or "") or None,
+        unquote(parts.password or "") or None,
+        unquote(path or "") or None,
+        unquote(virtual_host or "") or None,
+        unquote(parts.query or "") or None,
+        dict(dict(parse_qsl(parts.query))),
+    )
+
+
+def parse_url(url):
+    """
+    Given a ``url`` returns, a dict of its constituent parts.
+
+    Based on Kombu's ``kombu.utils.url``.
+    Source: http://bit.ly/11UFcfH
+
+    :param url:
+        Any standard URL. (file://, https://, etc.)
+    """
+    scheme, host, port, user, passwd, path, vhost, qs, qs_dict = _parse_url(url)
+    return dict(
+        scheme=scheme,
+        hostname=host,
+        port=port,
+        username=user,
+        password=passwd,
+        path=path,
+        virtual_host=vhost,
+        query=qs,
+        **qs_dict,
+    )
+
+
+if __name__ == "__main__":
+    tests = (
+        "https://username:password@myhost.aol.com:12345?limit=10&vendor=cisco#develop",
+        "file:///usr/local/etc/netdevices.xml",
+        "/usr/local/etc/netdevices.xml",
+        "mysql://dbuser:dbpass@dbhost.com:3306/",
+        "http://jathan:password@api.foo.com/netdevices/?limit=10&device_type=switch&vendor=cisco&format=json",
+    )
+
+    import pprint
+
+    for test in tests:
+        print(test)
+        pprint.pprint(parse_url(test))
+        print

trigger/utils/xmltodict.py

@@ -0,0 +1,298 @@
+#!/usr/bin/env python
+"Makes working with XML feel like you are working with JSON"
+
+from xml.parsers import expat
+from xml.sax.saxutils import XMLGenerator
+from xml.sax.xmlreader import AttributesImpl
+
+try:  # pragma no cover
+    from cStringIO import StringIO
+except ImportError:  # pragma no cover
+    try:
+        from StringIO import StringIO
+    except ImportError:
+        from io import StringIO
+try:  # pragma no cover
+    from collections import OrderedDict
+except ImportError:  # pragma no cover
+    OrderedDict = dict
+
+try:  # pragma no cover
+    _basestring = basestring
+except NameError:  # pragma no cover
+    _basestring = str
+try:  # pragma no cover
+    _unicode = unicode
+except NameError:  # pragma no cover
+    _unicode = str
+
+__author__ = "Martin Blech"
+__version__ = "0.4.6"
+__license__ = "MIT"
+
+
+class ParsingInterrupted(Exception):
+    pass
+
+
+class _DictSAXHandler:
+    def __init__(
+        self,
+        item_depth=0,
+        item_callback=lambda *args: True,
+        xml_attribs=True,
+        attr_prefix="@",
+        cdata_key="#text",
+        force_cdata=False,
+        cdata_separator="",
+        postprocessor=None,
+        dict_constructor=OrderedDict,
+        strip_whitespace=True,
+    ):
+        self.path = []
+        self.stack = []
+        self.data = None
+        self.item = None
+        self.item_depth = item_depth
+        self.xml_attribs = xml_attribs
+        self.item_callback = item_callback
+        self.attr_prefix = attr_prefix
+        self.cdata_key = cdata_key
+        self.force_cdata = force_cdata
+        self.cdata_separator = cdata_separator
+        self.postprocessor = postprocessor
+        self.dict_constructor = dict_constructor
+        self.strip_whitespace = strip_whitespace
+
+    def startElement(self, name, attrs):
+        attrs = self.dict_constructor(zip(attrs[0::2], attrs[1::2]))
+        self.path.append((name, attrs or None))
+        if len(self.path) > self.item_depth:
+            self.stack.append((self.item, self.data))
+            if self.xml_attribs:
+                attrs = self.dict_constructor(
+                    (self.attr_prefix + key, value) for (key, value) in attrs.items()
+                )
+            else:
+                attrs = None
+            self.item = attrs or None
+            self.data = None
+
+    def endElement(self, name):
+        if len(self.path) == self.item_depth:
+            item = self.item
+            if item is None:
+                item = self.data
+            should_continue = self.item_callback(self.path, item)
+            if not should_continue:
+                raise ParsingInterrupted()
+        if len(self.stack):
+            item, data = self.item, self.data
+            self.item, self.data = self.stack.pop()
+            if self.strip_whitespace and data is not None:
+                data = data.strip() or None
+            if data and self.force_cdata and item is None:
+                item = self.dict_constructor()
+            if item is not None:
+                if data:
+                    self.push_data(item, self.cdata_key, data)
+                self.item = self.push_data(self.item, name, item)
+            else:
+                self.item = self.push_data(self.item, name, data)
+        else:
+            self.item = self.data = None
+        self.path.pop()
+
+    def characters(self, data):
+        if not self.data:
+            self.data = data
+        else:
+            self.data += self.cdata_separator + data
+
+    def push_data(self, item, key, data):
+        if self.postprocessor is not None:
+            result = self.postprocessor(self.path, key, data)
+            if result is None:
+                return item
+            key, data = result
+        if item is None:
+            item = self.dict_constructor()
+        try:
+            value = item[key]
+            if isinstance(value, list):
+                value.append(data)
+            else:
+                item[key] = [value, data]
+        except KeyError:
+            item[key] = data
+        return item
+
+
+def parse(xml_input, encoding="utf-8", *args, **kwargs):
+    """Parse the given XML input and convert it into a dictionary.
+
+    `xml_input` can either be a `string` or a file-like object.
+
+    If `xml_attribs` is `True`, element attributes are put in the dictionary
+    among regular child elements, using `@` as a prefix to avoid collisions. If
+    set to `False`, they are just ignored.
+
+    Simple example::
+
+        >>> doc = xmltodict.parse(\"\"\"
+        ... <a prop="x">
+        ...   <b>1</b>
+        ...   <b>2</b>
+        ... </a>
+        ... \"\"\")
+        >>> doc['a']['@prop']
+        u'x'
+        >>> doc['a']['b']
+        [u'1', u'2']
+
+    If `item_depth` is `0`, the function returns a dictionary for the root
+    element (default behavior). Otherwise, it calls `item_callback` every time
+    an item at the specified depth is found and returns `None` in the end
+    (streaming mode).
+
+    The callback function receives two parameters: the `path` from the document
+    root to the item (name-attribs pairs), and the `item` (dict). If the
+    callback's return value is false-ish, parsing will be stopped with the
+    :class:`ParsingInterrupted` exception.
+
+    Streaming example::
+
+        >>> def handle(path, item):
+        ...     print 'path:%s item:%s' % (path, item)
+        ...     return True
+        ...
+        >>> xmltodict.parse(\"\"\"
+        ... <a prop="x">
+        ...   <b>1</b>
+        ...   <b>2</b>
+        ... </a>\"\"\", item_depth=2, item_callback=handle)
+        path:[(u'a', {u'prop': u'x'}), (u'b', None)] item:1
+        path:[(u'a', {u'prop': u'x'}), (u'b', None)] item:2
+
+    The optional argument `postprocessor` is a function that takes `path`, `key`
+    and `value` as positional arguments and returns a new `(key, value)` pair
+    where both `key` and `value` may have changed. Usage example::
+
+        >>> def postprocessor(path, key, value):
+        ...     try:
+        ...         return key + ':int', int(value)
+        ...     except (ValueError, TypeError):
+        ...         return key, value
+        >>> xmltodict.parse('<a><b>1</b><b>2</b><b>x</b></a>',
+        ...                 postprocessor=postprocessor)
+        OrderedDict([(u'a', OrderedDict([(u'b:int', [1, 2]), (u'b', u'x')]))])
+
+    """
+    handler = _DictSAXHandler(*args, **kwargs)
+    parser = expat.ParserCreate()
+    parser.ordered_attributes = True
+    parser.StartElementHandler = handler.startElement
+    parser.EndElementHandler = handler.endElement
+    parser.CharacterDataHandler = handler.characters
+    try:
+        parser.ParseFile(xml_input)
+    except (TypeError, AttributeError):
+        if isinstance(xml_input, _unicode):
+            xml_input = xml_input.encode(encoding)
+        parser.Parse(xml_input, True)
+    return handler.item
+
+
+def _emit(
+    key,
+    value,
+    content_handler,
+    attr_prefix="@",
+    cdata_key="#text",
+    root=True,
+    preprocessor=None,
+):
+    if preprocessor is not None:
+        result = preprocessor(key, value)
+        if result is None:
+            return
+        key, value = result
+    if not isinstance(value, (list, tuple)):
+        value = [value]
+    if root and len(value) > 1:
+        raise ValueError("document with multiple roots")
+    for v in value:
+        if v is None:
+            v = OrderedDict()
+        elif not isinstance(v, dict):
+            v = _unicode(v)
+        if isinstance(v, _basestring):
+            v = OrderedDict(((cdata_key, v),))
+        cdata = None
+        attrs = OrderedDict()
+        children = []
+        for ik, iv in v.items():
+            if ik == cdata_key:
+                cdata = iv
+                continue
+            if ik.startswith(attr_prefix):
+                attrs[ik[len(attr_prefix) :]] = iv
+                continue
+            children.append((ik, iv))
+        content_handler.startElement(key, AttributesImpl(attrs))
+        for child_key, child_value in children:
+            _emit(
+                child_key,
+                child_value,
+                content_handler,
+                attr_prefix,
+                cdata_key,
+                False,
+                preprocessor,
+            )
+        if cdata is not None:
+            content_handler.characters(cdata)
+        content_handler.endElement(key)
+
+
+def unparse(item, output=None, encoding="utf-8", **kwargs):
+    ((key, value),) = item.items()
+    must_return = False
+    if output is None:
+        output = StringIO()
+        must_return = True
+    content_handler = XMLGenerator(output, encoding)
+    content_handler.startDocument()
+    _emit(key, value, content_handler, **kwargs)
+    content_handler.endDocument()
+    if must_return:
+        value = output.getvalue()
+        try:  # pragma no cover
+            value = value.decode(encoding)
+        except AttributeError:  # pragma no cover
+            pass
+        return value
+
+
+if __name__ == "__main__":  # pragma: no cover
+    import marshal
+    import sys
+
+    (item_depth,) = sys.argv[1:]
+    item_depth = int(item_depth)
+
+    def handle_item(path, item):
+        marshal.dump((path, item), sys.stdout)
+        return True
+
+    try:
+        root = parse(
+            sys.stdin,
+            item_depth=item_depth,
+            item_callback=handle_item,
+            dict_constructor=dict,
+        )
+        if item_depth == 0:
+            handle_item([], root)
+    except KeyboardInterrupt:
+        pass