cmdatahandlers/src/cmdatahandlers/network_profiles/config.py

   1 # Copyright 2019 Nokia
   2
   3 # Licensed under the Apache License, Version 2.0 (the "License");
   4 # you may not use this file except in compliance with the License.
   5 # You may obtain a copy of the License at
   6 #
   7 #     http://www.apache.org/licenses/LICENSE-2.0
   8 #
   9 # Unless required by applicable law or agreed to in writing, software
  10 # distributed under the License is distributed on an "AS IS" BASIS,
  11 # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  12 # See the License for the specific language governing permissions and
  13 # limitations under the License.
  14
  15 from cmdatahandlers.api import configerror
  16 from cmdatahandlers.api import config
  17 from cmdatahandlers.api import utils
  18
  19 class Config(config.Config):
  20     def __init__(self, confman):
  21         super(Config, self).__init__(confman)
  22         self.ROOT = 'cloud.network_profiles'
  23         self.DOMAIN = 'network_profiles'
  24
  25     def init(self):
  26         pass
  27
  28     def validate(self):
  29         self.validate_root()
  30         self._validate_network_profiles()
  31
  32     def _validate_network_profiles(self):
  33         profiles = self.get_network_profiles()
  34         utils.validate_list_items_unique(profiles)
  35         for profile in profiles:
  36             self._validate_network_profile(profile)
  37
  38     def _validate_network_profile(self, profile):
  39         bondinginterfaces = None
  40         try:
  41             bondinginterfaces = self.get_profile_bonding_interfaces(profile)
  42         except configerror.ConfigError:
  43             pass
  44
  45         if bondinginterfaces:
  46             utils.validate_list_items_unique(bondinginterfaces)
  47
  48             for bond in bondinginterfaces:
  49                 bondedinterfaces = self.get_profile_bonded_interfaces(profile, bond)
  50                 utils.validate_list_items_unique(bondedinterfaces)
  51                 if len(bondedinterfaces) < 2:
  52                     raise configerror.ConfigError('Number of bonded interfaces should be at least 2 in %s' % bond)
  53
  54         mappedinterfaces = self.get_profile_network_mapped_interfaces(profile)
  55
  56         utils.validate_list_items_unique(mappedinterfaces)
  57
  58         netconf = self.confman.get_networking_config_handler()
  59         validnetworks = netconf.get_networks()
  60         for interface in mappedinterfaces:
  61             networks = self.get_profile_interface_mapped_networks(profile, interface)
  62             utils.validate_list_items_unique(networks)
  63             for network in networks:
  64                 if network not in validnetworks:
  65                     raise configerror.ConfigError('Network %s is not valid' % network)
  66
  67     def is_valid_profile(self, profile):
  68         """
  69         Check if given profile exists
  70
  71         Arguments:
  72             The profile name
  73
  74         Returns:
  75             True if given profile exists
  76
  77         Raises:
  78             ConfigError in-case of an error
  79         """
  80         self.validate_root()
  81         profiles = self.get_network_profiles()
  82         if profile not in profiles:
  83             raise configerror.ConfigError('Invalid profile name %s' % profile)
  84
  85     def get_network_profiles(self):
  86         """
  87         Get the network profiles list
  88
  89         Returns:
  90             A list of network profile(s) names
  91
  92         Raises:
  93             ConfigError in-case of an error
  94         """
  95         self.validate_root()
  96         return self.config[self.ROOT].keys()
  97
  98     def get_profile_linux_bonding_options(self, profile):
  99         """
 100         Get the linux bonding options of a profile
 101
 102         Arguments:
 103             The profile name
 104
 105         Returns:
 106             The linux bonding options
 107
 108         Raises:
 109             ConfigError in-case of an error
 110         """
 111         self.is_valid_profile(profile)
 112
 113         if 'linux_bonding_options' not in self.config[self.ROOT][profile]:
 114             raise configerror.ConfigError('profile %s has no linux bonding options' % profile)
 115
 116         return self.config[self.ROOT][profile]['linux_bonding_options']
 117
 118     def get_profile_bonding_interfaces(self, profile):
 119         """
 120         Get the bonding interfaces in a profile
 121
 122         Arguments:
 123             The profile name
 124
 125         Returns:
 126             A list of bonding interfaces names
 127
 128         Raises:
 129             ConfigError in-case of an error
 130         """
 131         self.is_valid_profile(profile)
 132
 133         if 'bonding_interfaces' not in self.config[self.ROOT][profile]:
 134             raise configerror.ConfigError('Profile %s has no bonding interfaces' % profile)
 135
 136         return self.config[self.ROOT][profile]['bonding_interfaces'].keys()
 137
 138     def get_profile_bonded_interfaces(self, profile, bond):
 139         """
 140         Get the bonded interfaces in bond interface
 141
 142         Arguments:
 143             The name of the profile
 144             The name of the bond interface
 145
 146         Returns:
 147             A list of bonded interfaces names
 148
 149         Raises:
 150             ConfigError in-case of an error
 151         """
 152         self.validate_root()
 153         bondinterfaces = self.get_profile_bonding_interfaces(profile)
 154         if bond not in bondinterfaces:
 155             raise configerror.ConfigError('Invalid bond interface name %s in profile %s' % (bond, profile))
 156
 157         return self.config[self.ROOT][profile]['bonding_interfaces'][bond]
 158
 159     def get_profile_network_mapped_interfaces(self, profile):
 160         """
 161         Get the network mapped interfaces
 162
 163         Arguments:
 164             The profile name
 165
 166         Returns:
 167             A list of network mapped interfaces
 168
 169         Raises:
 170             ConfigError in-case of an error
 171         """
 172         self.is_valid_profile(profile)
 173
 174         if 'interface_net_mapping' not in self.config[self.ROOT][profile]:
 175             raise configerror.ConfigError('Profile %s has now interface to network mapping' % profile)
 176
 177         return self.config[self.ROOT][profile]['interface_net_mapping'].keys()
 178
 179     def get_profile_interface_mapped_networks(self, profile, interface):
 180         """
 181         Get the networks mapped to a specific interface
 182
 183         Arguments:
 184             The profile name
 185             The interface name
 186
 187         Returns:
 188             A list of network names
 189
 190         Raises:
 191             ConfigError in-case of an error
 192         """
 193         self.is_valid_profile(profile)
 194         mappedinterfaces = self.get_profile_network_mapped_interfaces(profile)
 195         if interface not in mappedinterfaces:
 196             raise configerror.ConfigError('Interface %s is not valid for profile %s' % (interface, profile))
 197
 198         return self.config[self.ROOT][profile]['interface_net_mapping'][interface]
 199
 200     def get_profile_provider_network_interfaces(self, profile):
 201         """
 202         Get the list of provider network interfaces
 203
 204         Arguments:
 205             The profile name
 206
 207         Returns:
 208             A sorted list of network interface names
 209
 210         Raises:
 211             ConfigError in-case of an error
 212         """
 213         self.is_valid_profile(profile)
 214         if 'provider_network_interfaces' not in self.config[self.ROOT][profile]:
 215             raise configerror.ConfigError('Profile %s has no provider network interfaces' % profile)
 216
 217         return sorted(self.config[self.ROOT][profile]['provider_network_interfaces'].keys())
 218
 219     def _get_profile_provider_network_interface_dict(self, profile, interface):
 220         self.is_valid_profile(profile)
 221         interfaces = self.get_profile_provider_network_interfaces(profile)
 222         if interface not in interfaces:
 223             raise configerror.ConfigError('Profile %s has no provider interface with name %s' % (profile, interface))
 224
 225         return self.config[self.ROOT][profile]['provider_network_interfaces'][interface]
 226
 227     def get_profile_provider_network_interface_type(self, profile, interface):
 228         """
 229         Get the type of a provider network interface
 230
 231         Arguments:
 232             The profile name
 233             The interface name
 234
 235         Returns:
 236             The type of the network interface
 237
 238         Raises:
 239             ConfigError in-case of an error
 240         """
 241         iface_dict = self._get_profile_provider_network_interface_dict(profile, interface)
 242         if 'type' not in iface_dict:
 243             raise configerror.ConfigError('Provider network interface %s in profile %s does not have a type!' % (interface, profile))
 244
 245         return iface_dict['type']
 246
 247     def get_profile_provider_interface_networks(self, profile, interface):
 248         """
 249         Get provider networks for the interface
 250
 251         Arguments:
 252             The profile name
 253             The interface name
 254
 255         Returns:
 256             A list of provider network names
 257
 258         Raises:
 259             ConfigError in-case of an error
 260         """
 261         iface_dict = self._get_profile_provider_network_interface_dict(profile, interface)
 262         if 'provider_networks' not in iface_dict:
 263             raise configerror.ConfigError('Profile %s has no provider networks for interface %s' % (profile, interface))
 264
 265         return iface_dict['provider_networks']
 266
 267     def get_profile_sriov_provider_networks(self, profile):
 268         """
 269         Get SR-IOV provider networks
 270
 271         Arguments:
 272             The profile name
 273
 274         Returns:
 275             A list of SR-IOV provider network names
 276
 277         Raises:
 278             ConfigError in-case of an error
 279         """
 280         self.is_valid_profile(profile)
 281         if 'sriov_provider_networks' not in self.config[self.ROOT][profile]:
 282             raise configerror.ConfigError('Profile %s has no SR-IOV provider networks' % profile)
 283
 284         return self.config[self.ROOT][profile]['sriov_provider_networks'].keys()
 285
 286     def get_profile_sriov_network_interfaces(self, profile, network):
 287         """
 288         Get SR-IOV provider network interfaces
 289
 290         Arguments:
 291             The profile name
 292             The SR-IOV network name
 293
 294         Returns:
 295             A list of SR-IOV provider network interface names
 296
 297         Raises:
 298             ConfigError in-case of an error
 299         """
 300         if network not in self.get_profile_sriov_provider_networks(profile):
 301             raise configerror.ConfigError('Profile %s has no SR-IOV provider network %s' % (profile, network))
 302
 303         if 'interfaces' not in self.config[self.ROOT][profile]['sriov_provider_networks'][network]:
 304             raise configerror.ConfigError('Profile %s has no SR-IOV provider network interfaces for the network %s' % (profile, network))
 305
 306         return self.config[self.ROOT][profile]['sriov_provider_networks'][network]['interfaces']