mirror of
https://github.com/ansible-collections/community.general.git
synced 2025-04-24 11:21:25 -07:00
a3261500dd
The copy action_plugin is not easy to read. Part of this commit is taking that file, restructuring it, and adding comments. No functionality changed in how it interacts with the world. The fix for #5739 ends up being the assumption that there is a cleanup 'rm -rf' that happens at the end of the copy loop. This was not the fact before and we made a bunch of tmp directories that we hoped would end up being cleaned up. Now we just use the tmp directory that the runner provides and cleanup inline if it is a single file to be coppied or after the loop if it is a recursive copy. As a part of this we did end up having to change runner to provide a flag so that we could short the inline tmp directory removal. This flag defaults to True so it will not change the behavior of other modules that are being called.
317 lines
14 KiB
Python
317 lines
14 KiB
Python
# (c) 2012-2014, Michael DeHaan <michael.dehaan@gmail.com>
|
|
#
|
|
# 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 <http://www.gnu.org/licenses/>.
|
|
|
|
import os
|
|
|
|
from ansible import utils
|
|
import ansible.constants as C
|
|
import ansible.utils.template as template
|
|
from ansible import errors
|
|
from ansible.runner.return_data import ReturnData
|
|
import base64
|
|
import stat
|
|
import tempfile
|
|
import pipes
|
|
|
|
## fixes https://github.com/ansible/ansible/issues/3518
|
|
# http://mypy.pythonblogs.com/12_mypy/archive/1253_workaround_for_python_bug_ascii_codec_cant_encode_character_uxa0_in_position_111_ordinal_not_in_range128.html
|
|
import sys
|
|
reload(sys)
|
|
sys.setdefaultencoding("utf8")
|
|
|
|
|
|
class ActionModule(object):
|
|
|
|
def __init__(self, runner):
|
|
self.runner = runner
|
|
|
|
def run(self, conn, tmp_path, module_name, module_args, inject, complex_args=None, **kwargs):
|
|
''' handler for file transfer operations '''
|
|
|
|
# load up options
|
|
options = {}
|
|
if complex_args:
|
|
options.update(complex_args)
|
|
options.update(utils.parse_kv(module_args))
|
|
source = options.get('src', None)
|
|
content = options.get('content', None)
|
|
dest = options.get('dest', None)
|
|
raw = utils.boolean(options.get('raw', 'no'))
|
|
force = utils.boolean(options.get('force', 'yes'))
|
|
|
|
if (source is None and content is None and not 'first_available_file' in inject) or dest is None:
|
|
result=dict(failed=True, msg="src (or content) and dest are required")
|
|
return ReturnData(conn=conn, result=result)
|
|
elif (source is not None or 'first_available_file' in inject) and content is not None:
|
|
result=dict(failed=True, msg="src and content are mutually exclusive")
|
|
return ReturnData(conn=conn, result=result)
|
|
|
|
# Check if the source ends with a "/"
|
|
source_trailing_slash = False
|
|
if source:
|
|
source_trailing_slash = source.endswith("/")
|
|
|
|
# Define content_tempfile in case we set it after finding content populated.
|
|
content_tempfile = None
|
|
|
|
# If content is defined make a temp file and write the content into it.
|
|
if content is not None:
|
|
try:
|
|
content_tempfile = self._create_content_tempfile(content)
|
|
source = content_tempfile
|
|
except Exception, err:
|
|
result = dict(failed=True, msg="could not write content temp file: %s" % err)
|
|
return ReturnData(conn=conn, result=result)
|
|
# if we have first_available_file in our vars
|
|
# look up the files and use the first one we find as src
|
|
elif 'first_available_file' in inject:
|
|
found = False
|
|
for fn in inject.get('first_available_file'):
|
|
fn_orig = fn
|
|
fnt = template.template(self.runner.basedir, fn, inject)
|
|
fnd = utils.path_dwim(self.runner.basedir, fnt)
|
|
if not os.path.exists(fnd) and '_original_file' in inject:
|
|
fnd = utils.path_dwim_relative(inject['_original_file'], 'files', fnt, self.runner.basedir, check=False)
|
|
if os.path.exists(fnd):
|
|
source = fnd
|
|
found = True
|
|
break
|
|
if not found:
|
|
results = dict(failed=True, msg="could not find src in first_available_file list")
|
|
return ReturnData(conn=conn, result=results)
|
|
else:
|
|
source = template.template(self.runner.basedir, source, inject)
|
|
if '_original_file' in inject:
|
|
source = utils.path_dwim_relative(inject['_original_file'], 'files', source, self.runner.basedir)
|
|
else:
|
|
source = utils.path_dwim(self.runner.basedir, source)
|
|
|
|
# A list of source file tuples (full_path, relative_path) which will try to copy to the destination
|
|
source_files = []
|
|
|
|
# If source is a directory populate our list else source is a file and translate it to a tuple.
|
|
if os.path.isdir(source):
|
|
# Get the amount of spaces to remove to get the relative path.
|
|
if source_trailing_slash:
|
|
sz = len(source) + 1
|
|
else:
|
|
sz = len(source.rsplit('/', 1)[0]) + 1
|
|
|
|
# Walk the directory and append the file tuples to source_files.
|
|
for base_path, sub_folders, files in os.walk(source):
|
|
for file in files:
|
|
full_path = os.path.join(base_path, file)
|
|
rel_path = full_path[sz:]
|
|
source_files.append((full_path, rel_path))
|
|
|
|
# If it's recursive copy, destination is always a dir,
|
|
# explicitly mark it so (note - copy module relies on this).
|
|
if not dest.endswith("/"):
|
|
dest += "/"
|
|
else:
|
|
source_files.append((source, os.path.basename(source)))
|
|
|
|
changed = False
|
|
diffs = []
|
|
module_result = {"changed": False}
|
|
|
|
# Don't remove the directory if there are more than 1 source file.
|
|
delete_remote_tmp = not (len(source_files) < 1)
|
|
|
|
for source_full, source_rel in source_files:
|
|
# Generate the MD5 hash of the local file.
|
|
local_md5 = utils.md5(source_full)
|
|
|
|
# If local_md5 is not defined we can't find the file so we should fail out.
|
|
if local_md5 is None:
|
|
result = dict(failed=True, msg="could not find src=%s" % source_full)
|
|
return ReturnData(conn=conn, result=result)
|
|
|
|
# This is kind of optimization - if user told us destination is
|
|
# dir, do path manipulation right away, otherwise we still check
|
|
# for dest being a dir via remote call below.
|
|
if dest.endswith("/"):
|
|
dest_file = os.path.join(dest, source_rel)
|
|
else:
|
|
dest_file = dest
|
|
|
|
# Attempt to get the remote MD5 Hash.
|
|
remote_md5 = self.runner._remote_md5(conn, tmp_path, dest_file)
|
|
|
|
if remote_md5 == '3':
|
|
# The remote_md5 was executed on a directory.
|
|
if content is not None:
|
|
# If source was defined as content remove the temporary file and fail out.
|
|
self._remove_tempfile_if_content_defined(content, content_tempfile)
|
|
result = dict(failed=True, msg="can not use content with a dir as dest")
|
|
return ReturnData(conn=conn, result=result)
|
|
else:
|
|
# Append the relative source location to the destination and retry remote_md5.
|
|
dest_file = os.path.join(dest, source_rel)
|
|
remote_md5 = self.runner._remote_md5(conn, tmp_path, dest_file)
|
|
|
|
if remote_md5 != '1' and not force:
|
|
# remote_file does not exist so continue to next iteration.
|
|
continue
|
|
|
|
if local_md5 != remote_md5:
|
|
# The MD5 hashes don't match and we will change or error out.
|
|
changed = True
|
|
|
|
if self.runner.diff and not raw:
|
|
diff = self._get_diff_data(conn, tmp_path, inject, dest_file, source_full)
|
|
else:
|
|
diff = {}
|
|
|
|
if self.runner.noop_on_check(inject):
|
|
self._remove_tempfile_if_content_defined(content, content_tempfile)
|
|
diffs.append(diff)
|
|
changed = True
|
|
module_result = dict(changed=True)
|
|
continue
|
|
|
|
# Define a remote directory that we will copy the file to.
|
|
tmp_src = tmp_path + 'source'
|
|
|
|
if not raw:
|
|
conn.put_file(source_full, tmp_src)
|
|
else:
|
|
conn.put_file(source_full, dest_file)
|
|
|
|
# We have copied the file remotely and no longer require our content_tempfile
|
|
self._remove_tempfile_if_content_defined(content, content_tempfile)
|
|
|
|
# fix file permissions when the copy is done as a different user
|
|
if self.runner.sudo and self.runner.sudo_user != 'root' and not raw:
|
|
self.runner._low_level_exec_command(conn, "chmod a+r %s" % tmp_src, tmp_path)
|
|
|
|
if raw:
|
|
# Continue to next iteration if raw is defined.
|
|
continue
|
|
|
|
# Run the copy module
|
|
|
|
# src and dest here come after original and override them
|
|
# we pass dest only to make sure it includes trailing slash in case of recursive copy
|
|
module_args_tmp = "%s src=%s dest=%s original_basename=%s" % (module_args,
|
|
pipes.quote(tmp_src), pipes.quote(dest), pipes.quote(source_rel))
|
|
module_return = self.runner._execute_module(conn, tmp_path, 'copy', module_args_tmp, inject=inject, complex_args=complex_args, delete_remote_tmp=delete_remote_tmp)
|
|
|
|
else:
|
|
# no need to transfer the file, already correct md5, but still need to call
|
|
# the file module in case we want to change attributes
|
|
self._remove_tempfile_if_content_defined(content, content_tempfile)
|
|
|
|
if raw:
|
|
# Continue to next iteration if raw is defined.
|
|
# self.runner._remove_tmp_path(conn, tmp_path)
|
|
continue
|
|
|
|
tmp_src = tmp_path + source_rel
|
|
|
|
# Build temporary module_args.
|
|
module_args_tmp = "%s src=%s original_basename=%s" % (module_args,
|
|
pipes.quote(tmp_src), pipes.quote(source_rel))
|
|
if self.runner.noop_on_check(inject):
|
|
module_args_tmp = "%s CHECKMODE=True" % module_args_tmp
|
|
if self.runner.no_log:
|
|
module_args_tmp = "%s NO_LOG=True" % module_args_tmp
|
|
|
|
# Execute the file module.
|
|
module_return = self.runner._execute_module(conn, tmp_path, 'file', module_args_tmp, inject=inject, complex_args=complex_args, delete_remote_tmp=delete_remote_tmp)
|
|
|
|
if not C.DEFAULT_KEEP_REMOTE_FILES and not delete_remote_tmp:
|
|
self.runner._remove_tmp_path(conn, tmp_path)
|
|
|
|
module_result = module_return.result
|
|
if module_result.get('failed') == True:
|
|
return module_return
|
|
if module_result.get('changed') == True:
|
|
changed = True
|
|
|
|
# TODO: Support detailed status/diff for multiple files
|
|
if len(source_files) == 1:
|
|
result = module_result
|
|
else:
|
|
result = dict(dest=dest, src=source, changed=changed)
|
|
if len(diffs) == 1:
|
|
return ReturnData(conn=conn, result=result, diff=diffs[0])
|
|
else:
|
|
return ReturnData(conn=conn, result=result)
|
|
|
|
def _create_content_tempfile(self, content):
|
|
''' Create a tempfile containing defined content '''
|
|
fd, content_tempfile = tempfile.mkstemp()
|
|
f = os.fdopen(fd, 'w')
|
|
try:
|
|
f.write(content)
|
|
except Exception, err:
|
|
os.remove(content_tempfile)
|
|
raise Exception(err)
|
|
finally:
|
|
f.close()
|
|
return content_tempfile
|
|
|
|
def _get_diff_data(self, conn, tmp, inject, destination, source):
|
|
peek_result = self.runner._execute_module(conn, tmp, 'file', "path=%s diff_peek=1" % destination, inject=inject, persist_files=True)
|
|
|
|
if not peek_result.is_successful():
|
|
return {}
|
|
|
|
diff = {}
|
|
if peek_result.result['state'] == 'absent':
|
|
diff['before'] = ''
|
|
elif peek_result.result['appears_binary']:
|
|
diff['dst_binary'] = 1
|
|
elif peek_result.result['size'] > utils.MAX_FILE_SIZE_FOR_DIFF:
|
|
diff['dst_larger'] = utils.MAX_FILE_SIZE_FOR_DIFF
|
|
else:
|
|
dest_result = self.runner._execute_module(conn, tmp, 'slurp', "path=%s" % destination, inject=inject, persist_files=True)
|
|
if 'content' in dest_result.result:
|
|
dest_contents = dest_result.result['content']
|
|
if dest_result.result['encoding'] == 'base64':
|
|
dest_contents = base64.b64decode(dest_contents)
|
|
else:
|
|
raise Exception("unknown encoding, failed: %s" % dest_result.result)
|
|
diff['before_header'] = destination
|
|
diff['before'] = dest_contents
|
|
|
|
src = open(source)
|
|
src_contents = src.read(8192)
|
|
st = os.stat(source)
|
|
if src_contents.find("\x00") != -1:
|
|
diff['src_binary'] = 1
|
|
elif st[stat.ST_SIZE] > utils.MAX_FILE_SIZE_FOR_DIFF:
|
|
diff['src_larger'] = utils.MAX_FILE_SIZE_FOR_DIFF
|
|
else:
|
|
src.seek(0)
|
|
diff['after_header'] = source
|
|
diff['after'] = src.read()
|
|
|
|
return diff
|
|
|
|
def _remove_tempfile_if_content_defined(self, content, content_tempfile):
|
|
if content is not None:
|
|
os.remove(content_tempfile)
|
|
|
|
|
|
def _result_key_merge(self, options, results):
|
|
# add keys to file module results to mimic copy
|
|
if 'path' in results.result and 'dest' not in results.result:
|
|
results.result['dest'] = results.result['path']
|
|
del results.result['path']
|
|
return results
|