Merge pull request #5969 from risaacson/pull_5136

Updates for the unarchive module and action_plugin.

lib/ansible/runner/action_plugins/unarchive.py

@@ -28,11 +28,9 @@ from ansible.runner.return_data import ReturnData
 import sys
 reload(sys)
 sys.setdefaultencoding("utf8")
-#import base64
-#import stat
-#import tempfile
 import pipes
 
+
 class ActionModule(object):
 
     TRANSFERS_FILES = True
@@ -50,12 +48,14 @@ class ActionModule(object):
         options.update(utils.parse_kv(module_args))
         source  = options.get('src', None)
         dest    = options.get('dest', None)
+        copy    = utils.boolean(options.get('copy', 'yes'))
 
         if source is None or dest is None:
-            result=dict(failed=True, msg="src (or content) and dest are required")
+            result = dict(failed=True, msg="src (or content) and dest are required")
             return ReturnData(conn=conn, result=result)
 
         source = template.template(self.runner.basedir, source, inject)
+        if copy:
             if '_original_file' in inject:
                 source = utils.path_dwim_relative(inject['_original_file'], 'files', source, self.runner.basedir)
             else:
@@ -66,6 +66,7 @@ class ActionModule(object):
             result = dict(failed=True, msg="dest must be an existing dir")
             return ReturnData(conn=conn, result=result)
 
+        if copy:
             # transfer the file to a remote tmp location
             tmp_src = tmp + 'source'
             conn.put_file(source, tmp_src)
@@ -73,7 +74,10 @@ class ActionModule(object):
         # handle diff mode client side
         # handle check mode client side
         # fix file permissions when the copy is done as a different user
+        if copy:
             if self.runner.sudo and self.runner.sudo_user != 'root':
                 self.runner._low_level_exec_command(conn, "chmod a+r %s" % tmp_src, tmp)
             module_args = "%s src=%s original_basename=%s" % (module_args, pipes.quote(tmp_src), pipes.quote(os.path.basename(source)))
+        else:
+            module_args = "%s original_basename=%s" % (module_args, pipes.quote(os.path.basename(source)))
         return self.runner._execute_module(conn, tmp, 'unarchive', module_args, inject=inject, complex_args=complex_args)

library/files/unarchive

@@ -37,6 +37,12 @@ options:
       - Remote absolute path where the archive should be unpacked
     required: true
     default: null
+  copy:
+    description:
+      - Should the file be copied from the local to the remote machine?
+    required: false
+    choices: [ "yes", "no" ]
+    default: "yes"
 author: Dylan Martin 
 todo:
     - detect changed/unchanged for .zip files
@@ -59,35 +65,37 @@ EXAMPLES = '''
 - unarchive: src=foo.tgz dest=/var/lib/foo
 '''
 
-
 import os
+
+
 # class to handle .zip files
-class _zipfile(object):
+class ZipFile(object):
     
-    def __init__(self,src,dest,module):
+    def __init__(self, src, dest, module):
         self.src = src
         self.dest = dest
         self.module = module
 
     def is_unarchived(self):
-        return dict(bool = False)
+        return dict(unarchived=False)
 
     def unarchive(self):
-        cmd = 'unzip -o "%s" -d "%s"'  % (self.src,self.dest)
+        cmd = 'unzip -o "%s" -d "%s"' % (self.src, self.dest)
         rc, out, err = self.module.run_command(cmd)
-        return dict(cmd = cmd, rc=rc, out=out, err=err)
+        return dict(cmd=cmd, rc=rc, out=out, err=err)
 
     def can_handle_archive(self):
-        cmd = 'unzip -l "%s"' % (self.src)
+        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):
+class TgzFile(object):
     
-    def __init__(self,src,dest,module):
+    def __init__(self, src, dest, module):
         self.src = src
         self.dest = dest
         self.module = module
@@ -96,56 +104,62 @@ class _tgzfile(object):
     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)
+        cmd = 'tar -v -C "%s" --diff -%sf "%s"' % (self.dest, self.zipflag, self.src)
         rc, out, err = self.module.run_command(cmd)
-        bool = (rc == 0)
-        return dict( bool = bool, rc = rc , out = out, err = err, cmd = cmd)
+        unarchived = (rc == 0)
+        return dict(unarchived=unarchived, rc=rc, out=out, err=err, cmd=cmd)
 
     def unarchive(self):
-        cmd = 'tar -C "%s" -x%sf "%s"' % (self.dest,self.zipflag,self.src)
+        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)
+        return dict(cmd=cmd, rc=rc, out=out, err=err)
 
     def can_handle_archive(self):
-        cmd = 'tar -t%sf "%s"' % (self.zipflag,self.src)
+        cmd = 'tar -t%sf "%s"' % (self.zipflag, self.src)
         rc, out, err = self.module.run_command(cmd)
         if rc == 0:
+            if len(out.splitlines(True)) > 0:
                 return True
         return False
 
+
 # class to handle tar files that aren't compressed
-class _tarfile(_tgzfile):
-    def __init__(self,src,dest,module):
+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):
+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):
+class TarXz(TgzFile):
+    def __init__(self, src, dest, module):
         self.src = src
         self.dest = dest
         self.module = module
         self.zipflag = 'J'
 
+
 # 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]
+def pick_handler(src, dest, module):
+    handlers = [TgzFile, ZipFile, TarFile, TarBzip, TarXz]
     for handler in handlers:
-        obj = handler(src,dest,module)
+        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
@@ -153,40 +167,43 @@ def main():
             src               = dict(required=True),
             original_basename = dict(required=False), # used to handle 'dest is a directory' via template, a slight hack
             dest              = dict(required=True),
+            copy              = dict(default=True, type='bool'),
         ),
         add_file_common_args=True,
     )
 
     src    = os.path.expanduser(module.params['src'])
     dest   = os.path.expanduser(module.params['dest'])
+    copy   = module.params['copy']
 
     # did tar file arrive?
     if not os.path.exists(src):
-        module.fail_json(msg="Source '%s' failed to transfer" % (src))
+        if copy:
+            module.fail_json(msg="Source '%s' failed to transfer" % src)
+        else:
+            module.fail_json(msg="Source '%s' does not exist" % src)
     if not os.access(src, os.R_OK):
-        module.fail_json(msg="Source '%s' not readable" % (src))
+        module.fail_json(msg="Source '%s' not readable" % src)
 
-    # is dest OK to recieve tar file?
+    # is dest OK to receive 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)
+    handler = pick_handler(src, dest, module)
 
-    res_args = dict( handler=handler.__class__.__name__, dest = dest, src = src )
+    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']:
+    if res_args['check_results']['unarchived']:
         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))
 

test/TestPlayBook.py

@@ -82,6 +82,7 @@ class TestCallbacks(object):
     def on_no_hosts(self):
         pass
 
+
 class TestPlaybook(unittest.TestCase):
 
     def setUp(self):
@@ -119,8 +120,7 @@ class TestPlaybook(unittest.TestCase):
         filename = os.path.join(self.stage_dir, filename)
         return filename
 
-   def _run(self, test_playbook, host_list='test/ansible_hosts', 
-            extra_vars=None):
+    def _run(self, test_playbook, host_list='test/ansible_hosts', extra_vars=None):
         ''' run a module and get the localhost results '''
         # This ensures tests are independent of eachother
         global EVENTS
@@ -410,6 +410,23 @@ class TestPlaybook(unittest.TestCase):
         assert utils.jsonify(expected, format=True) == utils.jsonify(actual,format=True)
 
 
+    def test_unarchive(self):
+        pb = 'test/playbook-unarchive.yml'
+        actual = self._run(pb)
+
+        expected =  {
+            "localhost": {
+                "changed": 29,
+                "failures": 0,
+                "ok": 33,
+                "skipped": 12,
+                "unreachable": 0
+            }
+        }
+
+        assert utils.jsonify(expected, format=True) == utils.jsonify(actual,format=True)
+
+
     def _compare_file_output(self, filename, expected_lines):
         actual_lines = []
         with open(filename) as f:

test/playbook-unarchive.yml

+---
+# To run me manually, use: -i "localhost,"
+- hosts: localhost
+  connection: local
+  gather_facts: no
+  vars:
+    - testdir: /tmp/ansible-unarchive
+    - filesdir: test_unarchive/files
+  tasks:
+
+   - name: "Simple tar unarchive."
+     command: rm -rf {{testdir}}
+   - file: state=directory dest={{testdir}}
+   - unarchive: src={{filesdir}}/test.tar dest={{testdir}}
+     register: res
+   - command: test -f {{testdir}}/foo
+   - fail: msg="Resource was expected to be changed."
+     when: not res|changed
+   - unarchive: src={{filesdir}}/test.tar dest={{testdir}}
+     register: res
+   - fail: msg="Resource was not expected to be changed."
+     when: res|changed
+
+   - name: "Simple tar.gz unarchive."
+     command: rm -rf {{testdir}}
+   - file: state=directory dest={{testdir}}
+   - unarchive: src={{filesdir}}/test.tar.gz dest={{testdir}}
+     register: res
+   - command: test -f {{testdir}}/foo
+   - fail: msg="Resource was expected to be changed."
+     when: not res|changed
+   - unarchive: src={{filesdir}}/test.tar.gz dest={{testdir}}
+     register: res
+   - fail: msg="Resource was not expected to be changed."
+     when: res|changed
+
+   - name: "Simple zip unarchive."
+     command: rm -rf {{testdir}}
+   - file: state=directory dest={{testdir}}
+   - unarchive: src={{filesdir}}/test.zip dest={{testdir}}
+     register: res
+   - command: test -f {{testdir}}/foo
+   - fail: msg="Resource was expected to be changed."
+     when: not res|changed
+   - unarchive: src={{filesdir}}/test.zip dest={{testdir}}
+     register: res
+   - fail: msg="Resource was expected to be changed."
+     when: not res|changed
+
+   - name: "Unarchive a local tar file."
+     command : rm -rf {{testdir}}
+   - file: state=directory dest={{testdir}}
+   - copy: src={{filesdir}}/test.tar dest={{testdir}}
+   - unarchive: src={{testdir}}/test.tar dest={{testdir}}
+     register: res
+   - command: test -f {{testdir}}/foo
+   - fail: msg="Resource was expected to be changed."
+     when: not res|changed
+   - unarchive: src={{testdir}}/test.tar dest={{testdir}}
+     register: res
+   - fail: msg="Resource was not expected to be changed."
+     when: res|changed
+
+   - name: "Unarchive a local tar.gz file."
+     command : rm -rf {{testdir}}
+   - file: state=directory dest={{testdir}}
+   - copy: src={{filesdir}}/test.tar.gz dest={{testdir}}
+   - unarchive: src={{testdir}}/test.tar.gz dest={{testdir}}
+     register: res
+   - command: test -f {{testdir}}/foo
+   - fail: msg="Resource was expected to be changed."
+     when: not res|changed
+   - unarchive: src={{testdir}}/test.tar.gz dest={{testdir}}
+     register: res
+   - fail: msg="Resource was not expected to be changed."
+     when: res|changed
+
+   - name: "Unarchive a local zip file."
+     command : rm -rf {{testdir}}
+   - file: state=directory dest={{testdir}}
+   - copy: src={{filesdir}}/test.zip dest={{testdir}}
+   - unarchive: src={{testdir}}/test.zip dest={{testdir}}
+     register: res
+   - command: test -f {{testdir}}/foo
+   - fail: msg="Resource was expected to be changed."
+     when: not res|changed
+   - unarchive: src={{testdir}}/test.zip dest={{testdir}}
+     register: res
+   - fail: msg="Resource was expected to be changed."
+     when: not res|changed