# (c) 2012-2014, Michael DeHaan # # 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 . # Make coding more python3-ish from __future__ import (absolute_import, division, print_function) __metaclass__ = type import base64 import json import os import pipes import stat import tempfile from ansible import constants as C from ansible.plugins.action import ActionBase from ansible.utils.boolean import boolean from ansible.utils.hashing import checksum ## 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(ActionBase): def run(self, tmp=None, task_vars=dict()): ''' handler for file transfer operations ''' source = self._task.args.get('src', None) content = self._task.args.get('content', None) dest = self._task.args.get('dest', None) raw = boolean(self._task.args.get('raw', 'no')) force = boolean(self._task.args.get('force', 'yes')) # content with newlines is going to be escaped to safely load in yaml # now we need to unescape it so that the newlines are evaluated properly # when writing the file to disk if content: if isinstance(content, unicode): try: content = content.decode('unicode-escape') except UnicodeDecodeError: pass # FIXME: first available file needs to be reworked somehow... #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: # If content comes to us as a dict it should be decoded json. # We need to encode it back into a string to write it out. if type(content) is dict: content_tempfile = self._create_content_tempfile(json.dumps(content)) else: content_tempfile = self._create_content_tempfile(content) source = content_tempfile except Exception, err: return dict(failed=True, msg="could not write content temp file: %s" % err) ############################################################################################### # FIXME: first_available_file needs to be reworked? ############################################################################################### # 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: if self._task._role is not None: source = self._loader.path_dwim_relative(self._task._role._role_path, 'files', source) else: source = self._loader.path_dwim(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) 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 self._shell.path_has_trailing_slash(dest): dest = self._shell.join_path(dest, '') else: source_files.append((source, os.path.basename(source))) changed = False diffs = [] module_result = {"changed": False} # A register for if we executed a module. # Used to cut down on command calls when not recursive. module_executed = False # Tell _execute_module to delete the file if there is one file. delete_remote_tmp = (len(source_files) == 1) # If this is a recursive action create a tmp path that we can share as the _exec_module create is too late. if not delete_remote_tmp: if tmp is None or "-tmp-" not in tmp: tmp = self._make_tmp_path() # expand any user home dir specifier dest = self._remote_expand_user(dest, tmp) for source_full, source_rel in source_files: # Generate a hash of the local file. local_checksum = checksum(source_full) # If local_checksum is not defined we can't find the file so we should fail out. if local_checksum is None: return dict(failed=True, msg="could not find src=%s" % source_full) # 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 self._shell.path_has_trailing_slash(dest): dest_file = self._shell.join_path(dest, source_rel) else: dest_file = self._shell.join_path(dest) # Attempt to get the remote checksum remote_checksum = self._remote_checksum(tmp, dest_file) if remote_checksum == '3': # The remote_checksum 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) return dict(failed=True, msg="can not use content with a dir as dest") else: # Append the relative source location to the destination and retry remote_checksum dest_file = self._shell.join_path(dest, source_rel) remote_checksum = self._remote_checksum(tmp, dest_file) if remote_checksum != '1' and not force: # remote_file does not exist so continue to next iteration. continue if local_checksum != remote_checksum: # The checksums don't match and we will change or error out. changed = True # Create a tmp path if missing only if this is not recursive. # If this is recursive we already have a tmp path. if delete_remote_tmp: if tmp is None or "-tmp-" not in tmp: tmp = self._make_tmp_path() # FIXME: runner shouldn't have the diff option there #if self.runner.diff and not raw: # diff = self._get_diff_data(tmp, dest_file, source_full) #else: # diff = {} diff = {} # FIXME: noop stuff #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 + 'source' if not raw: self._connection.put_file(source_full, tmp_src) else: self._connection.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._connection_info.sudo and self._connection_info.sudo_user != 'root' or self._connection_info.su and self._connection_info.su_user != 'root') and not raw: self._remote_chmod('a+r', tmp_src, tmp) 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 new_module_args = self._task.args.copy() new_module_args.update( dict( src=tmp_src, dest=dest, original_basename=source_rel, ) ) # FIXME: checkmode and no_log stuff #if self.runner.noop_on_check(inject): # new_module_args['CHECKMODE'] = True #if self.runner.no_log: # new_module_args['NO_LOG'] = True module_return = self._execute_module(module_name='copy', module_args=new_module_args, delete_remote_tmp=delete_remote_tmp) module_executed = True else: # no need to transfer the file, already correct hash, 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._remove_tmp_path(tmp) continue # Build temporary module_args. new_module_args = self._task.args.copy() new_module_args.update( dict( src=source_rel, dest=dest, original_basename=source_rel ) ) # FIXME: checkmode and no_log stuff #if self.runner.noop_on_check(inject): # new_module_args['CHECKMODE'] = True #if self.runner.no_log: # new_module_args['NO_LOG'] = True # Execute the file module. module_return = self._execute_module(module_name='file', module_args=new_module_args, delete_remote_tmp=delete_remote_tmp) module_executed = True if not module_return.get('checksum'): module_return['checksum'] = local_checksum if module_return.get('failed') == True: return module_return if module_return.get('changed') == True: changed = True # Delete tmp path if we were recursive or if we did not execute a module. if (not C.DEFAULT_KEEP_REMOTE_FILES and not delete_remote_tmp) \ or (not C.DEFAULT_KEEP_REMOTE_FILES and delete_remote_tmp and not module_executed): self._remove_tmp_path(tmp) # the file module returns the file path as 'path', but # the copy module uses 'dest', so add it if it's not there if 'path' in module_return and 'dest' not in module_return: module_return['dest'] = module_return['path'] # TODO: Support detailed status/diff for multiple files if len(source_files) == 1: result = module_return else: result = dict(dest=dest, src=source, changed=changed) # FIXME: move diffs into the result? #if len(diffs) == 1: # return ReturnData(conn=conn, result=result, diff=diffs[0]) #else: # return ReturnData(conn=conn, result=result) return 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, tmp, destination, source): peek_result = self._execute_module(module_name='file', module_args=dict(path=destination, diff_peek=True), persist_files=True) if 'failed' in peek_result and peek_result['failed'] or peek_result.get('rc', 0) != 0: return {} diff = {} if peek_result['state'] == 'absent': diff['before'] = '' elif peek_result['appears_binary']: diff['dst_binary'] = 1 # FIXME: this should not be in utils.. #elif peek_result['size'] > utils.MAX_FILE_SIZE_FOR_DIFF: # diff['dst_larger'] = utils.MAX_FILE_SIZE_FOR_DIFF else: dest_result = self._execute_module(module_name='slurp', module_args=dict(path=destination), tmp=tmp, persist_files=True) if 'content' in dest_result: dest_contents = dest_result['content'] if dest_result['encoding'] == 'base64': dest_contents = base64.b64decode(dest_contents) else: raise Exception("unknown encoding, failed: %s" % dest_result) diff['before_header'] = destination diff['before'] = dest_contents src = open(source) src_contents = src.read(8192) st = os.stat(source) if "\x00" in src_contents: diff['src_binary'] = 1 # FIXME: this should not be in utils #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)