#!/usr/bin/env python3

# vim:ts=4:sts=4:sw=4:et

#

# Author: Hari Sekhon

# Date: 2016-05-20 20:24:12 +0100 (Fri, 20 May 2016)

#

# https://github.com/HariSekhon/DevOps-Python-tools

#

# License: see accompanying Hari Sekhon LICENSE file

#

# If you're using my code you're welcome to connect with me on LinkedIn and optionally send me feedback

# to help improve or steer this or other code I publish

#

# https://www.linkedin.com/in/HariSekhon

#

r"""

Tool to validate Git branches are aligned with any Dockerfiles in that revision which correspond with the brancVh prefix

Recurses any given directories to find all Dockerfiles and checks their ARG *_VERSION line in each branch

to ensure they're both aligned.

This requires the git branching and Dockerfile ARG to be aligned in such as way that 'ARG NAME_VERSION=<version>'

corresponds to Git branch 'NAME-<version>' where NAME matches regex '\w+' and <version> is in the form 'x.y[.z]' where

if git branch is at least a prefix of the Dockerfiles ARG version (eg. solr-4 matches ARG SOLR_VERSION=4 and ARG

SOLR_VERSION=4.10).

Additionally, git branches of NAME-dev-<version> are stripped of '-dev' and assumed to still use ARG NAME_VERSION, and

the parent directory name for the Dockerfile must match the branch base without the version (but including the -dev

part) in order to disambiguate between things like SOLRCLOUD_VERSION for either solrcloud/Dockerfile or

solrcloud-dev/Dockerfile.

Beware this will attempt to do a git checkout of all branches and test containing Dockerfiles under given paths in each

branch revision. If the git checkout is 'dirty' (ie has uncommitted changes) it will prevent checking out the branch,

the program will detect this and exit, leaving you to decide what to do. In normal circumstances it will return to the

original branch/branch checkout when complete.

Prematurely terminating this program can leave the git checkout in an inconsistent state, although all catchable

exceptions are caught to return to original state. If you end up in an inconsistent state just git reset and do a

manual checkout back to master.

Recommended to run this on a non-working git checkout to make it easy to reset state and avoid dirty git checkout

issues eg. run inside your CI system or a secondary git clone location.

Originally this worked on a file-by-file basis which is better when recursing directories across git submodules, but

was the least efficient way of doing it so I've rewritten it to do a single pass of all branches and check all

Dockerfiles in given directories, hence it's more efficient to give this program the directory containing the

Dockerfiles than each individual Dockerfile which would result in a similar behaviour to the original, multiplying each

Dockerfile by the number of branches and doing that many checkouts.

It is more efficient to give a directory tree of Dockerfiles than individual Dockerfiles... but the caveat is that they

must all be contained in the same Git repo (not crossing git submodule boundaries etc, otherwise you must do a

'find -exec' using this program instead).

There are a couple extra conditions now too - instead of checking ARG {NAME}_VERSION where {NAME} matches branch base,

this turns out to be too restrictive for branches with multiple versions like kafka-2.10-0.9 so this program now

expects that ARG {NAME}_VERSION is in the same order as the versions of the branch name, ie SCALA_VERSION comes before

KAFKA_VERSION to match the branch's version order.

This is one of the my less generic tools in the public domain. It requires your use of git branches matches your use of

Dockerfile ARG. You're welcome to modify it to suit your needs or make it more generic (in which case please

re-submit improvements in the form of GitHub pull requests).

This was primarily written to test the Dockerfiles repository at https://github.com/HariSekhon/Dockerfiles

"""

from __future__ import absolute_import

from __future__ import division

from __future__ import print_function

#from __future__ import unicode_literals

import logging

import os

import re

import sys

import traceback

import git

libdir = os.path.abspath(os.path.join(os.path.dirname(__file__), 'pylib'))

sys.path.append(libdir)

try:

# pylint: disable=wrong-import-position

from harisekhon.utils import die, ERRORS, log, log_option

from harisekhon.utils import find_git_root, uniq_list_ordered, isVersion, validate_regex, version_regex

from harisekhon import CLI

except ImportError as _:

print('module import failed: %s' % _, file=sys.stderr)

print("Did you remember to build the project by running 'make'?", file=sys.stderr)

print("Alternatively perhaps you tried to copy this program out without it's adjacent libraries?", file=sys.stderr)

sys.exit(4)

__author__ = 'Hari Sekhon'

__version__ = '0.7.3'

class DockerfileGitBranchCheckTool(CLI):

return True

if __name__ == '__main__':

DockerfileGitBranchCheckTool().main()