snaps/openstack/create_user.py

   1 # Copyright (c) 2016 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 from keystoneclient.exceptions import NotFound
  17 from snaps.openstack.os_credentials import OSCreds
  18
  19 from snaps.openstack.utils import keystone_utils
  20
  21 __author__ = 'spisarski'
  22
  23 logger = logging.getLogger('create_user')
  24
  25
  26 class OpenStackUser:
  27     """
  28     Class responsible for creating a user in OpenStack
  29     """
  30
  31     def __init__(self, os_creds, user_settings):
  32         """
  33         Constructor
  34         :param os_creds: The OpenStack connection credentials
  35         :param user_settings: The user settings
  36         :return:
  37         """
  38         self.__os_creds = os_creds
  39         self.user_settings = user_settings
  40         self.__user = None
  41         self.__keystone = keystone_utils.keystone_client(self.__os_creds)
  42
  43     def create(self, cleanup=False):
  44         """
  45         Creates the user in OpenStack if it does not already exist
  46         :param cleanup: Denotes whether or not this is being called for cleanup or not
  47         :return: The OpenStack user object
  48         """
  49         self.__user = keystone_utils.get_user(self.__keystone, self.user_settings.name)
  50         if self.__user:
  51             logger.info('Found user with name - ' + self.user_settings.name)
  52         elif not cleanup:
  53             self.__user = keystone_utils.create_user(self.__keystone, self.user_settings)
  54         else:
  55             logger.info('Did not create user due to cleanup mode')
  56
  57         return self.__user
  58
  59     def clean(self):
  60         """
  61         Cleanse environment of user
  62         :return: void
  63         """
  64         if self.__user:
  65             try:
  66                 keystone_utils.delete_user(self.__keystone, self.__user)
  67             except NotFound:
  68                 pass
  69             self.__user = None
  70
  71     def get_user(self):
  72         """
  73         Returns the OpenStack user object populated in create()
  74         :return: the Object or None if not created
  75         """
  76         return self.__user
  77
  78     def get_os_creds(self, project_name=None):
  79         """
  80         Returns an OSCreds object based on this user account and a project
  81         :param project_name: the name of the project to leverage in the credentials
  82         :return:
  83         """
  84         return OSCreds(username=self.user_settings.name,
  85                        password=self.user_settings.password,
  86                        auth_url=self.__os_creds.auth_url,
  87                        project_name=project_name,
  88                        identity_api_version=self.__os_creds.identity_api_version,
  89                        user_domain_id=self.__os_creds.user_domain_id,
  90                        project_domain_id=self.__os_creds.project_domain_id,
  91                        proxy_settings=self.__os_creds.proxy_settings)
  92
  93
  94 class UserSettings:
  95     def __init__(self, config=None, name=None, password=None, project_name=None, domain_name='default', email=None,
  96                  enabled=True):
  97
  98         """
  99         Constructor
 100         :param config: dict() object containing the configuration settings using the attribute names below as each
 101                        member's the key and overrides any of the other parameters.
 102         :param name: the user's name (required)
 103         :param password: the user's password (required)
 104         :param project_name: the user's primary project name (optional)
 105         :param domain_name: the user's domain name (default='default'). For v3 APIs
 106         :param email: the user's email address (optional)
 107         :param enabled: denotes whether or not the user is enabled (default True)
 108         """
 109
 110         if config:
 111             self.name = config.get('name')
 112             self.password = config.get('password')
 113             self.project_name = config.get('project_name')
 114             self.email = config.get('email')
 115
 116             if config.get('domain_name'):
 117                 self.domain_name = config['domain_name']
 118             else:
 119                 self.domain_name = domain_name
 120
 121             if config.get('enabled') is not None:
 122                 self.enabled = config['enabled']
 123             else:
 124                 self.enabled = enabled
 125         else:
 126             self.name = name
 127             self.password = password
 128             self.project_name = project_name
 129             self.email = email
 130             self.enabled = enabled
 131             self.domain_name = domain_name
 132
 133         if not self.name or not self.password:
 134             raise Exception('The attributes name and password are required for UserSettings')
 135
 136         if not isinstance(self.enabled, bool):
 137             raise Exception('The attribute enabled must be of type boolean')