Convert to package

1 files changed, 197 insertions, 0 deletions

diff --git a/log_raider/jenkins.py b/log_raider/jenkins.py
new file mode 100644
index 0000000..16096a5
--- /dev/null
+++ b/log_raider/jenkins.py
@@ -0,0 +1,197 @@
+import argparse
+import json
+import os
+import sys
+from . import __version__
+
+PIPELINE_VERBOSE = False
+PIPELINE_MARKER = "[Pipeline]"
+PIPELINE_BLOCK_START = '{'
+PIPELINE_BLOCK_END = '}'
+PIPELINE_BLOCK_START_NOTE = '('
+PIPELINE_BLOCK_START_NOTE_END = ')'
+PIPELINE_BLOCK_END_NOTE = "//"
+
+
+def consume_token(s, token, l_trunc=0, r_trunc=0, strip_leading=True):
+    """
+    :param s: String to scan
+    :param token: Substring to target
+    :param l_trunc: Truncate chars from left; Positive integer
+    :param r_trunc: Truncate chars from right; Positive integer
+    :param strip_leading: Remove leading whitespace
+    :return: Modified input string
+    """
+    s_len = len(s)
+    token_len = len(token)
+    result = s[l_trunc + s.find(token) + token_len:s_len - r_trunc]
+
+    if strip_leading:
+        result = result.strip()
+
+    return result
+
+
+def printv(*args, **kwargs):
+    if PIPELINE_VERBOSE:
+        print(*args, *kwargs)
+
+
+def parse_log(filename):
+    """
+    Parse a Jenkins pipeline log and return information about each logical section
+    :param filename: path to log file
+    :return: list of section dictionaries
+    """
+    section_defaults = {
+        "type": "",
+        "name": "",
+        "data": "",
+        "depth": 0,
+    }
+    depth = 0
+    master_log = False
+    last_name = ""
+    last_type = ""
+    section = section_defaults.copy()
+    result = list()
+
+    # Reducing code duplication and trying to increase readability with "macro" like functions here.
+    # Don't move these.
+    def is_pipeline(lobj):
+        return lobj[0].startswith(PIPELINE_MARKER)
+
+    def is_pipeline_block_start(lobj):
+        return lobj[0] == PIPELINE_BLOCK_START
+
+    def is_pipeline_block_start_note(lobj):
+        return lobj[0].startswith(PIPELINE_BLOCK_START_NOTE)
+
+    def is_pipeline_block_end(lobj):
+        return lobj[0] == PIPELINE_BLOCK_END
+
+    def is_pipeline_block_end_note(lobj):
+        return lobj[0] == PIPELINE_BLOCK_END_NOTE
+
+    def commit(block):
+        if block != section_defaults:
+            if not block["name"]:
+                block["name"] = last_name
+            if not block["type"]:
+                block["type"] = last_type
+            block["depth"] = depth
+            block["line"] = lineno
+            result.append(block)
+            block = section_defaults.copy()
+        return block
+
+    # Parsing begins
+    for lineno, line in enumerate(open(filename, "r").readlines()):
+        line = line.strip()
+        if not line:
+            continue
+
+        # Format:
+        #  [Pipeline]\ {?}?\ (?STRING?|\/\/\ COMMENT?)?
+        #
+        # The first two arguments are important.
+        #  1) Is it a pipeline log record?
+        #  2) Is it a block start/end/comment?
+        # All string data beyond this point is considered a section "name" or "type"
+        data = line.split(" ", 2)
+
+        if is_pipeline(data):
+            # Parsing: [Pipeline]
+            # Information related to the groovy pipeline is always preceded by: [Pipeline]
+            if master_log:
+                section = commit(section)
+
+            master_log = False
+            section = commit(section)
+            data = data[1:]
+
+            if is_pipeline_block_end(data):
+                # Parsing: [Pipeline] }
+                depth -= 1
+                printv("DEPTH ::", depth)
+                if section != section_defaults:
+                    section = commit(section)
+            elif is_pipeline_block_end_note(data):
+                # Ignoring: [Pipeline] // NAME HERE
+                pass
+            elif is_pipeline_block_start(data):
+                # Parsing: [Pipeline] {
+                depth += 1
+                printv("DEPTH ::", depth)
+
+                if len(data) == 2:
+                    # Parsing: [Pipeline] { (NAME HERE)
+                    # Read the stage name.
+                    # Stage names are preceded by a "{" and the literal name is encapsulated by parenthesis
+                    x = data[1:]
+                    if is_pipeline_block_start_note(x):
+                        section["name"] = consume_token(x[0], PIPELINE_BLOCK_START_NOTE, r_trunc=1)
+                        last_name = section["name"]
+                        printv("NAME  ::", section["name"])
+            elif len(data) == 1:
+                # Parsing: [Pipeline] NAME HERE
+                # A standalone string without a preceding "{" denotes the type of step being executed
+                section["type"] = data[0]
+                last_type = section["type"]
+                printv("TYPE  ::", section["type"])
+
+            # Finished with [Pipeline] data for now... see if there's more
+            continue
+
+        if not depth and not is_pipeline(line):
+            # Parser depth begins at zero. Trigger only when a line doesn't begin with: [Pipeline]
+            master_log = True
+            section["name"] = "master"
+            section["type"] = "masterLog"
+            section["data"] += line + "\n"
+            section["depth"] = depth
+        else:
+            # Consume raw log data at current depth
+            section["type"] = last_type
+            section["data"] += line + "\n"
+            printv("RAW   ::", line)
+
+    # Save any data appearing after: [Pipeline] End of Pipeline
+    # This data belongs to the master node
+    commit(section)
+
+    return result
+
+
+def main():
+    global PIPELINE_VERBOSE
+    parser = argparse.ArgumentParser()
+    parser.add_argument("-j", "--json", action="store_true", help="Emit JSON")
+    parser.add_argument("-v", "--verbose", action="store_true", help="Increase verbosity")
+    parser.add_argument("-V", "--version", action="store_true", help="Show version")
+    parser.add_argument("logfile", nargs='?')
+
+    args = parser.parse_args()
+
+    if args.version:
+        print(__version__)
+        exit(0)
+
+    if not os.path.exists(args.logfile):
+        print(f"{args.logfile}: does not exist")
+
+    PIPELINE_VERBOSE = args.verbose
+    data = parse_log(args.logfile)
+
+    if args.json:
+        print(json.dumps(data, indent=2))
+    else:
+        for x in data:
+            print("#" * 79)
+            print(f"{x['type']} - {x['name']} (line @ {x['line']})")
+            print("#" * 79)
+            print(f"{x['data']}")
+
+
+if __name__ == "__main__":
+    sys.exit(main())