Revert "Remove neutron library"
Using the upstream library breaks the ability to test network plugins
that use 'local' neutron networks (ie. calico).
https://github.com/ansible/ansible-modules-core/issues/5589
This reverts commit 38b899b63b.
Change-Id: I8a33db524c24324dc2af8463a43cb145f7cc34d6
This commit is contained in:
Logan V
parent
0af898835a
commit
800ef36999
|
|
@ -12,6 +12,7 @@ This project provides the Ansible modules:
|
|||
* keystone
|
||||
* memcached
|
||||
* name2int
|
||||
* neutron
|
||||
* provider_networks
|
||||
|
||||
Filters
|
||||
|
|
|
|||
|
|
@ -0,0 +1,465 @@
|
|||
#!/usr/bin/env python
|
||||
# Copyright 2014, Rackspace US, Inc.
|
||||
#
|
||||
# Licensed under the Apache License, Version 2.0 (the "License");
|
||||
# you may not use this file except in compliance with the License.
|
||||
# You may obtain a copy of the License at
|
||||
#
|
||||
# http://www.apache.org/licenses/LICENSE-2.0
|
||||
#
|
||||
# Unless required by applicable law or agreed to in writing, software
|
||||
# distributed under the License is distributed on an "AS IS" BASIS,
|
||||
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
||||
# See the License for the specific language governing permissions and
|
||||
# limitations under the License.
|
||||
|
||||
|
||||
import keystoneclient.v3.client as ksclient
|
||||
from neutronclient.neutron import client as nclient
|
||||
|
||||
# import module snippets
|
||||
from ansible.module_utils.basic import *
|
||||
|
||||
|
||||
DOCUMENTATION = """
|
||||
---
|
||||
module: neutron
|
||||
short_description:
|
||||
- Basic module for interacting with openstack neutron
|
||||
description:
|
||||
- Basic module for interacting with openstack neutron
|
||||
options:
|
||||
command:
|
||||
description:
|
||||
- Operation for the module to perform. Currently available
|
||||
choices:
|
||||
- create_network
|
||||
- create_subnet
|
||||
- create_router
|
||||
- add_router_interface
|
||||
- get_networks
|
||||
required: True
|
||||
openrc_path:
|
||||
decription:
|
||||
- Path to openrc file from which credentials and keystone endpoint
|
||||
will be extracted
|
||||
net_name:
|
||||
description:
|
||||
- Name of network
|
||||
subnet_name:
|
||||
description:
|
||||
- Name of subnet
|
||||
allocation_pools:
|
||||
description:
|
||||
- List of allocation pools for a subnet. Format is
|
||||
startip-endip[,startip-endip]...
|
||||
router_name:
|
||||
description:
|
||||
- Name of router
|
||||
cidr:
|
||||
description:
|
||||
- Specify CIDR to use when creating subnet
|
||||
provider_physical_network:
|
||||
description:
|
||||
- Specify provider:physical_network when creating network
|
||||
provider_network_type:
|
||||
description:
|
||||
- Specify provider:network_type when creating network
|
||||
provider_segmentation_id:
|
||||
description:
|
||||
- Specify provider:segmentation_id when creating network
|
||||
router_external:
|
||||
description:
|
||||
- Specify router:external' when creating network
|
||||
external_gateway_info:
|
||||
description:
|
||||
- Specify external_gateway_info when creating router
|
||||
insecure:
|
||||
description:
|
||||
- Explicitly allow client to perform "insecure" TLS
|
||||
choices:
|
||||
- false
|
||||
- true
|
||||
default: false
|
||||
author: Hugh Saunders
|
||||
"""
|
||||
|
||||
EXAMPLES = """
|
||||
- name: Create private network
|
||||
neutron:
|
||||
command: create_network
|
||||
openrc_path: /root/openrc
|
||||
net_name: private
|
||||
- name: Create public network
|
||||
neutron:
|
||||
command: create_network
|
||||
openrc_path: /root/openrc
|
||||
net_name: public
|
||||
provider_network_type: flat
|
||||
provider_physical_network: vlan
|
||||
router_external: true
|
||||
- name: Create private subnet
|
||||
neutron:
|
||||
command: create_subnet
|
||||
openrc_path: /root/openrc
|
||||
net_name: private
|
||||
subnet_name: private-subnet
|
||||
cidr: "192.168.74.0/24"
|
||||
- name: Create public subnet
|
||||
neutron:
|
||||
command: create_subnet
|
||||
openrc_path: /root/openrc
|
||||
net_name: public
|
||||
subnet_name: public-subnet
|
||||
cidr: "10.1.13.0/24"
|
||||
- name: Create router
|
||||
neutron:
|
||||
command: create_router
|
||||
openrc_path: /root/openrc
|
||||
router_name: router
|
||||
external_gateway_info: public
|
||||
- name: Add private subnet to router
|
||||
neutron:
|
||||
command: add_router_interface
|
||||
openrc_path: /root/openrc
|
||||
router_name: router
|
||||
subnet_name: private-subnet
|
||||
- name: Get network information
|
||||
command: get_network
|
||||
openrc_path: /root/openrc
|
||||
net_name: public
|
||||
"""
|
||||
|
||||
|
||||
COMMAND_MAP = {
|
||||
'create_network': {
|
||||
'variables': [
|
||||
'net_name',
|
||||
'provider_physical_network',
|
||||
'provider_network_type',
|
||||
'provider_segmentation_id',
|
||||
'router_external',
|
||||
'tenant_id'
|
||||
]
|
||||
},
|
||||
'create_subnet': {
|
||||
'variables': [
|
||||
'net_name',
|
||||
'subnet_name',
|
||||
'cidr',
|
||||
'tenant_id',
|
||||
'allocation_pools'
|
||||
]
|
||||
},
|
||||
'create_router': {
|
||||
'variables': [
|
||||
'router_name',
|
||||
'external_gateway_info',
|
||||
'tenant_id'
|
||||
]
|
||||
},
|
||||
'add_router_interface': {
|
||||
'variables': [
|
||||
'router_name',
|
||||
'subnet_name'
|
||||
]
|
||||
},
|
||||
'get_networks': {
|
||||
'variables': [
|
||||
'net_name'
|
||||
]
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
class ManageNeutron(object):
|
||||
def __init__(self, module):
|
||||
self.state_change = False
|
||||
self.neutron = None
|
||||
self.keystone = None
|
||||
self.module = module
|
||||
|
||||
def command_router(self):
|
||||
"""Run the command as its provided to the module."""
|
||||
command_name = self.module.params['command']
|
||||
if command_name not in COMMAND_MAP:
|
||||
self.failure(
|
||||
error='No Command Found',
|
||||
rc=2,
|
||||
msg='Command [ %s ] was not found.' % command_name
|
||||
)
|
||||
|
||||
action_command = COMMAND_MAP[command_name]
|
||||
if hasattr(self, '_%s' % command_name):
|
||||
action = getattr(self, '_%s' % command_name)
|
||||
try:
|
||||
self._keystone_authenticate()
|
||||
self._init_neutron()
|
||||
except Exception as e:
|
||||
self.module.fail_json(
|
||||
err="Initialisation Error: %s" % e,
|
||||
rc=2, msg=str(e))
|
||||
facts = action(variables=action_command['variables'])
|
||||
if facts is None:
|
||||
self.module.exit_json(changed=self.state_change)
|
||||
else:
|
||||
self.module.exit_json(
|
||||
changed=self.state_change,
|
||||
ansible_facts=facts
|
||||
)
|
||||
else:
|
||||
self.failure(
|
||||
error='Command not in ManageNeutron class',
|
||||
rc=2,
|
||||
msg='Method [ %s ] was not found.' % command_name
|
||||
)
|
||||
|
||||
@staticmethod
|
||||
def _facts(resource_type, resource_data):
|
||||
"""Return a dict for our Ansible facts."""
|
||||
key = 'neutron_%s' % resource_type
|
||||
facts = {key: {}}
|
||||
for f in resource_data[resource_type]:
|
||||
res_name = f['name']
|
||||
del f['name']
|
||||
facts[key][res_name] = f
|
||||
|
||||
return facts
|
||||
|
||||
def _get_vars(self, variables, required=None):
|
||||
"""Return a dict of all variables as found within the module.
|
||||
|
||||
:param variables: ``list`` List of all variables that are available to
|
||||
use within the Neutron Command.
|
||||
:param required: ``list`` Name of variables that are required.
|
||||
"""
|
||||
return_dict = {}
|
||||
for variable in variables:
|
||||
return_dict[variable] = self.module.params.get(variable)
|
||||
else:
|
||||
if isinstance(required, list):
|
||||
for var_name in required:
|
||||
check = return_dict.get(var_name)
|
||||
if check is None:
|
||||
self.failure(
|
||||
error='Missing [ %s ] from Task or found a None'
|
||||
' value' % var_name,
|
||||
rc=000,
|
||||
msg='variables %s - available params [ %s ]'
|
||||
% (variables, self.module.params)
|
||||
)
|
||||
return return_dict
|
||||
|
||||
def failure(self, error, rc, msg):
|
||||
"""Return a Failure when running an Ansible command.
|
||||
|
||||
:param error: ``str`` Error that occurred.
|
||||
:param rc: ``int`` Return code while executing an Ansible command.
|
||||
:param msg: ``str`` Message to report.
|
||||
"""
|
||||
self.module.fail_json(msg=msg, rc=rc, err=error)
|
||||
|
||||
def _parse_openrc(self):
|
||||
"""Get credentials from an openrc file."""
|
||||
openrc_path = self.module.params['openrc_path']
|
||||
line_re = re.compile('^export (?P<key>OS_\w*)=(?P<value>[^\n]*)')
|
||||
with open(openrc_path) as openrc:
|
||||
matches = [line_re.match(l) for l in openrc]
|
||||
return dict(
|
||||
(g.groupdict()['key'], g.groupdict()['value'])
|
||||
for g in matches if g
|
||||
)
|
||||
|
||||
def _keystone_authenticate(self):
|
||||
"""Authenticate with Keystone."""
|
||||
openrc = self._parse_openrc()
|
||||
insecure = self.module.params['insecure']
|
||||
self.keystone = ksclient.Client(insecure=insecure,
|
||||
username=openrc['OS_USERNAME'],
|
||||
password=openrc['OS_PASSWORD'],
|
||||
project_name=openrc['OS_PROJECT_NAME'],
|
||||
auth_url=openrc['OS_AUTH_URL'])
|
||||
|
||||
def _init_neutron(self):
|
||||
"""Create neutron client object using token and url from keystone."""
|
||||
openrc = self._parse_openrc()
|
||||
self.neutron = nclient.Client(
|
||||
'2.0',
|
||||
endpoint_url=self.keystone.service_catalog.url_for(
|
||||
service_type='network',
|
||||
endpoint_type=openrc['OS_ENDPOINT_TYPE']),
|
||||
token=self.keystone.get_token(self.keystone.session))
|
||||
|
||||
def _get_resource_by_name(self, resource_type, resource_name):
|
||||
action = getattr(self.neutron, 'list_%s' % resource_type)
|
||||
resource = action(name=resource_name)[resource_type]
|
||||
|
||||
if resource:
|
||||
return resource[0]['id']
|
||||
else:
|
||||
return None
|
||||
|
||||
def _create_network(self, variables):
|
||||
required_vars = ['net_name']
|
||||
variables_dict = self._get_vars(variables, required=required_vars)
|
||||
net_name = variables_dict.pop('net_name')
|
||||
provider_physical_network = variables_dict.pop(
|
||||
'provider_physical_network'
|
||||
)
|
||||
provider_network_type = variables_dict.pop('provider_network_type')
|
||||
provider_segmentation_id = variables_dict.pop(
|
||||
'provider_segmentation_id'
|
||||
)
|
||||
router_external = variables_dict.pop('router_external')
|
||||
tenant_id = variables_dict.pop('tenant_id')
|
||||
|
||||
if not self._get_resource_by_name('networks', net_name):
|
||||
n = {"name": net_name, "admin_state_up": True}
|
||||
if provider_physical_network:
|
||||
n['provider:physical_network'] = provider_physical_network
|
||||
if provider_network_type:
|
||||
n['provider:network_type'] = provider_network_type
|
||||
if provider_segmentation_id:
|
||||
n['provider:segmentation_id'] = str(provider_segmentation_id)
|
||||
if router_external:
|
||||
n['router:external'] = router_external
|
||||
if tenant_id:
|
||||
n['tenant_id'] = tenant_id
|
||||
|
||||
self.state_change = True
|
||||
self.neutron.create_network({"network": n})
|
||||
|
||||
return self._facts('networks', self.neutron.list_networks())
|
||||
|
||||
def _create_subnet(self, variables):
|
||||
required_vars = ['net_name', 'subnet_name', 'cidr']
|
||||
variables_dict = self._get_vars(variables, required=required_vars)
|
||||
net_name = variables_dict.pop('net_name')
|
||||
subnet_name = variables_dict.pop('subnet_name')
|
||||
cidr = variables_dict.pop('cidr')
|
||||
network_id = self._get_resource_by_name('networks', net_name)
|
||||
tenant_id = variables_dict.pop('tenant_id')
|
||||
|
||||
# allocation_pools is a string with the format:
|
||||
# startip-endip[,startip-endip]...
|
||||
allocation_pools_str = variables_dict.get('allocation_pools', "")
|
||||
allocation_pools = []
|
||||
if allocation_pools_str:
|
||||
for ap in allocation_pools_str.split(','):
|
||||
if "-" not in ap:
|
||||
continue
|
||||
start, end = ap.split('-')
|
||||
allocation_pools.append({'start': start, 'end': end})
|
||||
|
||||
if not network_id:
|
||||
self.failure(
|
||||
error='Network not found',
|
||||
rc=1,
|
||||
msg='The specified network could not be found'
|
||||
)
|
||||
if not self.neutron.list_subnets(cidr=cidr,
|
||||
network_id=network_id)['subnets']:
|
||||
self.state_change = True
|
||||
s = {"name": subnet_name, "cidr": cidr, "ip_version": 4,
|
||||
"network_id": network_id}
|
||||
if tenant_id:
|
||||
s["tenant_id"] = tenant_id
|
||||
if allocation_pools:
|
||||
s["allocation_pools"] = allocation_pools
|
||||
|
||||
self.neutron.create_subnet({"subnet": s})
|
||||
return self._facts('subnets', self.neutron.list_subnets())
|
||||
|
||||
def _create_router(self, variables):
|
||||
required_vars = ['router_name', 'external_gateway_info']
|
||||
variables_dict = self._get_vars(variables, required=required_vars)
|
||||
router_name = variables_dict.pop('router_name')
|
||||
external_gateway_info = variables_dict.pop('external_gateway_info')
|
||||
tenant_id = variables_dict.pop('tenant_id')
|
||||
|
||||
if not self._get_resource_by_name('routers', router_name):
|
||||
self.state_change = True
|
||||
r = {'name': router_name}
|
||||
if external_gateway_info:
|
||||
network_id = self._get_resource_by_name('networks',
|
||||
external_gateway_info)
|
||||
r['external_gateway_info'] = {'network_id': network_id}
|
||||
if tenant_id:
|
||||
r['tenant_id'] = tenant_id
|
||||
self.neutron.create_router({'router': r})
|
||||
|
||||
return self._facts('routers', self.neutron.list_routers())
|
||||
|
||||
def _add_router_interface(self, variables):
|
||||
required_vars = ['router_name', 'subnet_name']
|
||||
variables_dict = self._get_vars(variables, required=required_vars)
|
||||
router_name = variables_dict.pop('router_name')
|
||||
subnet_name = variables_dict.pop('subnet_name')
|
||||
router_id = self._get_resource_by_name('routers', router_name)
|
||||
subnet_id = self._get_resource_by_name('subnets', subnet_name)
|
||||
|
||||
if not router_id:
|
||||
self.failure(
|
||||
error='Router not found',
|
||||
rc=1,
|
||||
msg='The specified router could not be found'
|
||||
)
|
||||
|
||||
if not subnet_id:
|
||||
self.failure(
|
||||
error='Subnet not found',
|
||||
rc=1,
|
||||
msg='The specified subnet could not be found'
|
||||
)
|
||||
|
||||
found = False
|
||||
|
||||
for port in self.neutron.list_ports(device_id=router_id)['ports']:
|
||||
for fixed_ips in port['fixed_ips']:
|
||||
if fixed_ips['subnet_id'] == subnet_id:
|
||||
found = True
|
||||
if not found:
|
||||
self.state_change = True
|
||||
self.neutron.add_interface_router(router_id,
|
||||
{'subnet_id': subnet_id})
|
||||
|
||||
def _get_networks(self, variables):
|
||||
variables_dict = self._get_vars(variables)
|
||||
net_name = variables_dict.pop('net_name')
|
||||
if net_name:
|
||||
network_id = self._get_resource_by_name('networks', net_name)
|
||||
if not network_id:
|
||||
self.failure(
|
||||
error='Network not found',
|
||||
rc=1,
|
||||
msg='The specified network could not be found'
|
||||
)
|
||||
|
||||
return self._facts('networks', self.neutron.list_networks())
|
||||
|
||||
|
||||
def main():
|
||||
module = AnsibleModule(
|
||||
argument_spec=dict(
|
||||
command=dict(required=True, choices=COMMAND_MAP.keys()),
|
||||
openrc_path=dict(required=True),
|
||||
net_name=dict(required=False),
|
||||
subnet_name=dict(required=False),
|
||||
cidr=dict(required=False),
|
||||
provider_physical_network=dict(required=False),
|
||||
provider_network_type=dict(required=False),
|
||||
provider_segmentation_id=dict(required=False),
|
||||
router_external=dict(required=False),
|
||||
router_name=dict(required=False),
|
||||
external_gateway_info=dict(required=False),
|
||||
tenant_id=dict(required=False),
|
||||
insecure=dict(default=False, required=False, type='bool'),
|
||||
allocation_pools=dict(required=False)
|
||||
),
|
||||
supports_check_mode=False
|
||||
)
|
||||
mn = ManageNeutron(module)
|
||||
mn.command_router()
|
||||
|
||||
if __name__ == '__main__':
|
||||
main()
|
||||
|
|
@ -1,5 +0,0 @@
|
|||
---
|
||||
upgrade:
|
||||
- The ``neutron`` library has been removed from OpenStack-Ansible's
|
||||
plugins. Upstream Ansible modules for managing OpenStack network
|
||||
resources should be used instead.
|
||||
Loading…
Reference in New Issue