snaps/openstack/os_credentials.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 from neutronclient.common.utils import str2bool
  16 import numbers
  17 from snaps import file_utils
  18 from snaps.openstack.utils import glance_utils, keystone_utils, cinder_utils
  19
  20 __author__ = 'spisarski'
  21
  22
  23 class OSCreds:
  24     """
  25     Represents the credentials required to connect with OpenStack servers
  26     """
  27
  28     def __init__(self, **kwargs):
  29         """
  30         Constructor
  31         :param username: The user (required)
  32         :param password: The user's password (required)
  33         :param auth_url: The OpenStack cloud's authorization URL (required)
  34         :param project_name: The project/tenant name
  35         :param identity_api_version: The OpenStack's API version to use for
  36                                      Keystone clients
  37         :param image_api_version: The OpenStack's API version to use for Glance
  38                                   clients
  39         :param network_api_version: The OpenStack's API version to use for
  40                                     Neutron clients
  41         :param compute_api_version: The OpenStack's API version to use for Nova
  42                                     clients
  43         :param heat_api_version: The OpenStack's API version to use for Heat
  44                                     clients
  45         :param volume_api_version: The OpenStack's API version to use
  46                                    for Cinder clients
  47         :param user_domain_id: Used for v3 APIs (default='default')
  48         :param user_domain_name: Used for v3 APIs (default='Default')
  49         :param project_domain_id: Used for v3 APIs (default='default')
  50         :param project_domain_name: Used for v3 APIs (default='Default')
  51         :param interface: Used to specify the endpoint type for keystone as
  52                           public, admin, internal
  53         :param proxy_settings: instance of os_credentials.ProxySettings class
  54         :param cacert: Default to be True for http, or the certification file
  55                        is specified for https verification, or set to be False
  56                        to disable server certificate verification without cert
  57                        file
  58         :param region_name: the region (optional default = None)
  59         """
  60         self.username = kwargs.get('username')
  61         self.password = kwargs.get('password')
  62         self.auth_url = kwargs.get('auth_url')
  63         self.project_name = kwargs.get('project_name')
  64
  65         if kwargs.get('identity_api_version') is None:
  66             self.identity_api_version = keystone_utils.V2_VERSION_NUM
  67         else:
  68             self.identity_api_version = float(kwargs['identity_api_version'])
  69
  70         if kwargs.get('image_api_version') is None:
  71             self.image_api_version = glance_utils.VERSION_2
  72         else:
  73             self.image_api_version = float(kwargs['image_api_version'])
  74
  75         if kwargs.get('network_api_version') is None:
  76             self.network_api_version = 2
  77         else:
  78             self.network_api_version = float(kwargs['network_api_version'])
  79
  80         if kwargs.get('compute_api_version') is None:
  81             self.compute_api_version = 2
  82         else:
  83             self.compute_api_version = float(kwargs['compute_api_version'])
  84
  85         if kwargs.get('heat_api_version') is None:
  86             self.heat_api_version = 1
  87         else:
  88             self.heat_api_version = float(kwargs['heat_api_version'])
  89
  90         if kwargs.get('volume_api_version') is None:
  91             self.volume_api_version = cinder_utils.VERSION_2
  92         else:
  93             self.volume_api_version = float(
  94                 kwargs['volume_api_version'])
  95
  96         self.user_domain_id = kwargs.get('user_domain_id', 'default')
  97
  98         if kwargs.get('user_domain_name') is None:
  99             self.user_domain_name = 'Default'
 100         else:
 101             self.user_domain_name = kwargs['user_domain_name']
 102
 103         self.project_domain_id = kwargs.get('project_domain_id', 'default')
 104
 105         if kwargs.get('project_domain_name') is None:
 106             self.project_domain_name = 'Default'
 107         else:
 108             self.project_domain_name = kwargs['project_domain_name']
 109
 110         if kwargs.get('interface') is None:
 111             self.interface = 'public'
 112         else:
 113             self.interface = kwargs['interface']
 114
 115         self.region_name = kwargs.get('region_name', None)
 116
 117         self.cacert = False
 118         if kwargs.get('cacert') is not None:
 119             if isinstance(kwargs.get('cacert'), str):
 120                 if file_utils.file_exists(kwargs['cacert']):
 121                     self.cacert = kwargs['cacert']
 122                 else:
 123                     self.cacert = str2bool(kwargs['cacert'])
 124             else:
 125                 self.cacert = kwargs['cacert']
 126
 127         if isinstance(kwargs.get('proxy_settings'), ProxySettings):
 128             self.proxy_settings = kwargs.get('proxy_settings')
 129         elif isinstance(kwargs.get('proxy_settings'), dict):
 130             self.proxy_settings = ProxySettings(**kwargs.get('proxy_settings'))
 131         else:
 132             self.proxy_settings = None
 133
 134         if (not self.username or not self.password or not self.auth_url
 135                 or not self.project_name):
 136             raise OSCredsError('username, password, auth_url, and project_name'
 137                                ' are required')
 138
 139         self.auth_url = self.__scrub_auth_url()
 140
 141     def __scrub_auth_url(self):
 142         """
 143         As the Python APIs are have more stringent requirements around how the
 144         auth_url is formed than the CLI, this method will scrub any version
 145         from the end of
 146         :return:
 147         """
 148         auth_url_tokens = self.auth_url.rstrip('/').split('/')
 149         last_token = auth_url_tokens[len(auth_url_tokens) - 1]
 150         token_iters = len(auth_url_tokens)
 151         if last_token.startswith('v'):
 152             token_iters -= 1
 153         if self.identity_api_version == keystone_utils.V2_VERSION_NUM:
 154             last_token = keystone_utils.V2_VERSION_STR
 155         else:
 156             last_token = 'v' + str(int(self.identity_api_version))
 157
 158         new_url = None
 159         for ctr in range(0, token_iters):
 160             if new_url:
 161                 new_url += '/' + auth_url_tokens[ctr]
 162             else:
 163                 new_url = auth_url_tokens[ctr]
 164         new_url += '/' + last_token
 165
 166         return new_url
 167
 168     @property
 169     def __str__(self):
 170         """Converts object to a string"""
 171         return ('OSCreds - username=' + str(self.username) +
 172                 ', password=' + str(self.password) +
 173                 ', auth_url=' + str(self.auth_url) +
 174                 ', project_name=' + str(self.project_name) +
 175                 ', identity_api_version=' + str(self.identity_api_version) +
 176                 ', image_api_version=' + str(self.image_api_version) +
 177                 ', network_api_version=' + str(self.network_api_version) +
 178                 ', compute_api_version=' + str(self.compute_api_version) +
 179                 ', heat_api_version=' + str(self.heat_api_version) +
 180                 ', user_domain_id=' + str(self.user_domain_id) +
 181                 ', user_domain_name=' + str(self.user_domain_name) +
 182                 ', project_domain_id=' + str(self.project_domain_id) +
 183                 ', project_domain_name=' + str(self.project_domain_name) +
 184                 ', interface=' + str(self.interface) +
 185                 ', region_name=' + str(self.region_name) +
 186                 ', proxy_settings=' + str(self.proxy_settings) +
 187                 ', cacert=' + str(self.cacert))
 188
 189
 190 class ProxySettings:
 191     """
 192     Represents the information required for sending traffic (HTTP & SSH)
 193     through a proxy
 194     """
 195
 196     def __init__(self, **kwargs):
 197         """
 198         Constructor
 199         :param host: the HTTP proxy host
 200         :param port: the HTTP proxy port
 201         :param https_host: the HTTPS proxy host (defaults to host)
 202         :param https_port: the HTTPS proxy port (defaults to port)
 203         :param port: the HTTP proxy port
 204         :param ssh_proxy_cmd: the SSH proxy command string (optional)
 205         """
 206         self.host = kwargs.get('host')
 207         self.port = kwargs.get('port')
 208         if self.port and isinstance(self.port, numbers.Number):
 209             self.port = str(self.port)
 210
 211         self.https_host = kwargs.get('https_host', self.host)
 212         self.https_port = kwargs.get('https_port', self.port)
 213         if self.https_port and isinstance(self.https_port, numbers.Number):
 214             self.https_port = str(self.https_port)
 215
 216         self.ssh_proxy_cmd = kwargs.get('ssh_proxy_cmd')
 217
 218         if not self.host or not self.port:
 219             raise ProxySettingsError('host & port are required')
 220
 221     def __str__(self):
 222         """Converts object to a string"""
 223         return 'ProxySettings - host=' + str(self.host) + \
 224                ', port=' + str(self.port) + \
 225                ', ssh_proxy_cmd=' + str(self.ssh_proxy_cmd)
 226
 227
 228 class ProxySettingsError(Exception):
 229     """
 230     Exception to be thrown when an OSCred are invalid
 231     """
 232
 233
 234 class OSCredsError(Exception):
 235     """
 236     Exception to be thrown when an OSCred are invalid
 237     """