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 from snaps.openstack.create_network import PortSettings
  19 from snaps.openstack.utils import neutron_utils, keystone_utils
  20
  21 __author__ = 'spisarski'
  22
  23 logger = logging.getLogger('OpenStackNetwork')
  24
  25
  26 class OpenStackRouter:
  27     """
  28     Class responsible for creating a router in OpenStack
  29     """
  30
  31     def __init__(self, os_creds, router_settings):
  32         """
  33         Constructor - all parameters are required
  34         :param os_creds: The credentials to connect with OpenStack
  35         :param router_settings: The settings used to create a router object
  36                                 (must be an instance of the RouterSettings
  37                                 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
  53         # interfaces are the value
  54         self.__ports = list()
  55
  56     def create(self, cleanup=False):
  57         """
  58         Responsible for creating the router.
  59         :param cleanup: When true, only perform lookups for OpenStack objects.
  60         :return: the router object
  61         """
  62         self.__neutron = neutron_utils.neutron_client(self.__os_creds)
  63
  64         logger.debug(
  65             'Creating Router with name - ' + self.router_settings.name)
  66         existing = False
  67         router_inst = neutron_utils.get_router_by_name(
  68             self.__neutron, self.router_settings.name)
  69         if router_inst:
  70             self.__router = router_inst
  71             existing = True
  72         else:
  73             if not cleanup:
  74                 self.__router = neutron_utils.create_router(
  75                     self.__neutron, self.__os_creds, self.router_settings)
  76
  77         for internal_subnet_name in self.router_settings.internal_subnets:
  78             internal_subnet = neutron_utils.get_subnet_by_name(
  79                 self.__neutron, internal_subnet_name)
  80             if internal_subnet:
  81                 self.__internal_subnets.append(internal_subnet)
  82                 if internal_subnet and not cleanup and not existing:
  83                     logger.debug('Adding router to subnet...')
  84                     self.__internal_router_interface = neutron_utils.add_interface_router(
  85                         self.__neutron, self.__router, subnet=internal_subnet)
  86             else:
  87                 raise Exception(
  88                     'Subnet not found with name ' + internal_subnet_name)
  89
  90         for port_setting in self.router_settings.port_settings:
  91             port = neutron_utils.get_port_by_name(self.__neutron,
  92                                                   port_setting.name)
  93             logger.info(
  94                 'Retrieved port %s for router - %s', port_setting.name,
  95                 self.router_settings.name)
  96             if port:
  97                 self.__ports.append(port)
  98
  99             if not port and not cleanup and not existing:
 100                 port = neutron_utils.create_port(self.__neutron,
 101                                                  self.__os_creds, port_setting)
 102                 if port:
 103                     logger.info(
 104                         'Created port %s for router - %s', port_setting.name,
 105                         self.router_settings.name)
 106                     self.__ports.append(port)
 107                     neutron_utils.add_interface_router(self.__neutron,
 108                                                        self.__router,
 109                                                        port=port)
 110                 else:
 111                     raise Exception(
 112                         'Error creating port with name - ' + port_setting.name)
 113
 114         return self.__router
 115
 116     def clean(self):
 117         """
 118         Removes and deletes all items created in reverse order.
 119         """
 120         for port in self.__ports:
 121             logger.info(
 122                 'Removing router interface from router %s and port %s',
 123                 self.router_settings.name, port.name)
 124             try:
 125                 neutron_utils.remove_interface_router(self.__neutron,
 126                                                       self.__router, port=port)
 127             except NotFound:
 128                 pass
 129         self.__ports = list()
 130
 131         for internal_subnet in self.__internal_subnets:
 132             logger.info(
 133                 'Removing router interface from router %s and subnet %s',
 134                 self.router_settings.name, internal_subnet.name)
 135             try:
 136                 neutron_utils.remove_interface_router(self.__neutron,
 137                                                       self.__router,
 138                                                       subnet=internal_subnet)
 139             except NotFound:
 140                 pass
 141         self.__internal_subnets = list()
 142
 143         if self.__router:
 144             logger.info('Removing router ' + self.router_settings.name)
 145             try:
 146                 neutron_utils.delete_router(self.__neutron, self.__router)
 147             except NotFound:
 148                 pass
 149             self.__router = None
 150
 151     def get_router(self):
 152         """
 153         Returns the OpenStack router object
 154         :return:
 155         """
 156         return self.__router
 157
 158     def get_internal_router_interface(self):
 159         """
 160         Returns the OpenStack internal router interface object
 161         :return:
 162         """
 163         return self.__internal_router_interface
 164
 165
 166 class RouterSettings:
 167     """
 168     Class representing a router configuration
 169     """
 170
 171     def __init__(self, **kwargs):
 172         """
 173         Constructor - all parameters are optional
 174         :param name: The router name.
 175         :param project_name: The name of the project who owns the network. Only
 176                              administrative users can specify a project ID
 177                              other than their own. You cannot change this value
 178                              through authorization policies.
 179         :param external_gateway: Name of the external network to which to route
 180         :param admin_state_up: The administrative status of the router.
 181                                True = up / False = down (default True)
 182         :param external_fixed_ips: Dictionary containing the IP address
 183                                    parameters.
 184         :param internal_subnets: List of subnet names to which to connect this
 185                                  router for Floating IP purposes
 186         :param port_settings: List of PortSettings objects
 187         :return:
 188         """
 189         self.name = kwargs.get('name')
 190         self.project_name = kwargs.get('project_name')
 191         self.external_gateway = kwargs.get('external_gateway')
 192
 193         self.admin_state_up = kwargs.get('admin_state_up')
 194         self.enable_snat = kwargs.get('enable_snat')
 195         self.external_fixed_ips = kwargs.get('external_fixed_ips')
 196         if kwargs.get('internal_subnets'):
 197             self.internal_subnets = kwargs['internal_subnets']
 198         else:
 199             self.internal_subnets = list()
 200
 201         self.port_settings = list()
 202         if kwargs.get('interfaces', kwargs.get('port_settings')):
 203             interfaces = kwargs.get('interfaces', kwargs.get('port_settings'))
 204             for interface in interfaces:
 205                 if isinstance(interface, PortSettings):
 206                     self.port_settings.append(interface)
 207                 else:
 208                     self.port_settings.append(
 209                         PortSettings(**interface['port']))
 210
 211         if not self.name:
 212             raise Exception('Name is required')
 213
 214     def dict_for_neutron(self, neutron, os_creds):
 215         """
 216         Returns a dictionary object representing this object.
 217         This is meant to be converted into JSON designed for use by the Neutron
 218         API
 219
 220         TODO - expand automated testing to exercise all parameters
 221         :param neutron: The neutron client to retrieve external network
 222                         information if necessary
 223         :param os_creds: The OpenStack credentials
 224         :return: the dictionary object
 225         """
 226         out = dict()
 227         ext_gw = dict()
 228
 229         project_id = None
 230
 231         if self.name:
 232             out['name'] = self.name
 233         if self.project_name:
 234             keystone = keystone_utils.keystone_client(os_creds)
 235             project = keystone_utils.get_project(keystone, self.project_name)
 236             project_id = None
 237             if project:
 238                 project_id = project.id
 239             if project_id:
 240                 out['project_id'] = project_id
 241             else:
 242                 raise Exception(
 243                     'Could not find project ID for project named - ' +
 244                     self.project_name)
 245         if self.admin_state_up is not None:
 246             out['admin_state_up'] = self.admin_state_up
 247         if self.external_gateway:
 248             ext_net = neutron_utils.get_network(neutron, self.external_gateway,
 249                                                 project_id)
 250             if ext_net:
 251                 ext_gw['network_id'] = ext_net.id
 252                 out['external_gateway_info'] = ext_gw
 253             else:
 254                 raise Exception(
 255                     'Could not find the external network named - ' +
 256                     self.external_gateway)
 257
 258         # TODO: Enable SNAT option for Router
 259         # TODO: Add external_fixed_ips Tests
 260
 261         return {'router': out}