#!/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 tags are aligned with any Dockerfiles in that revision which correspond with the tag prefix

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

to ensure they're both aligned.

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

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

git tag 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 tags 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 tag 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/Docekrfile

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

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

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

branch/tag 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 tags 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 tags 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).

This is one of the my less generic tools in the public domain. It requires your use of git tags 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 for GitHub pull requests).

"""

from __future__ import absolute_import

from __future__ import division

from __future__ import print_function

#from __future__ import unicode_literals

import os

import re

import sys

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, find_git_root, log, log_option

from harisekhon.utils import uniq_list_ordered, isVersion, validate_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.5.2'

class DockerfileGitTagCheckTool(CLI):

return True

# a per file method, better for recursing across git submodules but much more brute force as a cartesian product of

# tags vs Dockerfiles rather than a single pass of tags within one repo

#

# def check_dockerfile_git_tags(self, filename):

# filename = os.path.abspath(filename)

# gitroot = self.find_git_root(filename)

# log.debug("finding tags for file '{0}' from git root '{1}'".format(filename, gitroot))

# repo = git.Repo(gitroot)

# tags = [str(_).split('/')[-1] for _ in repo.tags]

# #if log.isEnabledFor(logging.DEBUG):

# log.debug('\n\ntags for Dockerfile %s:\n\n%s\n', filename, '\n'.join(tags))

# dirname = os.path.dirname(filename)

# original_dir = os.getcwd()

# log.debug('cd %s', dirname)

# os.chdir(dirname)

# original_checkout = 'master'

# try:

# try:

# original_checkout = repo.active_branch.name

# except TypeError as _:

# pass

# for tag in repo.tags:

# log.debug("checking file '%s' checking out tag '%s'", filename, tag)

# try:

# repo.git.checkout(tag)

# except git.exc.GitCommandError as _:

# die(_)

# try:

# if not self.check_dockerfile_arg(filename, tag):

# self.failed = True

# print(self.invalid_git_tags_msg)

# return False

# except IOError as _:

# log.warn(str(_) + " ('{0}' probably doesn't exist in tag revision '{1}')".format(filename, tag))

# print(self.valid_git_tags_msg)

# return True

# except Exception as _:

# die(_)

# finally:

# log.debug("returning to original checkout '%s'", original_checkout)

# repo.git.checkout(original_checkout)

# log.debug("cd %s", original_dir)

# os.chdir(original_dir)

if __name__ == '__main__':

DockerfileGitTagCheckTool().main()