ansible/bin/ansible-pull

#!/usr/bin/env python

# (c) 2012, Stephen Fromm <sfromm@gmail.com>
#
# Ansible is free software: you can redistribute it and/or modify
# it under the terms of the GNU General Public License as published by
# the Free Software Foundation, either version 3 of the License, or
# (at your option) any later version.
#
# Ansible is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
# GNU General Public License for more details.
#
# You should have received a copy of the GNU General Public License
# along with Ansible.  If not, see <http://www.gnu.org/licenses/>.
#
# ansible-pull is a script that runs ansible in local mode
# after checking out a playbooks directory from source repo.  There is an
# example playbook to bootstrap this script in the examples/ dir which
# installs ansible and sets it up to run on cron.

# usage:
#   ansible-pull -d /var/lib/ansible \
#                -U http://example.net/content.git [-C production] \
#                [path/playbook.yml]
#
# the -d and -U arguments are required; the -C argument is optional.
#
# ansible-pull accepts an optional argument to specify a playbook
# location underneath the workdir and then searches the source repo
# for playbooks in the following order, stopping at the first match:
#
# 1. $workdir/path/playbook.yml, if specified
# 2. $workdir/$hostname.yml
# 3. $workdir/local.yml
#
# the source repo must contain at least one of these playbooks.

import os
import shutil
import subprocess
import sys
import datetime
import socket
from ansible import utils

DEFAULT_REPO_TYPE = 'git'
DEFAULT_PLAYBOOK = 'local.yml'
PLAYBOOK_ERRORS = {1: 'File does not exist',
                    2: 'File is not readable'}


def _run(cmd):
    print >>sys.stderr, "Running: '%s'" % cmd
    cmd = subprocess.Popen(cmd, shell=True,
                           stdout=subprocess.PIPE, stderr=subprocess.PIPE)
    (out, err) = cmd.communicate()
    print out
    if cmd.returncode != 0:
        print >>sys.stderr, err
    return cmd.returncode, out


def try_playbook(path):
    if not os.path.exists(path):
        return 1
    if not os.access(path, os.R_OK):
        return 2
    return 0


def select_playbook(path, args):
    playbook = None
    if len(args) > 0 and args[0] is not None:
        playbook = "%s/%s" % (path, args[0])
        rc = try_playbook(playbook)
        if rc != 0:
            print >>sys.stderr, "%s: %s" % (playbook, PLAYBOOK_ERRORS[rc])
            return None
        return playbook
    else:
        hostpb = "%s/%s.yml" % (path, socket.getfqdn())
        localpb = "%s/%s" % (path, DEFAULT_PLAYBOOK)
        errors = []
        for pb in [hostpb, localpb]:
            rc = try_playbook(pb)
            if rc == 0:
                playbook = pb
                break
            else:
                errors.append("%s: %s" % (pb, PLAYBOOK_ERRORS[rc]))
        if playbook is None:
            print >>sys.stderr, "\n".join(errors)
        return playbook


def main(args):
    """ Set up and run a local playbook """
    usage = "%prog [options] [playbook.yml]"
    parser = utils.SortedOptParser(usage=usage)
    parser.add_option('--purge', default=False, action='store_true',
                      help='purge checkout after playbook run')
    parser.add_option('-o', '--only-if-changed', dest='ifchanged', default=False, action='store_true',
                      help='only run the playbook if the repository has been updated')
    parser.add_option('-f', '--force', dest='force', default=False,
                      action='store_true',
                      help='run the playbook even if the repository could '
                           'not be updated')
    parser.add_option('-d', '--directory', dest='dest', default=None,
                      help='directory to checkout repository to')
    parser.add_option('-U', '--url', dest='url', default=None,
                      help='URL of the playbook repository')
    parser.add_option('-C', '--checkout', dest='checkout',
                      help='branch/tag/commit to checkout.  '
                      'Defaults to behavior of repository module.')
    parser.add_option('-i', '--inventory-file', dest='inventory',
                      help="location of the inventory host file")
    parser.add_option('-m', '--module-name', dest='module_name',
                      default=DEFAULT_REPO_TYPE,
                      help='Module name used to check out repository.  '
                      'Default is %s.' % DEFAULT_REPO_TYPE)
    options, args = parser.parse_args(args)

    hostname = socket.getfqdn()
    if not options.dest:
        # use a hostname dependent directory, in case of $HOME on nfs
        options.dest = utils.prepare_writeable_dir('~/.ansible/pull/%s' % hostname)

    options.dest = os.path.abspath(options.dest)

    if not options.url:
        parser.error("URL for repository not specified, use -h for help")
        return 1

    now = datetime.datetime.now()
    print >>sys.stderr, now.strftime("Starting ansible-pull at %F %T")

    inv_opts = 'localhost,'
    limit_opts = 'localhost:%s:127.0.0.1' % hostname
    base_opts = '-c local --limit "%s"' % limit_opts
    repo_opts = "name=%s dest=%s" % (options.url, options.dest)
    if options.checkout:
        repo_opts += ' version=%s' % options.checkout
    path = utils.plugins.module_finder.find_plugin(options.module_name)
    if path is None:
        sys.stderr.write("module '%s' not found.\n" % options.module_name)
        return 1
    cmd = 'ansible all -i "%s" %s -m %s -a "%s"' % (
            inv_opts, base_opts, options.module_name, repo_opts
            )
    rc, out = _run(cmd)
    if rc != 0:
        if options.force:
            print "Unable to update repository. Continuing with (forced) run of playbook."
        else:
            return rc
    elif options.ifchanged and '"changed": true' not in out:
        print "Repository has not changed, quitting."
        return 0

    playbook = select_playbook(options.dest, args)

    if playbook is None:
        print >>sys.stderr, "Could not find a playbook to run."
        return 1

    cmd = 'ansible-playbook %s %s' % (base_opts, playbook)
    if options.inventory:
        cmd += ' -i "%s"' % options.inventory
    os.chdir(options.dest)
    rc, out = _run(cmd)

    if options.purge:
        os.chdir('/')
        try:
            shutil.rmtree(options.dest)
        except Exception, e:
            print >>sys.stderr, "Failed to remove %s: %s" % (options.dest, str(e))

    return rc

if __name__ == '__main__':
    try:
        sys.exit(main(sys.argv[1:]))
    except KeyboardInterrupt, e:
        print >>sys.stderr, "Exit on user request.\n"
        sys.exit(1)