#!/usr/bin/python
# -*- coding: utf-8 -*-

# (c) 2012, 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 shutil
import stat
import grp
import pwd
try:
    import selinux
    HAVE_SELINUX=True
except ImportError:
    HAVE_SELINUX=False

DOCUMENTATION = '''
---
module: file
version_added: "historical"
short_description: Sets attributes of files
description: 
     - Sets attributes of files, symlinks, and directories, or removes
       files/symlinks/directories. Many other modules support the same options as
       the M(file) module - including M(copy), M(template), and M(assemble).
options:
  path:
    description:
      - 'defines the file being managed, unless when used with C(state=link), and then sets the destination to create a symbolic link to using I(src). Aliases: I(dest), I(name)'
    required: true
    default: []
    aliases: ['dest', 'name'] 
  state:
    description:
      - If C(directory), all immediate subdirectories will be created if they
        do not exist. If C(file), the file will NOT be created if it does not
        exist, see the M(copy) or M(template) module if you want that behavior.
        If C(link), the symbolic link will be created or changed. Use C(hard)
        for hardlinks. If C(absent), directories will be recursively deleted,
        and files or symlinks will be unlinked. If C(touch) (new in 1.4), an empty file will 
        be created if the c(dest) does not exist, while an existing file or
        directory will receive updated file access and modification times (similar
        to the way `touch` works from the command line).
    required: false
    default: file
    choices: [ file, link, directory, hard, touch, absent ]
  mode:
    required: false
    default: null
    choices: []
    description:
      - mode the file or directory should be, such as 0644 as would be fed to I(chmod)
  owner:
    required: false
    default: null
    choices: []
    description:
      - name of the user that should own the file/directory, as would be fed to I(chown)
  group:
    required: false
    default: null
    choices: []
    description:
      - name of the group that should own the file/directory, as would be fed to I(chown)
  src:
    required: false
    default: null
    choices: []
    description:
      - path of the file to link to (applies only to C(state=link)). Will accept absolute,
        relative and nonexisting paths. Relative paths are not expanded.
  seuser:
    required: false
    default: null
    choices: []
    description:
      - user part of SELinux file context. Will default to system policy, if
        applicable. If set to C(_default), it will use the C(user) portion of the
        policy if available
  serole:
    required: false
    default: null
    choices: []
    description:
      - role part of SELinux file context, C(_default) feature works as for I(seuser).
  setype:
    required: false
    default: null
    choices: []
    description:
      - type part of SELinux file context, C(_default) feature works as for I(seuser).
  selevel:
    required: false
    default: "s0"
    choices: []
    description:
      - level part of the SELinux file context. This is the MLS/MCS attribute,
        sometimes known as the C(range). C(_default) feature works as for
        I(seuser).
  recurse:
    required: false
    default: "no"
    choices: [ "yes", "no" ]
    version_added: "1.1"
    description:
      - recursively set the specified file attributes (applies only to state=directory)
  force:
    required: false
    default: "no"
    choices: [ "yes", "no" ]
    description:
      - 'force the creation of the symlinks in two cases: the source file does 
        not exist (but will appear later); the destination exists and is a file (so, we need to unlink the
        "path" file and create symlink to the "src" file in place of it).'
notes:
    - See also M(copy), M(template), M(assemble)
requirements: [ ]
author: Michael DeHaan
'''

EXAMPLES = '''
- file: path=/etc/foo.conf owner=foo group=foo mode=0644
- file: src=/file/to/link/to dest=/path/to/symlink owner=foo group=foo state=link
'''

def main():

    # FIXME: pass this around, should not use global
    global module

    module = AnsibleModule(
        argument_spec = dict(
            state = dict(choices=['file','directory','link','hard','touch','absent'], default=None),
            path  = dict(aliases=['dest', 'name'], required=True),
            original_basename = dict(required=False), # Internal use only, for recursive ops
            recurse  = dict(default='no', type='bool'),
            force = dict(required=False,default=False,type='bool'),
            diff_peek = dict(default=None),
            validate = dict(required=False, default=None),
        ),
        add_file_common_args=True,
        supports_check_mode=True
    )

    params = module.params
    state  = params['state']
    force = params['force']
    params['path'] = path = os.path.expanduser(params['path'])

    # short-circuit for diff_peek
    if params.get('diff_peek', None) is not None:
        appears_binary = False
        try:
            f = open(path)
            b = f.read(8192)
            f.close()
            if b.find("\x00") != -1:
                appears_binary = True
        except:
            pass
        module.exit_json(path=path, changed=False, appears_binary=appears_binary)

    prev_state = 'absent'

    if os.path.lexists(path):
        if os.path.islink(path):
            prev_state = 'link'
        elif os.path.isdir(path):
            prev_state = 'directory'
        elif os.stat(path).st_nlink > 1:
            prev_state = 'hard'
        else:
            # could be many other things, but defaulting to file
            prev_state = 'file'

    if prev_state is not None and state is None:
        # set state to current type of file
        state = prev_state
    elif state is None:
        # set default state to file
        state = 'file'

    # source is both the source of a symlink or an informational passing of the src for a template module
    # or copy module, even if this module never uses it, it is needed to key off some things

    src = params.get('src', None)
    if src:
        src = os.path.expanduser(src)

    if src is not None and os.path.isdir(path) and state not in ["link", "absent"]:
        if params['original_basename']:
            basename = params['original_basename']
        else:
            basename = os.path.basename(src)
        params['path'] = path = os.path.join(path, basename)

    file_args = module.load_file_common_arguments(params)

    if state in ['link','hard'] and (src is None or path is None):
        module.fail_json(msg='src and dest are required for creating links')
    elif path is None:
        module.fail_json(msg='path is required')

    changed = False

    recurse = params['recurse']

    if recurse and state == 'file' and prev_state == 'directory':
        state = 'directory'

    if prev_state != 'absent' and state == 'absent':
        try:
            if prev_state == 'directory':
                if os.path.islink(path):
                    if module.check_mode:
                        module.exit_json(changed=True)
                    os.unlink(path)
                else:
                    try:
                        if module.check_mode:
                            module.exit_json(changed=True)
                        shutil.rmtree(path, ignore_errors=False)
                    except Exception, e:
                        module.fail_json(msg="rmtree failed: %s" % str(e))
            else:
                if module.check_mode:
                    module.exit_json(changed=True)
                os.unlink(path)
        except Exception, e:
            module.fail_json(path=path, msg=str(e))
        module.exit_json(path=path, changed=True)

    if prev_state != 'absent' and prev_state != state:
        if not (force and (prev_state == 'file' or prev_state == 'directory') and state == 'link') and state != 'touch':
            module.fail_json(path=path, msg='refusing to convert between %s and %s for %s' % (prev_state, state, src))

    if prev_state == 'absent' and state == 'absent':
        module.exit_json(path=path, changed=False)

    if state == 'file':

        if prev_state != 'file':
            module.fail_json(path=path, msg='file (%s) does not exist, use copy or template module to create' % path)

        changed = module.set_file_attributes_if_different(file_args, changed)
        module.exit_json(path=path, changed=changed)

    elif state == 'directory':
        if prev_state == 'absent':
            if module.check_mode:
                module.exit_json(changed=True)
            os.makedirs(path)
            changed = True

        changed = module.set_directory_attributes_if_different(file_args, changed)
        if recurse:
            for root,dirs,files in os.walk( file_args['path'] ):
                for dir in dirs:
                    dirname=os.path.join(root,dir)
                    tmp_file_args = file_args.copy()
                    tmp_file_args['path']=dirname
                    changed = module.set_directory_attributes_if_different(tmp_file_args, changed)
                for file in files:
                    filename=os.path.join(root,file)
                    tmp_file_args = file_args.copy()
                    tmp_file_args['path']=filename
                    changed = module.set_file_attributes_if_different(tmp_file_args, changed)
        module.exit_json(path=path, changed=changed)

    elif state in ['link','hard']:

        if state == 'hard':
            if os.path.isabs(src):
                abs_src = src
            else:
                module.fail_json(msg="absolute paths are required")

            if not os.path.exists(abs_src) and not force:
                module.fail_json(path=path, src=src, msg='src file does not exist')

        if prev_state == 'absent':
            changed = True
        elif prev_state == 'link':
            old_src = os.readlink(path)
            if old_src != src:
                changed = True
        elif prev_state == 'hard':
            if not (state == 'hard' and os.stat(path).st_ino == os.stat(src).st_ino):
                if not force:
                    module.fail_json(dest=path, src=src, msg='Cannot link, different hard link exists at destination')
                changed = True
        elif prev_state == 'file':
            if not force:
                module.fail_json(dest=path, src=src, msg='Cannot link, file exists at destination')
            changed = True
        elif prev_state == 'directory':
            if not force:
                module.fail_json(dest=path, src=src, msg='Cannot link, directory exists at destination')
            changed = True
        else:
            module.fail_json(dest=path, src=src, msg='unexpected position reached')

        if changed and not module.check_mode:
            if prev_state != 'absent':
                try:
                    os.unlink(path)
                except OSError, e:
                    module.fail_json(path=path, msg='Error while removing existing target: %s' % str(e))
            try:
                if state == 'hard':
                    os.link(src,path)
                else:
                    os.symlink(src, path)
            except OSError, e:
                module.fail_json(path=path, msg='Error while linking: %s' % str(e))

        changed = module.set_file_attributes_if_different(file_args, changed)
        module.exit_json(dest=path, src=src, changed=changed)

    elif state == 'touch':
        if module.check_mode:
            module.exit_json(path=path, skipped=True)

        if prev_state not in ['file', 'directory', 'absent']:
            module.fail_json(msg='Cannot touch other than files and directories')
        if prev_state != 'absent':
            try:
                os.utime(path, None)
            except OSError, e:
                module.fail_json(path=path, msg='Error while touching existing target: %s' % str(e))
        else:
            try:
                open(path, 'w').close()
            except OSError, e:
                module.fail_json(path=path, msg='Error, could not touch target: %s' % str(e))
        module.set_file_attributes_if_different(file_args, True)
        module.exit_json(dest=path, changed=True)

    else:
        module.fail_json(path=path, msg='unexpected position reached')

# import module snippets
from ansible.module_utils.basic import *
main()