#!/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/$fqdn.yml
 # 3. $workdir/$hostname.yml
 # 4. $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:

         fqdn = socket.getfqdn()
         hostpb = "%s/%s.yml" % (path, fqdn)
         shorthostpb = "%s/%s.yml" % (path, fqdn.split('.')[0])

         localpb = "%s/%s" % (path, DEFAULT_PLAYBOOK)
         errors = []

         for pb in [hostpb, shorthostpb, 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)