skilleter-thingy 0.3.14__py3-none-any.whl

skilleter_thingy/tfparse.py

@@ -0,0 +1,101 @@
+#! /usr/bin/env python3
+
+"""
+Read JSON Terraform output and convert back to human-readable text
+This allows multiple errors and warnings to be reported as there's
+no way of doing this directly from Terraform
+"""
+
+import os
+import sys
+import json
+import argparse
+from collections import defaultdict
+
+from skilleter_modules import colour
+
+################################################################################
+
+def error(msg, status=1):
+    """Report an error and quit"""
+
+    colour.write(f'[RED:ERROR]: {msg}')
+    sys.exit(status)
+
+################################################################################
+
+def main():
+    """Everything"""
+
+    # Command line is either empty or contains the input file
+
+    parser = argparse.ArgumentParser(description='Convert Terraform JSON output back into human-readable text')
+    parser.add_argument('--abspath', '-a', action='store_true', help='Output absolute file paths')
+    parser.add_argument('infile', nargs='*', help='The error file (defaults to standard input if not specified)')
+
+    args = parser.parse_args()
+
+    # Open the input file or use stdin and read the JSON
+
+    jsonfile = open(args.infile[0], 'rt') if args.infile else sys.stdin
+
+    terraform = json.loads(jsonfile.read())
+
+    # Collect each of the error/warnings
+
+    report = defaultdict(list)
+
+    if 'diagnostics' in terraform:
+        for diagnostics in terraform['diagnostics']:
+            severity = diagnostics['severity'].title()
+
+            if 'range' in diagnostics:
+                file_path = os.path.abspath(diagnostics['range']['filename']) if args.abspath else diagnostics['range']['filename']
+
+            category = f'{severity}: {diagnostics["summary"]} - {diagnostics["detail"]}'
+
+            message = ''
+            if 'range' in diagnostics:
+                message += f'In [BLUE:{file_path}:{diagnostics["range"]["start"]["line"]}]'
+
+            if 'address' in diagnostics:
+                message += f' in [BLUE:{diagnostics["address"]}]'
+
+            report[category].append(message)
+
+    for category in report:
+        colour.write()
+
+        # Fudge emboldening multi-line warnings
+
+        formatted_category = '[BOLD:' + category.replace('\n', ']\n[BOLD:') + ']'
+        colour.write(formatted_category)
+
+        for entry in sorted(report[category]):
+            colour.write(f'    {entry}')
+
+    # Summarise the results
+
+    error_count = terraform.get('error_count', 0)
+    warning_count = terraform.get('warning_count', 0)
+
+    colour.write()
+    colour.write(f'[BOLD:Summary:] [BLUE:{error_count}] [BOLD:errors and] [BLUE:{warning_count}] [BOLD:warnings]')
+
+################################################################################
+
+def tfparse():
+    """Entry point"""
+
+    try:
+        main()
+
+    except KeyboardInterrupt:
+        sys.exit(1)
+    except BrokenPipeError:
+        sys.exit(2)
+
+################################################################################
+
+if __name__ == '__main__':
+    tfparse()

skilleter_thingy/trimpath.py

@@ -0,0 +1,82 @@
+#! /usr/bin/env python3
+
+################################################################################
+""" Thingy trimpath command
+
+    Copyright (C) 2017 John Skilleter
+
+    Given a path, truncate it to less than 25% of the width of the console by
+    replacing intermediate directories with '...' """
+################################################################################
+
+import sys
+import os
+import argparse
+import shutil
+import logging
+
+from skilleter_modules import path
+
+################################################################################
+
+def main():
+    """ Trim a path to a specified width """
+
+    # Set up the command line parser
+
+    parser = argparse.ArgumentParser(description='Trim a path for display to a specified with by replacing intermediate directory names with "..."')
+
+    parser.add_argument('--width', '-w', default=None, help='Specify the width to trim to the path to. Default is 25% of the current console width')
+    parser.add_argument('path', nargs='?', default=None, help='The path to trim. Default is the current directory')
+    parser.add_argument('--debug', action='store_true', help='Enable debug output')
+
+    args = parser.parse_args()
+
+    if args.debug:
+        logging.basicConfig(level=logging.DEBUG)
+
+    # Set the width, defaulting to 25% of the console width
+
+    if args.width:
+        try:
+            trim_width = int(args.width)
+        except ValueError:
+            trim_width = -1
+
+        if trim_width <= 0:
+            logging.critical('Invalid width: "%s"', args.width)
+            sys.exit(1)
+    else:
+        console = shutil.get_terminal_size()
+        trim_width = console.columns // 4
+
+    # Set the path, defaulting to the current directory
+
+    try:
+        full_path = args.path or os.getcwd()
+    except FileNotFoundError:
+        logging.critical('Unable to locate directory')
+        sys.exit(1)
+
+    trimmed = path.trimpath(full_path, trim_width)
+
+    sys.stdout.write(trimmed)
+
+################################################################################
+
+def trimpath():
+    """Entry point"""
+
+    try:
+        main()
+    except KeyboardInterrupt:
+        sys.exit(1)
+    except BrokenPipeError:
+        sys.exit(2)
+    except Exception:
+        sys.exit(3)
+
+################################################################################
+
+if __name__ == '__main__':
+    trimpath()

skilleter_thingy/venv_create.py

@@ -0,0 +1,47 @@
+#!/usr/bin/env python3
+
+import sys
+import os
+import stat
+import argparse
+
+from skilleter_modules import venv_template
+
+################################################################################
+
+def main():
+    """Create the venv script and make it executable"""
+
+    parser = argparse.ArgumentParser(description='Create a script to run Python code in a virtual environment')
+    parser.add_argument('name', nargs=1, help='Name of the script to create')
+
+    args = parser.parse_args()
+
+    script = args.name[0]
+
+    with open(script, 'wt') as scriptfile:
+        scriptfile.write(venv_template.TEMPLATE)
+
+    statinfo = os.stat(script)
+
+    os.chmod(script, statinfo.st_mode | stat.S_IXUSR | stat.S_IXGRP | stat.S_IXOTH)
+
+    print(f'Created virtual environment: {script}')
+
+################################################################################
+
+def venv_create():
+    """Entry point"""
+
+    try:
+        main()
+
+    except KeyboardInterrupt:
+        sys.exit(1)
+    except BrokenPipeError:
+        sys.exit(2)
+
+################################################################################
+
+if __name__ == '__main__':
+    venv_create()

skilleter_thingy/venv_template.py

@@ -0,0 +1,47 @@
+TEMPLATE = \
+r"""#!/usr/bin/env bash
+
+set -e
+
+################################################################################
+
+VENV_NAME=$(basename "$0")
+VENV_DIR=__venv__
+
+GREEN="\e[42m"
+NORMAL="\e[0m"
+
+################################################################################
+
+function box()
+{
+   echo -e "${GREEN}################################################################################${NORMAL}"
+   echo -e "${GREEN}# $@${NORMAL}"
+   echo -e "${GREEN}################################################################################${NORMAL}"
+}
+
+################################################################################
+
+box "Creating & activating $VENV_NAME virtual environment"
+
+python3 -m venv $VENV_DIR
+
+source $VENV_DIR/bin/activate
+
+if [[ -f requirements.txt ]]
+then
+   box "Installing/Upgrading packages"
+
+   python3 -m pip install -r requirements.txt
+fi
+
+if [[ -f ${VENV_NAME} ]]
+then
+    box "Running ${VENV_NAME} script"
+
+    python3 ./${VENV_NAME}.py "$@"
+
+    deactivate
+fi
+"""
+

skilleter_thingy/xchmod.py

@@ -0,0 +1,124 @@
+#! /usr/bin/env python3
+
+################################################################################
+""" xchmod - Equivalent to chmod but only modifies files that do not
+             have the correct permissions - chmod will just set all to the
+             correct permissions regardless of current permissions and update
+             the file last-changed date whether or not the file has changed.
+
+    Initial version has MAJOR RESTRICTIONS: It only allows permissions
+    of 'a+rw' and applies them to all files and directories in the specified
+    path and must be run with -R/--recursive.
+
+    TODO: [ ] Support all file modes as per chmod
+    TODO: [ ] Support all command line options of chmod
+    TODO: [ ] Implement non-recursive mode
+    TODO: [ ] Options for files/directories only
+
+    Copyright (C) 2017 John Skilleter
+
+    Licence: GPL v3 or later
+"""
+################################################################################
+
+import os
+import sys
+import stat
+import argparse
+
+################################################################################
+# Constants
+
+# Required mode for files
+
+MODE_ALL_RW = stat.S_IRUSR | stat.S_IWUSR | stat.S_IRGRP | stat.S_IWGRP | stat.S_IROTH | stat.S_IWOTH
+
+MODE_ALL_RW_DIR = MODE_ALL_RW | stat.S_IXUSR | stat.S_IXGRP | stat.S_IXOTH
+
+################################################################################
+
+def set_mode(filepath, mode, debug, verbose):
+    """ Given the name of a file, the required mode and verbose
+        and debug flags, attempt to set the mode of the file if it does not
+        already have the specified mode bits set (it currently only sets
+        mode bits - it will not unset them)
+
+        If verbose or debug are true then the operation is reported
+        If debug is true the operation is not performed """
+
+    # File mode (the bits that can be changed via chmod)
+
+    filemode = stat.S_IMODE(os.stat(filepath).st_mode)
+
+    # If the current mode doesn't have all the right bits set
+    # then either report it or set them (leaving other bits unchanged)
+
+    if (filemode & mode) != mode:
+
+        newfilemode = filemode | mode
+
+        if verbose or debug:
+            print('%s (%03o -> %03o)' % (filepath, filemode, newfilemode))
+
+        if not debug:
+            os.chmod(filepath, newfilemode)
+
+################################################################################
+
+def make_public():
+    """ Search and make public everything in the paths specified on the command
+        line """
+
+    parser = argparse.ArgumentParser(description='Locate files that are not publically writeable and make them so')
+
+    parser.add_argument('--debug', action='store_true', help='Output the list of files (if any) that need to be made publically writeable')
+    parser.add_argument('--verbose', action='store_true', help='List files as they are updated')
+    parser.add_argument('--recursive', '-R', action='store_true', help='Operate recursively')
+    parser.add_argument('mode', help='Mode to set')
+    parser.add_argument('paths', nargs='+', help='List of directory paths to search')
+
+    args = parser.parse_args()
+
+    # We only support a+rw in the first version! Future versions will allow all mode types
+    # and command line options supported by the chmod command.
+
+    if args.mode != 'a+rw':
+        sys.stderr.write('Invalid mode "%s" - currently ONLY a+rw is supported\n' % args.mode)
+        sys.exit(1)
+
+    if not args.recursive:
+        sys.stderr.write('Invalid command line - recursive option currently MUST be specified\n')
+        sys.exit(1)
+
+    # Make sure that we aren't doing anything reckless
+
+    for path in args.paths:
+        if os.path.abspath(path) == '/':
+            sys.stderr.write('You cannot recurse from the root directory\n')
+            sys.exit(1)
+
+    # Process each path and each directory and each file & directory in each directory
+
+    for path in args.paths:
+        for root, dirs, files in os.walk(path):
+            for filename in files:
+                set_mode(os.path.join(root, filename), MODE_ALL_RW, args.debug, args.verbose)
+
+            for dirname in dirs:
+                set_mode(os.path.join(root, dirname) + '/', MODE_ALL_RW_DIR, args.debug, args.verbose)
+
+################################################################################
+
+def xchmod():
+    """Entry point"""
+    try:
+        make_public()
+    except KeyboardInterrupt:
+        sys.exit(1)
+    except BrokenPipeError:
+        sys.exit(2)
+
+################################################################################
+
+if __name__ == '__main__':
+    xchmod()

skilleter_thingy/yamlcheck.py

@@ -0,0 +1,89 @@
+#! /usr/bin/env python3
+
+################################################################################
+""" Basic YML validator
+
+    Copyright (C) 2017, 2018 John Skilleter
+    """
+################################################################################
+
+import sys
+import argparse
+
+import yaml
+
+################################################################################
+
+def yaml_process(name, data):
+    """ Recursive yaml nosher """
+
+    if isinstance(data, dict):
+        for item in data:
+            yaml_process('%s::%s' % (name, item), data[item])
+    else:
+        print('%s: %s' % (name, data))
+
+################################################################################
+
+def main():
+    """ Parse the command line - just takes one option (to dump the file after
+        successfully parsing it) and a list of 1 or more files to parse """
+
+    parser = argparse.ArgumentParser(description='Validate one or more YAML source files')
+    parser.add_argument('--dump', action='store_true', help='Dump the YAML data after parsing it')
+    parser.add_argument('--block', action='store_true', help='Force block style when dumping the YAML data')
+    parser.add_argument('--flow', action='store_true', help='Force flow style when dumping the YAML data')
+    parser.add_argument('--hiera', action='store_true', help='Process the file as Puppet Hiera data')
+    parser.add_argument('files', nargs='+', help='YAML source file')
+    args = parser.parse_args()
+
+    if args.block and args.flow:
+        sys.stderr.write('You cannot specify both block and flow style output')
+
+    if args.block:
+        flow_style = False
+    elif args.flow:
+        flow_style = True
+    else:
+        flow_style = None
+
+    # Try to parse each file, optionally dumping the result back to stdout
+    # and catching and reporting exceptions
+
+    for filename in args.files:
+        try:
+            for yaml_data in yaml.safe_load_all(open(filename)):
+
+                if args.dump:
+                    if len(args.files) > 1:
+                        print('File: %s' % filename)
+
+                    print(yaml.dump(yaml_data, default_flow_style=flow_style))
+
+                if args.hiera:
+                    for data in yaml_data:
+                        yaml_process(data, yaml_data[data])
+
+        except yaml.YAMLError as exc:
+            sys.stderr.write('Error: %s\n' % exc)
+
+        except IOError:
+            sys.stderr.write('Error reading %s\n' % filename)
+            sys.exit(2)
+
+################################################################################
+
+def yamlcheck():
+    """Entry point"""
+
+    try:
+        main()
+    except KeyboardInterrupt:
+        sys.exit(1)
+    except BrokenPipeError:
+        sys.exit(2)
+
+################################################################################
+
+if __name__ == '__main__':
+    yamlcheck()