community.general/library/cloud/nova_compute

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

# (c) 2013, Benno Joy <benno@ansible.com>
# (c) 2013, John Dewey <john@dewey.ws>
#
# This module 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.
#
# This software 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 this software.  If not, see <http://www.gnu.org/licenses/>.

try:
    from novaclient.v1_1 import client as nova_client
    from novaclient.v1_1 import floating_ips 
    from novaclient import exceptions
    from novaclient import utils
    import time
except ImportError:
    print("failed=True msg='novaclient is required for this module'")

DOCUMENTATION = '''
---
module: nova_compute
version_added: "1.2"
short_description: Create/Delete VMs from OpenStack
description:
   - Create or Remove virtual machines from Openstack.
options:
   login_username:
     description:
        - login username to authenticate to keystone
     required: true
     default: admin
   login_password:
     description:
        - Password of login user
     required: true
     default: 'yes'
   login_tenant_name:
     description:
        - The tenant name of the login user
     required: true
     default: 'yes'
   auth_url:
     description:
        - The keystone url for authentication
     required: false
     default: 'http://127.0.0.1:35357/v2.0/'
   region_name:
     description:
        - Name of the region
     required: false
     default: None
   state:
     description:
        - Indicate desired state of the resource
     choices: ['present', 'absent']
     default: present
   name:
     description:
        - Name that has to be given to the instance
     required: true
     default: None
   image_id:
     description:
        - The id of the image that has to be cloned
     required: true
     default: None
   flavor_id:
     description:
        - The id of the flavor in which the new VM has to be created
     required: false
     default: 1
   key_name:
     description:
        - The key pair name to be used when creating a VM
     required: false
     default: None
   security_groups:
     description:
        - The name of the security group to which the VM should be added
     required: false
     default: None
   nics:
     description:
        - A list of network id's to which the VM's interface should be attached
     required: false
     default: None
   floating_ip:
     description:
        - list of key value pairs that determine how to assign, if specified, floating IPs. Either use an explicite list of valid floating IPs, list of floating IP pools to choose from, or auto-assign 
     required: false
     default: None
   availability_zone:
     description:
        - Name of the availability zone
     required: false
     default: None
   meta:
     description:
        - A list of key value pairs that should be provided as a metadata to the new VM
     required: false
     default: None
   wait:
     description:
        - If the module should wait for the VM to be created.
     required: false
     default: 'yes'
   wait_for:
     description:
        - The amount of time the module should wait for the VM to get into active state
     required: false
     default: 180
   user_data:
     description:
        - Opaque blob of data which is made available to the instance
     required: false
     default: None
     version_added: "1.6"
requirements: ["novaclient"]
'''

EXAMPLES = '''
# Creates a new VM and attaches to a network and passes metadata to the instance
- nova_compute:
       state: present
       login_username: admin
       login_password: admin
       login_tenant_name: admin
       name: vm1
       image_id: 4f905f38-e52a-43d2-b6ec-754a13ffb529
       key_name: ansible_key
       wait_for: 200
       flavor_id: 4
       nics:
         - net-id: 34605f38-e52a-25d2-b6ec-754a13ffb723
       meta:
         hostname: test1
         group: uge_master

# Creates a new VM in HP Cloud AE1 region availability zone az2 and automatically assigns a floating IP
- name: launch a nova instance
  hosts: localhost
  tasks:
  - name: launch an instance
    nova_compute:
      state: present
      login_username: username 
      login_password: Equality7-2521 
      login_tenant_name: username-project1
      name: vm1
      auth_url: https://region-b.geo-1.identity.hpcloudsvc.com:35357/v2.0/
      region_name: region-b.geo-1
      availability_zone: az2
      image_id: 9302692b-b787-4b52-a3a6-daebb79cb498
      key_name: test
      wait_for: 200
      flavor_id: 101
      security_groups: default
      floating_ip:
        auto: True

# If one wants to specify a floating ip to use:
      <snip>
      floating_ip:
        ips: 
          - 15.126.238.160

'''



def _delete_server(module, nova):
    name = None
    server_list = None
    try:
        server_list = nova.servers.list(True, {'name': module.params['name']})
        if server_list:
            server = [x for x in server_list if x.name == module.params['name']]
            nova.servers.delete(server.pop())
    except Exception, e:
        module.fail_json( msg = "Error in deleting vm: %s" % e.message)
    if module.params['wait'] == 'no':
        module.exit_json(changed = True, result = "deleted")
    expire = time.time() + int(module.params['wait_for'])
    while time.time() < expire:
        name = nova.servers.list(True, {'name': module.params['name']})
        if not name:
            module.exit_json(changed = True, result = "deleted")
        time.sleep(5)
    module.fail_json(msg = "Timed out waiting for server to get deleted, please check manually")


def _add_floating_ip_from_pool(module, nova, server, floating_ip_obj):

    # empty dict and list 
    usable_floating_ips = {} 
    pools = []

    # user specified
    pools = module.params['floating_ip']['pools']

    # get the list of all floating IPs. Mileage may 
    # vary according to Nova Compute configuration 
    # per cloud provider
    all_floating_ips = floating_ip_obj.list()

    # iterate through all pools of IP address. Empty
    # string means all and is the default value
    for pool in pools:
        # temporary list per pool
        pool_ips = []
        # loop through all floating IPs
        for f_ip in all_floating_ips:
            # if not reserved and the correct pool, add
            if f_ip.instance_id is None and (f_ip.pool == pool):
                pool_ips.append(f_ip.ip)
                # only need one
                break

        # if the list is empty, add for this pool
        if not pool_ips:
            try:
                new_ip = nova.floating_ips.create(pool)
            except Exception, e: 
                module.fail_json(msg = "Unable to create floating ip")
            pool_ips.append(new_ip.ip)
        # Add to the main list
        usable_floating_ips[pool] = pool_ips

    # finally, add ip(s) to instance for each pool
    for pool in usable_floating_ips:
        for ip in usable_floating_ips[pool]:
            try:
                server.add_floating_ip(ip)
                # We only need to assign one ip - but there is an inherent
                # race condition and some other cloud operation may have
                # stolen an available floating ip
                break
            except Exception, e:
                module.fail_json(msg = "Error attaching IP %s to instance %s: %s " % (ip, server.id, e.message))


def _add_floating_ip_no_pool(module, nova, server, floating_ip_obj):

    usable_floating_ips = list()

    # if there is a list of IP addresses, make that the list 
    if module.params['floating_ip'].has_key('ips'):
        usable_floating_ips = [dict(ip=f, created=False) for f in module.params['floating_ip']['ips']]
    else:
        # get the list of all floating IPs. Mileage may 
        # vary according to Nova Compute configuration 
        # per cloud provider
        for f_ip in floating_ip_obj.list():
            # if not reserved and the correct pool, add
            if f_ip.instance_id is None:
                usable_floating_ips.append(dict(ip=f_ip.ip, created=False))

        if not usable_floating_ips:
            try:
                new_ip = nova.floating_ips.create()
            except Exception, e: 
                module.fail_json(msg = "Unable to create floating ip")
            usable_floating_ips.append(dict(ip=new_ip.ip, created=True))

    # finally, add ip(s) to instance
    for ip in usable_floating_ips:
        try:
            server.add_floating_ip(ip['ip'])
        except Exception, e:
            # Clean up - we auto-created this ip, and it's not attached
            # to the server, so the cloud will not know what to do with it
            server.floating_ips.delete(ip['ip'])
            module.fail_json(msg = "Error attaching IP %s to instance %s: %s " % (ip, server.id, e.message))


def _add_floating_ip(module, nova, server):
    # instantiate FloatingIPManager object
    floating_ip_obj = floating_ips.FloatingIPManager(nova)

    if module.params['floating_ip'].has_key('pools'):
        _add_floating_ip_from_pool(module, nova, server, floating_ip_obj)
    else: 
        _add_floating_ip_no_pool(module, nova, server, floating_ip_obj)

    # this may look redundant, but if there is now a 
    # floating IP, then it needs to be obtained from
    # a recent server object if the above code path exec'd 
    try:
        server = nova.servers.get(server.id)
    except Exception, e:
        module.fail_json(msg = "Error in getting info from instance: %s " % e.message)
    return server


def _get_ips(addresses, ext_tag, key_name):

    ret = []
    for (k, v) in addresses.iteritems():
        if k == key_name:
            ret.extend([addrs['addr'] for addrs in v])
        else:
            for interface_spec in v:
                if 'OS-EXT-IPS:type' in interface_spec and interface_spec['OS-EXT-IPS:type'] == ext_tag:
                    ret.append(interface_spec['addr'])
    return ret


def _create_server(module, nova):
    # issue an error early on and not launch the instance
    if module.params['floating_ip'] is not None:
        if module.params['floating_ip'].has_key('ips'):
            # can't specify "ips" and "auto" both 
            if module.params['floating_ip'].has_key('auto') and module.params['floating_ip']['auto']:
                module.fail_json(msg = "For floating_ips - you cannot specify both 'auto' and 'ips'!")
            # can't specify "ips" and "pools" both 
            if module.params['floating_ip'].has_key('pools'):
                module.fail_json(msg = "For floating_ips - you cannot specify both 'pools' and 'ips'!")

    bootargs = [module.params['name'], module.params['image_id'], module.params['flavor_id']]
    bootkwargs = {
                'nics' : module.params['nics'],
                'meta' : module.params['meta'],
                'security_groups': module.params['security_groups'].split(','),
                #userdata is unhyphenated in novaclient, but hyphenated here for consistency with the ec2 module:
                'userdata': module.params['user_data'],
    }

    for optional_param in ('region_name', 'key_name', 'availability_zone'):
        if module.params[optional_param]:
            bootkwargs[optional_param] = module.params[optional_param]
    try:
        server = nova.servers.create(*bootargs, **bootkwargs)
        server = nova.servers.get(server.id)
    except Exception, e:
            module.fail_json( msg = "Error in creating instance: %s " % e.message)
    if module.params['wait'] == 'yes':
        expire = time.time() + int(module.params['wait_for'])
        while time.time() < expire:
            try:
                server = nova.servers.get(server.id)
            except Exception, e:
                    module.fail_json( msg = "Error in getting info from instance: %s" % e.message)
            if server.status == 'ACTIVE':
                # if floating_ip is specified, then attach 
                if module.params['floating_ip'] is not None:
                    server = _add_floating_ip(module, nova, server)

                private = _get_ips(getattr(server, 'addresses'), 'fixed', 'private')
                public = _get_ips(getattr(server, 'addresses'), 'floating', 'public')

                # now exit with info 
                module.exit_json(changed = True, id = server.id, private_ip=''.join(private), public_ip=''.join(public), status = server.status, info = server._info)

            if server.status == 'ERROR':
                module.fail_json(msg = "Error in creating the server, please check logs")
            time.sleep(2)

        module.fail_json(msg = "Timeout waiting for the server to come up.. Please check manually")
    if server.status == 'ERROR':
            module.fail_json(msg = "Error in creating the server.. Please check manually")
    private = _get_ips(getattr(server, 'addresses'), 'fixed', 'private')
    public = _get_ips(getattr(server, 'addresses'), 'floating', 'public')

    module.exit_json(changed = True, id = info['id'], private_ip=''.join(private), public_ip=''.join(public), status = server.status, info = server._info)


def _get_server_state(module, nova):
    server = None
    try:
        servers = nova.servers.list(True, {'name': module.params['name']})
        if servers:
            # the {'name': module.params['name']} will also return servers
            # with names that partially match the server name, so we have to
            # strictly filter here
            servers = [x for x in servers if x.name == module.params['name']]
            if servers:
                server = servers[0]
    except Exception, e:
        module.fail_json(msg = "Error in getting the server list: %s" % e.message)
    if server and module.params['state'] == 'present':
        if server.status != 'ACTIVE':
            module.fail_json( msg="The VM is available but not Active. state:" + server.status)
        private = _get_ips(getattr(server, 'addresses'), 'fixed', 'private')
        public = _get_ips(getattr(server, 'addresses'), 'floating', 'public')
        module.exit_json(changed = False, id = server.id, public_ip = ''.join(public), private_ip = ''.join(private), info = server._info)
    if server and module.params['state'] == 'absent':
        return True
    if module.params['state'] == 'absent':
        module.exit_json(changed = False, result = "not present")
    return True



def main():
    module = AnsibleModule(
        argument_spec                   = dict(
        login_username                  = dict(default='admin'),
        login_password                  = dict(required=True),
        login_tenant_name               = dict(required='True'),
        auth_url                        = dict(default='http://127.0.0.1:35357/v2.0/'),
        region_name                     = dict(default=None),
        name                            = dict(required=True),
        image_id                        = dict(default=None),
        flavor_id                       = dict(default=1),
        key_name                        = dict(default=None),
        security_groups                 = dict(default='default'),
        nics                            = dict(default=None),
        meta                            = dict(default=None),
        wait                            = dict(default='yes', choices=['yes', 'no']),
        wait_for                        = dict(default=180),
        state                           = dict(default='present', choices=['absent', 'present']),
        user_data                       = dict(default=None),
        floating_ip                     = dict(default=None),
        availability_zone               = dict(default=None),
        ),
    )

    nova = nova_client.Client(module.params['login_username'],
                              module.params['login_password'],
                              module.params['login_tenant_name'],
                              module.params['auth_url'],
                              region_name=module.params['region_name'],
                              service_type='compute')
    try:
        nova.authenticate()
    except exceptions.Unauthorized, e:
        module.fail_json(msg = "Invalid OpenStack Nova credentials.: %s" % e.message)
    except exceptions.AuthorizationFailure, e:
        module.fail_json(msg = "Unable to authorize user: %s" % e.message)

    if module.params['state'] == 'present':
        if not module.params['image_id']:
            module.fail_json( msg = "Parameter 'image_id' is required if state == 'present'")
        else:
            _get_server_state(module, nova)
            _create_server(module, nova)
    if module.params['state'] == 'absent':
        _get_server_state(module, nova)
        _delete_server(module, nova)

# this is magic, see lib/ansible/module.params['common.py
from ansible.module_utils.basic import *
main()