docker-hook

#! /usr/bin/env python
# -*- coding: utf-8 -*-

"""Automatic Docker Deployment via Webhooks"""

import json
import os
from subprocess import Popen
from argparse import ArgumentParser, ArgumentDefaultsHelpFormatter
try:
    # For Python 3.0 and later
    from http.server import HTTPServer
    from http.server import BaseHTTPRequestHandler
except ImportError:
    # Fall back to Python 2
    from BaseHTTPServer import BaseHTTPRequestHandler
    from BaseHTTPServer import HTTPServer as HTTPServer
import sys
import logging
import requests

logging.basicConfig(format='%(asctime)s %(levelname)s %(message)s',
                    level=logging.DEBUG,
                    stream=sys.stdout)

class RequestHandler(BaseHTTPRequestHandler):
    """A POST request handler which expects a token in its path."""
    def do_POST(self):
        logging.info("Path: %s", self.path)
        header_length = int(self.headers.getheader('content-length', "0"))
        json_payload = self.rfile.read(header_length)
        env = dict(os.environ)
        json_params = {}
        if len(json_payload) > 0:
            json_params = json.loads(json_payload)
            if json_params['repository'] and hasattr(json_params['repository'], 'items'):
                env.update(('REPOSITORY_' + var.upper(), str(val))
                           for var, val in json_params['repository'].items())

        # Check if the secret URL was called
        if self.path in hooks:
            cmd = ["sh", hooks[self.path]]
            logging.info("Start executing '%s'" % cmd)
            try:
                Popen(cmd, env=env).wait()
                logging.info("Removing None Docker Images")
                remove_cmd = "/usr/bin/docker rmi $(docker images -a | grep \"^<none>\" | awk '{print $3}')"
                Popen(remove_cmd, shell=True).wait()
                self.send_response(200, "OK")
                if 'callback_url' in json_params:
                    # Make a callback to Docker Hub
                    data = {'state': 'success'}
                    headers = {'Content-type': 'application/json',
                               'Accept': 'text/plain'}
                    requests.post(json_params['callback_url'],
                                  data=json.dumps(data),
                                  headers=headers)
            except OSError as err:
                self.send_response(500, "OSError")
                logging.error("You probably didn't use 'sh ./script.sh'.")
                logging.error(err)
                if 'callback_url' in json_params:
                    # Make a callback to Docker Hub
                    data = {'state': 'failure',
                            'description': str(err)}
                    headers = {'Content-type': 'application/json',
                               'Accept': 'text/plain'}
                    requests.post(json_params['callback_url'],
                                  data=json.dumps(data),
                                  headers=headers)
        else:
            self.send_response(401, "Not authorized")
        self.end_headers()


def get_parser():
    """Get a command line parser for docker-hook."""
    parser = ArgumentParser(description=__doc__,
                            formatter_class=ArgumentDefaultsHelpFormatter)

    parser.add_argument("-l", "--listhooks",
                        dest="list_hooks",
                        nargs="*",
                        required=True,
                        default=[],
                        help=("List of Hook options for tokens and paths e.g.: token1:/path1 token2:/path2"))

    parser.add_argument("--addr",
                        dest="addr",
                        default="0.0.0.0",
                        help="address where it listens")
    parser.add_argument("--port",
                        dest="port",
                        type=int,
                        default=8686,
                        metavar="PORT",
                        help="port where it listens")
    return parser


def main(addr, port):
    """Start a HTTPServer which waits for requests."""
    httpd = HTTPServer((addr, port), RequestHandler)
    httpd.serve_forever()

if __name__ == '__main__':
    parser = get_parser()
    if len(sys.argv) == 1:
        parser.print_help()
        sys.exit(1)

    args = parser.parse_args()

    try:
        hooks = {}
        for hook in args.list_hooks:
            options = hook.split(':')
            hooks['/' + options[0]] = options[1]
    except Exception as e:
        print 'Cannot parse the hook options. They should be in format token:/path_of_deploy_file.sh and seperated by spaces'

    main(args.addr, args.port)