From 3420ffa94bb4c829cbdaeedf08b2ee2e8ec89eaf Mon Sep 17 00:00:00 2001 From: Dylan Martin Date: Mon, 21 Oct 2013 15:22:42 -0500 Subject: [PATCH 1/3] unarchive module & action_plugin added --- files/unarchive | 191 ++++++++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 191 insertions(+) create mode 100644 files/unarchive diff --git a/files/unarchive b/files/unarchive new file mode 100644 index 00000000000..72929f7589f --- /dev/null +++ b/files/unarchive @@ -0,0 +1,191 @@ +#!/usr/bin/python +# -*- coding: utf-8 -*- + +# (c) 2012, Michael DeHaan +# (c) 2013, Dylan Martin +# +# This file is part of Ansible +# +# 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 . + +import os +# class to handle .zip files +class _zipfile(object): + + def __init__(self,src,dest,module): + self.src = src + self.dest = dest + self.module = module + + def is_unarchived(self): + return dict(bool = False) + + def unarchive(self): + cmd = 'unzip "%s" -d "%s" -o' % (self.src,self.dest) + rc, out, err = self.module.run_command(cmd) + return dict(cmd = cmd, rc=rc, out=out, err=err) + + def can_handle_archive(self): + cmd = 'unzip -l "%s"' % (self.src) + rc, out, err = self.module.run_command(cmd) + if rc == 0: + return True + return False + +# class to handle gzipped tar files +class _tgzfile(object): + + def __init__(self,src,dest,module): + self.src = src + self.dest = dest + self.module = module + self.zipflag = 'z' + + def is_unarchived(self): + dirof = os.path.dirname(self.dest) + destbase = os.path.basename(self.dest) + cmd = 'tar -v -C "%s" --diff -%sf "%s"' % (self.dest, self.zipflag,self.src ) + rc, out, err = self.module.run_command(cmd) + bool = True if rc == 0 else False + return dict( bool = bool, rc = rc , out = out, err = err, cmd = cmd) + + def unarchive(self): + cmd = 'tar -C "%s" -x%sf "%s"' % (self.dest,self.zipflag,self.src) + rc, out, err = self.module.run_command(cmd) + return dict(cmd = cmd, rc=rc, out=out, err=err) + + def can_handle_archive(self): + cmd = 'tar -t%sf "%s"' % (self.zipflag,self.src) + rc, out, err = self.module.run_command(cmd) + if rc == 0: + return True + return False + +# class to handle tar files that aren't compressed +class _tarfile(_tgzfile): + def __init__(self,src,dest,module): + self.src = src + self.dest = dest + self.module = module + self.zipflag = '' + +# class to handle bzip2 compressed tar files +class _tarbzip(_tgzfile): + def __init__(self,src,dest,module): + self.src = src + self.dest = dest + self.module = module + self.zipflag = 'j' + +# class to handle xz compressed tar files +class _tarxz(_tgzfile): + def __init__(self,src,dest,module): + self.src = src + self.dest = dest + self.module = module + self.zipflag = 'J' + +DOCUMENTATION = ''' +--- +module: unarchive +short_description: Copies archive to remote locations and unpacks them +description: + - The M(unarchive) module copies an archive file on the local box to remote locations and unpacks them. +options: + src: + description: + - Local path to archive file to copy to the remote server; can be absolute or relative. + required: true + default: null + dest: + description: + - Remote absolute path where the archive should be unpacked + required: true + default: null +author: Dylan Martin +notes: + - requires tar command on host + - can handle gzip, bzip2 and xz compressed as well as uncompressed + - uses tar's --diff arg to calculate if changed or not. If this arg is not + supported, it will always unpack the archive + - existing files/directories in the destination which are not in the archvie + are not touched. This is the same behavior as a normal archive extraction + - existing files/directories in the destination which are not in the archvie + are ignored for purposes of deciding if the archive should be unpacked or not +''' + +EXAMPLES = ''' +# Example from Ansible Playbooks +- unarchive: src=foo.tgz dest=/var/lib/foo +''' +# try handlers in order and return the one that works or bail if none work +def pick_handler (src,dest,module): + handlers = [_tgzfile, _zipfile, _tarfile, _tarbzip, _tarxz] + for handler in handlers: + obj = handler(src,dest,module) + if obj.can_handle_archive(): + return obj + raise RuntimeError('Failed to find handler to unarchive "%s"' % src) + +def main(): + module = AnsibleModule( + # not checking because of daisy chain to file module + argument_spec = dict( + src = dict(required=False), + original_basename = dict(required=False), # used to handle 'dest is a directory' via template, a slight hack + dest = dict(required=True), + ), + add_file_common_args=True, + ) + + src = os.path.expanduser(module.params['src']) + dest = os.path.expanduser(module.params['dest']) + + # did tar file arrive? + if not os.path.exists(src): + module.fail_json(msg="Source '%s' failed to transfer" % (src)) + if not os.access(src, os.R_OK): + module.fail_json(msg="Source '%s' not readable" % (src)) + + # is dest OK to recieve tar file? + if not os.path.exists(os.path.dirname(dest)): + module.fail_json(msg="Destination directory '%s' does not exist" % (os.path.dirname(dest))) + if not os.access(os.path.dirname(dest), os.W_OK): + module.fail_json(msg="Destination '%s' not writable" % (os.path.dirname(dest))) + + handler = pick_handler(src,dest,module) + + res_args = dict( handler=handler.__class__.__name__, dest = dest, src = src ) + + # do we need to do unpack? + namelist = ['bool','rc','out','err','cmd'] + res_args['check_results'] = handler.is_unarchived() + if res_args['check_results']['bool']: + res_args['changed'] = False + module.exit_json(**res_args) + + # do the unpack + try: + results = handler.unarchive() + #results = (src,dest,module) + except IOError: + module.fail_json(msg="failed to unpack %s to %s" % (src, dest)) + + res_args['changed'] = True + + module.exit_json(**res_args) + +# this is magic, see lib/ansible/module_common.py +#<> +main() From d4a9e54f266a7e99264d43dba827de65cfd84deb Mon Sep 17 00:00:00 2001 From: Dylan Martin Date: Mon, 21 Oct 2013 15:30:22 -0500 Subject: [PATCH 2/3] better docs --- files/unarchive | 9 +++++++-- 1 file changed, 7 insertions(+), 2 deletions(-) diff --git a/files/unarchive b/files/unarchive index 72929f7589f..bed545c528f 100644 --- a/files/unarchive +++ b/files/unarchive @@ -114,11 +114,16 @@ options: required: true default: null author: Dylan Martin +todo: + - detect changed/unchanged for .zip files + - handle common unarchive args, like preserve owner/timestamp etc... notes: - - requires tar command on host - - can handle gzip, bzip2 and xz compressed as well as uncompressed + - requires tar/unzip command on host + - can handle gzip, bzip2 and xz compressed as well as uncompressed tar files + - detects type of archive automatically - uses tar's --diff arg to calculate if changed or not. If this arg is not supported, it will always unpack the archive + - does not detect if a .zip file is different from destination - always unzips - existing files/directories in the destination which are not in the archvie are not touched. This is the same behavior as a normal archive extraction - existing files/directories in the destination which are not in the archvie From bc2b826fc49d3042d527db3452bea83e469c17a7 Mon Sep 17 00:00:00 2001 From: Dylan Martin Date: Mon, 21 Oct 2013 16:10:55 -0500 Subject: [PATCH 3/3] unarchive - mvd docs to top of file --- files/unarchive | 78 +++++++++++++++++++++++++------------------------ 1 file changed, 40 insertions(+), 38 deletions(-) diff --git a/files/unarchive b/files/unarchive index bed545c528f..bd62bc9372b 100644 --- a/files/unarchive +++ b/files/unarchive @@ -19,6 +19,46 @@ # You should have received a copy of the GNU General Public License # along with Ansible. If not, see . +DOCUMENTATION = ''' +--- +module: unarchive +short_description: Copies archive to remote locations and unpacks them +description: + - The M(unarchive) module copies an archive file on the local box to remote locations and unpacks them. +options: + src: + description: + - Local path to archive file to copy to the remote server; can be absolute or relative. + required: true + default: null + dest: + description: + - Remote absolute path where the archive should be unpacked + required: true + default: null +author: Dylan Martin +todo: + - detect changed/unchanged for .zip files + - handle common unarchive args, like preserve owner/timestamp etc... +notes: + - requires tar/unzip command on host + - can handle gzip, bzip2 and xz compressed as well as uncompressed tar files + - detects type of archive automatically + - uses tar's --diff arg to calculate if changed or not. If this arg is not + supported, it will always unpack the archive + - does not detect if a .zip file is different from destination - always unzips + - existing files/directories in the destination which are not in the archvie + are not touched. This is the same behavior as a normal archive extraction + - existing files/directories in the destination which are not in the archvie + are ignored for purposes of deciding if the archive should be unpacked or not +''' + +EXAMPLES = ''' +# Example from Ansible Playbooks +- unarchive: src=foo.tgz dest=/var/lib/foo +''' + + import os # class to handle .zip files class _zipfile(object): @@ -96,44 +136,6 @@ class _tarxz(_tgzfile): self.module = module self.zipflag = 'J' -DOCUMENTATION = ''' ---- -module: unarchive -short_description: Copies archive to remote locations and unpacks them -description: - - The M(unarchive) module copies an archive file on the local box to remote locations and unpacks them. -options: - src: - description: - - Local path to archive file to copy to the remote server; can be absolute or relative. - required: true - default: null - dest: - description: - - Remote absolute path where the archive should be unpacked - required: true - default: null -author: Dylan Martin -todo: - - detect changed/unchanged for .zip files - - handle common unarchive args, like preserve owner/timestamp etc... -notes: - - requires tar/unzip command on host - - can handle gzip, bzip2 and xz compressed as well as uncompressed tar files - - detects type of archive automatically - - uses tar's --diff arg to calculate if changed or not. If this arg is not - supported, it will always unpack the archive - - does not detect if a .zip file is different from destination - always unzips - - existing files/directories in the destination which are not in the archvie - are not touched. This is the same behavior as a normal archive extraction - - existing files/directories in the destination which are not in the archvie - are ignored for purposes of deciding if the archive should be unpacked or not -''' - -EXAMPLES = ''' -# Example from Ansible Playbooks -- unarchive: src=foo.tgz dest=/var/lib/foo -''' # try handlers in order and return the one that works or bail if none work def pick_handler (src,dest,module): handlers = [_tgzfile, _zipfile, _tarfile, _tarbzip, _tarxz]