#!/usr/bin/python 
# 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/>.

DOCUMENTATION = '''
---
module: vagrant
short_description: create a local instance via vagrant
description:
     - creates VM instances via vagrant and optionally waits for it to be 'running'. This module has a dependency on python-vagrant.
version_added: "100.0"
options:
  state:
    description:
      - Should the VMs be "present" or "absent."
  cmd:
    description:
      - vagrant subcommand to execute. Can be "up," "status," "config," "ssh," "halt," "destroy" or "clear." 
    required: false
    default: null
    aliases: ['command'] 
  box_name:
    description:
      - vagrant boxed image to start
    required: false
    default: null
    aliases: ['image']
  box_path:
    description:
      - path to vagrant boxed image to start
    required: false
    default: null
    aliases: []
  vm_name:
    description:
      - name to give an associated VM
    required: false
    default: null
    aliases: [] 
  count:
    description:
      - number of instances to launch
    required: False
    default: 1
    aliases: []
  forward_ports:
    description:
      - comma separated list of ports to forward to the host. If the port is under 1024, the host port will be the guest port +10000
    required: False
    aliases: []
  memory:
    description:
      - memory in MB    
    required: False
    
examples:
   - code: 'local_action: vagrant cmd=up box_name=lucid32 vm_name=webserver'
     description: 
requirements: [ "vagrant" ]
author: Rob Parrott
'''

VAGRANT_FILE = "./Vagrantfile"
VAGRANT_DICT_FILE = "./Vagrantfile.json"
VAGRANT_LOCKFILE = "./.vagrant-lock"

VAGRANT_FILE_HEAD = "Vagrant::Config.run do |config|\n"
VAGRANT_FILE_BOX_NAME = "  config.vm.box = \"%s\"\n"
VAGRANT_FILE_VM_STANZA_HEAD = """
  config.vm.define :%s do |%s_config|
    %s_config.vm.network :hostonly, "%s"
    %s_config.vm.box = "%s"
"""
VAGRANT_FILE_HOSTNAME_LINE     = "    %s_config.vm.host_name = \"%s\"\n"
VAGRANT_FILE_PORT_FORWARD_LINE = "    %s_config.vm.forward_port %s, %s\n"  
VAGRANT_FILE_MEMORY_LINE       = "    %s_config.vm.customize [\"modifyvm\", :id, \"--memory\", %s]\n" 
VAGRANT_FILE_VM_STANZA_TAIL="  end\n"

VAGRANT_FILE_TAIL = "\nend\n"

# If this is already a network on your machine, this may fail ... change it here.
VAGRANT_INT_IP = "192.168.179.%s"

DEFAULT_VM_NAME = "ansible"
DEFAULT_VM_RAM = 1024

import sys
import subprocess
#import time
import os.path
import json

try:
    import lockfile
except ImportError:
    print "Python module lockfile is not installed. Falling back to using flock(), which will fail on Windows."
    
try:
    import vagrant
except ImportError:
    print "failed=True msg='python-vagrant required for this module'"
    sys.exit(1)

class VagrantWrapper(object):

    def __init__(self):
        '''
        Wrapper around the python-vagrant module for use with ansible.
        Note that Vagrant itself is non-thread safe, as is the python-vagrant lib, so we need to lock on basically all operations ...
        '''
        # Get a lock
        self.lock = None

        try:
            self.lock = lockfile.FileLock(VAGRANT_LOCKFILE)
            self.lock.acquire()
        except:
            # fall back to using flock instead ...
            try:
                import fcntl
                self.lock = open(VAGRANT_LOCKFILE, 'w')
                fcntl.flock(self.lock, fcntl.LOCK_EX)
            except:
                print "failed=True msg='Could not get a lock for using vagrant. Install python module \"lockfile\" to use vagrant on non-POSIX filesytems.'"
                sys.exit(1)
            
        # Initialize vagrant and state files
        self.vg = vagrant.Vagrant()
        
        # operation will create a default data structure if none present
        self._deserialize()  
        self._serialize()
        
    def __del__(self):
        '''Clean up file locks'''
        try:
            self.lock.release()
        except:
            os.close(self.lock)
            os.unlink(self.lock)
        
    def prepare_box(self, box_name, box_path):
        '''Given a specified name and URL, import a Vagrant "box" for use.'''
        changed = False
        if box_name == None:
            raise Exception("You must specify a box_name with a box_path for vagrant.")
        boxes = self.vg.box_list()
        if not box_name in boxes:
            self.vg.box_add(box_name, box_path)
            changed = True
            
        return changed
             
    def up(self, box_name, vm_name=None, count=1, box_path=None, ports=[]):    
        '''Fire up a given VM and name it, using vagrant's multi-VM mode.'''

        changed = False
        if vm_name == None: 
            vm_name = DEFAULT_VM_NAME
        
        if box_name == None:
            raise Exception("You must specify a box name for Vagrant.")
        if box_path != None: 
            changed = self.prepare_box(box_name, box_path)
        
        for icount in range(int(count)):
            
            self._deserialize()
            
            this_instance_dict = self._get_instance(vm_name,icount)
            if not this_instance_dict.has_key('box_name'): 
                this_instance_dict['box_name'] = box_name   
                     
            this_instance_dict['forward_ports'] = ports  
            
            # Save our changes and run
            inst_array = self._instances()[vm_name]
            inst_array[icount] = this_instance_dict    
            
            self._serialize()
            
            # See if we need to fire it up ...
            vgn = this_instance_dict['vagrant_name']
            status = self.vg.status(vgn)
            if status != 'running':
                self.vg.up(False, this_instance_dict['vagrant_name'])
                changed =True
                
        ansible_instance_array = self._build_instance_array_for_ansible(vm_name)
        return (changed, ansible_instance_array)
    
    def status(self, vm_name = None, index = -1):
        '''Return the run status of the VM instance. If no instance N is given, returns first instance.'''
        vm_names = []
        if vm_name != None: vm_names = [vm_name]
        else:
            vm_names = self._instances().keys()
        
        statuses = {}
        for vmn in vm_names:
            stat_array = []
            instance_array = self.vg_data['instances'][vmn]
            if index >= 0:
                instance_array = [ self._get_instance(vmn,index) ]
            for inst in instance_array:
                vgn = inst['vagrant_name']
                stat_array.append(self.vg.status(vgn))
            statuses[vmn] = stat_array     
                    
        return (False, statuses)
            
    def config(self, vm_name, index = -1):
        '''Return info on SSH for the running instance.'''
        vm_names = []
        if vm_name != None: vm_names = [vm_name]
        else:
            vm_names = self._instances().keys()
        
        configs = {}
        for vmn in vm_names:
            conf_array = []
            instance_array = self.vg_data['instances'][vmn]
            if index >= 0:
                instance_array = [ self._get_instance(vmn,index) ]
            for inst in instance_array:
                cnf = self.vg.conf(None, inst['vagrant_name'])
                conf_array.append(cnf)
            configs[vmn] = conf_array     
                            
        return (False, configs)

    def halt(self, vm_name = None, index = -1):
        '''Shuts down a vm_name or all VMs.'''
        
        changed = False
        vm_names = []
        if vm_name != None: vm_names = [vm_name]
        else:
            vm_names = self._instances().keys()
        
        statuses = {}
        for vmn in vm_names:
            stat_array = []
            instance_array = self.vg_data['instances'][vmn]
            if index >= 0:
                instance_array = [ self.vg_data['instances'][vmn][index] ]
            for inst in instance_array:
                vgn = inst['vagrant_name']
                if self.vg.status(vgn) == 'running':
                    self.vg.halt(vgn)
                    changed = True
                stat_array.append(self.vg.status(vgn))
            statuses[vmn] = stat_array
            
        return (changed, statuses)         
            
    def destroy(self, vm_name=None, index = -1):
        '''Halt and remove data for a VM, or all VMs.'''
        
        self._deserialize()
        
        (changed, stats) = self.halt(vm_name, index)       
    
        self.vg.destroy(vm_name)
        if vm_name != None:
            self._instances().pop(vm_name)
        else:
            self.vg_data['instances'] = {}
            
        self._serialize()

        changed = True
        
        return changed
        
    def clear(self, vm_name=None):
        '''Halt and remove data for a VM, or all VMs. Also clear all state data.'''
        
        changed = self.vg.destroy(vm_name)
        
        if os.path.isfile(VAGRANT_FILE):
            os.remove(VAGRANT_FILE)
        if os.path.isfile(VAGRANT_DICT_FILE):
            os.remove(VAGRANT_DICT_FILE)            

        return changed           
#
# Helper Methods
#
    def _instances(self): 
        return self.vg_data['instances']
    
    def _get_instance(self, vm_name, index):
    
        instances = self._instances()

        inst_array = []        
        if instances.has_key(vm_name):
            inst_array = instances[vm_name]
            
        if len(inst_array) > index: 
            return inst_array[index]
        
        # 
        # otherwise create one afresh
        #
        this_instance_N = self.vg_data['num_inst']+1
        name_for_vagrant = "%s%d" % (vm_name.replace("-","_"),index)
        
        instance_dict = dict(
          n = index,
          N = this_instance_N,
          name = vm_name,
          vagrant_name = name_for_vagrant,
          internal_ip = VAGRANT_INT_IP % (255-this_instance_N),
          forward_ports = [],
          ram = DEFAULT_VM_RAM,
        )

        # Save this ...
        self.vg_data['num_inst'] = this_instance_N
        inst_array.append(instance_dict)
        
        self._instances()[vm_name] = inst_array
        
        return instance_dict          
    
    #
    # Serialize/Deserialize current state to a JSON representation, and 
    #  a file format for Vagrant.
    #
    # This is where we need to deal with file locking, since multiple threads/procs
    #  may be trying to operate on the same files 
    # 
    
    def _serialize(self):
        '''Save state to a JSON file, and write the Vagrantfile based on this.'''
        self._save_state()
        self._write_vagrantfile()
        
    def _deserialize(self): 
        '''Load in data from the JSON state file.'''
        self._load_state()
        
    
    #
    # Manage a JSON representation of vagrantfile for statefulness across invocations. 
    #
    def _load_state(self):        
        self.vg_data = dict(num_inst=0, instances = {})
        if os.path.isfile(VAGRANT_DICT_FILE):
            json_file=open(VAGRANT_DICT_FILE)
            self.vg_data = json.load(json_file)
            json_file.close()

#    def _state_as_string(self):
#        from StringIO import StringIO
#        io = StringIO()
#        json.dump(self.vg_data, io)
#        return io.getvalue()

    def _save_state(self):
        json_file=open(VAGRANT_DICT_FILE, 'w')
        json.dump(self.vg_data,json_file, sort_keys=True, indent=4, separators=(',', ': '))
        json_file.close()
      
    #
    # Translate the state dictionary into the Vagrantfile
    #    
    def _write_vagrantfile(self):

        vfile = open(VAGRANT_FILE, 'w')
        vfile.write(VAGRANT_FILE_HEAD)

        instances = self._instances()
        for vm_name in instances.keys():
            inst_array = instances[vm_name]
            for index in range(len(inst_array)):
                instance_dict = inst_array[index] 
                name     = instance_dict['vagrant_name']
                ip       = instance_dict['internal_ip']
                box_name = instance_dict['box_name']
                vfile.write(VAGRANT_FILE_VM_STANZA_HEAD % 
                            (name, name, name, ip, name, box_name) )
                if instance_dict.has_key('ram'):
                    vfile.write(VAGRANT_FILE_MEMORY_LINE  % (name, instance_dict['ram'])  )   
                vfile.write(VAGRANT_FILE_HOSTNAME_LINE  % (name, name.replace('_','-'))  )       
                if instance_dict.has_key('forward_ports'):
                    for port in instance_dict['forward_ports']:
                        port = int(port)
                        host_port = port
                        if port < 1024: 
                            host_port = port + 10000
                        vfile.write(VAGRANT_FILE_PORT_FORWARD_LINE % (name, port, host_port) )
                vfile.write(VAGRANT_FILE_VM_STANZA_TAIL)
  
        vfile.write(VAGRANT_FILE_TAIL)
        vfile.close()
        
    #
    # To be returned to ansible with info about instances
    #        
    def _build_instance_array_for_ansible(self, vmname=None):
    
        vm_names = []
        instances = self._instances()
        if vmname != None:
            vm_names = [vmname]
        else:
            vm_names = instances.keys()
        
        ans_instances = []   
        for vm_name in vm_names:
            for inst in instances[vm_name]:
                vagrant_name = inst['vagrant_name']
                cnf = self.vg.conf(None,vagrant_name) 
                vg_data = instances[vm_name]
                if cnf != None:
                    instance_dict = dict(
                      name            = vm_name,
                      vagrant_name    = vagrant_name, 
                      id              = cnf['Host'],
                      public_ip       = cnf['HostName'],
                      internal_ip     = inst['internal_ip'],
                      public_dns_name = cnf['HostName'],
                      port            = cnf['Port'],
                      username        = cnf['User'],
                      key             = cnf['IdentityFile'],
                      status          = self.vg.status(vagrant_name)           
                    )
                    ans_instances.append(instance_dict)

        return ans_instances
         
#--------
# MAIN
#--------
def main():
    
    module = AnsibleModule(
        argument_spec = dict(
            state=dict(),
            cmd=dict(required=False, aliases = ['command']),
            box_name=dict(required=False, aliases = ['image']),
            box_path=dict(),
            vm_name=dict(),
            forward_ports=dict(),
            count = dict(default='1'), 
       )
   )
    
    state = module.params.get('state')
    cmd = module.params.get('cmd')
    box_name = module.params.get('box_name')
    box_path = module.params.get('box_path')
    vm_name = module.params.get('vm_name')
    forward_ports = module.params.get('forward_ports')     

    if forward_ports != None:
        forward_ports=forward_ports.split(',')
    if forward_ports == None: 
        forward_ports=[]

    count = module.params.get('count') 
 
    # Initialize vagrant
    vgw = VagrantWrapper()
    
    #
    # Check if we are being invoked under an idempotency idiom of "state=present" or "state=absent"
    #
    try:
        if state != None:
            
            if state != 'present' and state != 'absent':
                module.fail_json(msg = "State must be \"present\" or \"absent\" in vagrant module.")
                 
            if state == 'present':
               
                changd, insts = vgw.up(box_name, vm_name, count, box_path, forward_ports)
                module.exit_json(changed = changd, instances = insts)
                 
            if state == 'absent':
                changd = vgw.halt(vm_name)    
                module.exit_json(changed = changd, status = vgw.status(vm_name))
                 
                 
        #
        # Main command tree for old style invocation
        #                     
            
        else:

            if cmd == 'up':
            
                if count == None: 
                    count = 1
                (changd, insts) = vgw.up(box_name, vm_name, count, box_path, forward_ports)
                module.exit_json(changed = changd, instances = insts)

            elif cmd == 'status':

#            if vm_name == None:
#                module.fail_json(msg = "Error: you must specify a vm_name when calling status." )
                
                (changd, result) = vgw.status(vm_name)
                module.exit_json(changed = changd, status = result)

            elif cmd == "config" or cmd == "conf":
            
                if vm_name == None:
                    module.fail_json(msg = "Error: you must specify a vm_name when calling config." )
                (changd, cnf) = vgw.config(vm_name)
                module.exit_json(changed = changd, config = cnf)

            elif cmd == 'ssh':
            
                if vm_name == None:
                    module.fail_json(msg = "Error: you must specify a vm_name when calling ssh." )             
                            
                (changd, cnf) = vgw.config(vm_name)
                sshcmd = "ssh -i %s -p %s %s@%s" % (cnf["IdentityFile"], cnf["Port"], cnf["User"], cnf["HostName"])
                sshmsg = "Execute the command \"vagrant ssh %s\"" % (vm_name)
                module.exit_json(changed = changd, msg = sshmsg, SshCommand = sshcmd)
           
            elif cmd == 'halt':

                (changd, stats) = vgw.halt(vm_name)
                module.exit_json(changed = changd, status = stats)

            elif cmd == 'destroy':

                changd = vgw.destroy(vm_name)    
                module.exit_json(changed = changd, status = vgw.status(vm_name))
            
            elif cmd == 'clear':
            
                changd = vgw.clear()          
                module.exit_json(changed = changd)
            
            else:
            
                module.fail_json(msg = "Unknown vagrant subcommand: \"%s\"." % (cmd))
            
    except subprocess.CalledProcessError as errer:     
        module.fail_json(msg = "Vagrant command failed: %s." % (errer))
    except Exception as errer:
        module.fail_json(msg = errer.__str__())
    module.exit_json(status = "success")
  

    

# this is magic, see lib/ansible/module_common.py
#<<INCLUDE_ANSIBLE_MODULE_COMMON>>

main()