mirror of https://github.com/ansible/ansible.git
You cannot select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
430 lines
16 KiB
Python
430 lines
16 KiB
Python
#!/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
|
|
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 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
|
|
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 = 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(f_ip.ip)
|
|
|
|
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(new_ip.ip)
|
|
|
|
# finally, add ip(s) to instance
|
|
for ip in usable_floating_ips:
|
|
try:
|
|
server.add_floating_ip(ip)
|
|
except Exception, e:
|
|
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 _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'],
|
|
'key_name': module.params['key_name'],
|
|
'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'],
|
|
}
|
|
if not module.params['key_name']:
|
|
del bootkwargs['key_name']
|
|
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 = [ x['addr'] for x in getattr(server, 'addresses').itervalues().next() if 'OS-EXT-IPS:type' in x and x['OS-EXT-IPS:type'] == 'fixed']
|
|
public = [ x['addr'] for x in getattr(server, 'addresses').itervalues().next() if 'OS-EXT-IPS:type' in x and x['OS-EXT-IPS:type'] == 'floating']
|
|
# 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 = [ x['addr'] for x in getattr(server, 'addresses').itervalues().next() if x['OS-EXT-IPS:type'] == 'fixed']
|
|
public = [ x['addr'] for x in getattr(server, 'addresses').itervalues().next() if x['OS-EXT-IPS:type'] == 'floating']
|
|
|
|
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 = [ x['addr'] for x in getattr(server, 'addresses').itervalues().next() if 'OS-EXT-IPS:type' in x and x['OS-EXT-IPS:type'] == 'fixed']
|
|
public = [ x['addr'] for x in getattr(server, 'addresses').itervalues().next() if 'OS-EXT-IPS:type' in x and x['OS-EXT-IPS:type'] == 'floating']
|
|
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)
|
|
),
|
|
)
|
|
|
|
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()
|
|
|