snaps/openstack/create_router.py

   1 # Copyright (c) 2017 Cable Television Laboratories, Inc. ("CableLabs")
   2 #                    and others.  All rights reserved.
   3 #
   4 # Licensed under the Apache License, Version 2.0 (the "License");
   5 # you may not use this file except in compliance with the License.
   6 # You may obtain a copy of the License at:
   7 #
   8 #     http://www.apache.org/licenses/LICENSE-2.0
   9 #
  10 # Unless required by applicable law or agreed to in writing, software
  11 # distributed under the License is distributed on an "AS IS" BASIS,
  12 # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  13 # See the License for the specific language governing permissions and
  14 # limitations under the License.
  15 import logging
  16
  17 from neutronclient.common.exceptions import NotFound
  18
  19 from snaps.openstack.create_network import PortSettings
  20 from snaps.openstack.utils import neutron_utils, keystone_utils
  21
  22 __author__ = 'spisarski'
  23
  24 logger = logging.getLogger('OpenStackNetwork')
  25
  26
  27 class OpenStackRouter:
  28     """
  29     Class responsible for creating a router in OpenStack
  30     """
  31
  32     def __init__(self, os_creds, router_settings):
  33         """
  34         Constructor - all parameters are required
  35         :param os_creds: The credentials to connect with OpenStack
  36         :param router_settings: The settings used to create a router object (must be an instance of the
  37                                 RouterSettings class)
  38         """
  39         self.__os_creds = os_creds
  40
  41         if not router_settings:
  42             raise Exception('router_settings is required')
  43
  44         self.router_settings = router_settings
  45         self.__neutron = None
  46
  47         # Attributes instantiated on create()
  48         self.__router = None
  49         self.__internal_subnets = list()
  50         self.__internal_router_interface = None
  51
  52         # Dict where the port object is the key and any newly created router interfaces are the value
  53         self.__ports = list()
  54
  55     def create(self, cleanup=False):
  56         """
  57         Responsible for creating the router.
  58         :param cleanup: When true, only perform lookups for OpenStack objects.
  59         :return: the router object
  60         """
  61         self.__neutron = neutron_utils.neutron_client(self.__os_creds)
  62
  63         logger.debug('Creating Router with name - ' + self.router_settings.name)
  64         existing = False
  65         router_inst = neutron_utils.get_router_by_name(self.__neutron, self.router_settings.name)
  66         if router_inst:
  67             self.__router = router_inst
  68             existing = True
  69         else:
  70             if not cleanup:
  71                 self.__router = neutron_utils.create_router(self.__neutron, self.__os_creds, self.router_settings)
  72
  73         for internal_subnet_name in self.router_settings.internal_subnets:
  74             internal_subnet = neutron_utils.get_subnet_by_name(self.__neutron, internal_subnet_name)
  75             if internal_subnet:
  76                 self.__internal_subnets.append(internal_subnet)
  77                 if internal_subnet and not cleanup and not existing:
  78                     logger.debug('Adding router to subnet...')
  79                     self.__internal_router_interface = neutron_utils.add_interface_router(
  80                         self.__neutron, self.__router, subnet=internal_subnet)
  81             else:
  82                 raise Exception('Subnet not found with name ' + internal_subnet_name)
  83
  84         for port_setting in self.router_settings.port_settings:
  85             port = neutron_utils.get_port_by_name(self.__neutron, port_setting.name)
  86             logger.info('Retrieved port ' + port_setting.name + ' for router - ' + self.router_settings.name)
  87             if port:
  88                 self.__ports.append(port)
  89
  90             if not port and not cleanup and not existing:
  91                 port = neutron_utils.create_port(self.__neutron, self.__os_creds, port_setting)
  92                 if port:
  93                     logger.info('Created port ' + port_setting.name + ' for router - ' + self.router_settings.name)
  94                     self.__ports.append(port)
  95                     neutron_utils.add_interface_router(self.__neutron, self.__router, port=port)
  96                 else:
  97                     raise Exception('Error creating port with name - ' + port_setting.name)
  98
  99         return self.__router
 100
 101     def clean(self):
 102         """
 103         Removes and deletes all items created in reverse order.
 104         """
 105         for port in self.__ports:
 106             logger.info('Removing router interface from router ' + self.router_settings.name +
 107                         ' and port ' + port['port']['name'])
 108             try:
 109                 neutron_utils.remove_interface_router(self.__neutron, self.__router, port=port)
 110             except NotFound:
 111                 pass
 112         self.__ports = list()
 113
 114         for internal_subnet in self.__internal_subnets:
 115             logger.info('Removing router interface from router ' + self.router_settings.name +
 116                         ' and subnet ' + internal_subnet['subnet']['name'])
 117             try:
 118                 neutron_utils.remove_interface_router(self.__neutron, self.__router, subnet=internal_subnet)
 119             except NotFound:
 120                 pass
 121         self.__internal_subnets = list()
 122
 123         if self.__router:
 124             logger.info('Removing router ' + self.router_settings.name)
 125             try:
 126                 neutron_utils.delete_router(self.__neutron, self.__router)
 127             except NotFound:
 128                 pass
 129             self.__router = None
 130
 131     def get_router(self):
 132         """
 133         Returns the OpenStack router object
 134         :return:
 135         """
 136         return self.__router
 137
 138     def get_internal_router_interface(self):
 139         """
 140         Returns the OpenStack internal router interface object
 141         :return:
 142         """
 143         return self.__internal_router_interface
 144
 145
 146 class RouterSettings:
 147     """
 148     Class representing a router configuration
 149     """
 150
 151     def __init__(self, config=None, name=None, project_name=None, external_gateway=None,
 152                  admin_state_up=True, external_fixed_ips=None, internal_subnets=list(),
 153                  port_settings=list()):
 154         """
 155         Constructor - all parameters are optional
 156         :param config: Should be a dict object containing the configuration settings using the attribute names below
 157                        as each member's the key and overrides any of the other parameters.
 158         :param name: The router name.
 159         :param project_name: The name of the project who owns the network. Only administrative users can specify a
 160                              project ID other than their own. You cannot change this value through authorization
 161                              policies.
 162         :param external_gateway: Name of the external network to which to route
 163         :param admin_state_up: The administrative status of the router. True = up / False = down (default True)
 164         :param external_fixed_ips: Dictionary containing the IP address parameters.
 165         :param internal_subnets: List of subnet names to which to connect this router for Floating IP purposes
 166         :param port_settings: List of PortSettings objects
 167         :return:
 168         """
 169         if config:
 170             self.name = config.get('name')
 171             self.project_name = config.get('project_name')
 172             self.external_gateway = config.get('external_gateway')
 173
 174             self.admin_state_up = config.get('admin_state_up')
 175             self.enable_snat = config.get('enable_snat')
 176             self.external_fixed_ips = config.get('external_fixed_ips')
 177             if config.get('internal_subnets'):
 178                 self.internal_subnets = config['internal_subnets']
 179             else:
 180                 self.internal_subnets = internal_subnets
 181
 182             self.port_settings = list()
 183             if config.get('interfaces'):
 184                 interfaces = config['interfaces']
 185                 for interface in interfaces:
 186                     if interface.get('port'):
 187                         self.port_settings.append(PortSettings(config=interface['port']))
 188         else:
 189             self.name = name
 190             self.project_name = project_name
 191             self.external_gateway = external_gateway
 192             self.admin_state_up = admin_state_up
 193             self.external_fixed_ips = external_fixed_ips
 194             self.internal_subnets = internal_subnets
 195             self.port_settings = port_settings
 196
 197         if not self.name:
 198             raise Exception('Name is required')
 199
 200     def dict_for_neutron(self, neutron, os_creds):
 201         """
 202         Returns a dictionary object representing this object.
 203         This is meant to be converted into JSON designed for use by the Neutron API
 204
 205         TODO - expand automated testing to exercise all parameters
 206         :param neutron: The neutron client to retrieve external network information if necessary
 207         :param os_creds: The OpenStack credentials
 208         :return: the dictionary object
 209         """
 210         out = dict()
 211         ext_gw = dict()
 212
 213         project_id = None
 214
 215         if self.name:
 216             out['name'] = self.name
 217         if self.project_name:
 218             keystone = keystone_utils.keystone_client(os_creds)
 219             project = keystone_utils.get_project(keystone, self.project_name)
 220             project_id = None
 221             if project:
 222                 project_id = project.id
 223             if project_id:
 224                 out['project_id'] = project_id
 225             else:
 226                 raise Exception('Could not find project ID for project named - ' + self.project_name)
 227         if self.admin_state_up is not None:
 228             out['admin_state_up'] = self.admin_state_up
 229         if self.external_gateway:
 230             ext_net = neutron_utils.get_network(neutron, self.external_gateway, project_id)
 231             if ext_net:
 232                 ext_gw['network_id'] = ext_net['network']['id']
 233                 out['external_gateway_info'] = ext_gw
 234             else:
 235                 raise Exception('Could not find the external network named - ' + self.external_gateway)
 236
 237         # TODO: Enable SNAT option for Router
 238         # TODO: Add external_fixed_ips Tests
 239
 240         return {'router': out}