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 = None
  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.__keystone = keystone_utils.keystone_client(self.__os_creds)
  50         self.__user = keystone_utils.get_user(self.__keystone, self.user_settings.name)
  51         if self.__user:
  52             logger.info('Found user with name - ' + self.user_settings.name)
  53         elif not cleanup:
  54             self.__user = keystone_utils.create_user(self.__keystone, self.user_settings)
  55         else:
  56             logger.info('Did not create user due to cleanup mode')
  57
  58         return self.__user
  59
  60     def clean(self):
  61         """
  62         Cleanse environment of user
  63         :return: void
  64         """
  65         if self.__user:
  66             try:
  67                 keystone_utils.delete_user(self.__keystone, self.__user)
  68             except NotFound:
  69                 pass
  70             self.__user = None
  71
  72     def get_user(self):
  73         """
  74         Returns the OpenStack user object populated in create()
  75         :return: the Object or None if not created
  76         """
  77         return self.__user
  78
  79     def get_os_creds(self, project_name=None):
  80         """
  81         Returns an OSCreds object based on this user account and a project
  82         :param project_name: the name of the project to leverage in the credentials
  83         :return:
  84         """
  85         return OSCreds(username=self.user_settings.name,
  86                        password=self.user_settings.password,
  87                        auth_url=self.__os_creds.auth_url,
  88                        project_name=project_name,
  89                        identity_api_version=self.__os_creds.identity_api_version,
  90                        user_domain_id=self.__os_creds.user_domain_id,
  91                        project_domain_id=self.__os_creds.project_domain_id,
  92                        proxy_settings=self.__os_creds.proxy_settings)
  93
  94
  95 class UserSettings:
  96     def __init__(self, config=None, name=None, password=None, project_name=None, domain_name='default', email=None,
  97                  enabled=True):
  98
  99         """
 100         Constructor
 101         :param config: dict() object containing the configuration settings using the attribute names below as each
 102                        member's the key and overrides any of the other parameters.
 103         :param name: the user's name (required)
 104         :param password: the user's password (required)
 105         :param project_name: the user's primary project name (optional)
 106         :param domain_name: the user's domain name (default='default'). For v3 APIs
 107         :param email: the user's email address (optional)
 108         :param enabled: denotes whether or not the user is enabled (default True)
 109         """
 110
 111         if config:
 112             self.name = config.get('name')
 113             self.password = config.get('password')
 114             self.project_name = config.get('project_name')
 115             self.email = config.get('email')
 116
 117             if config.get('domain_name'):
 118                 self.domain_name = config['domain_name']
 119             else:
 120                 self.domain_name = domain_name
 121
 122             if config.get('enabled') is not None:
 123                 self.enabled = config['enabled']
 124             else:
 125                 self.enabled = enabled
 126         else:
 127             self.name = name
 128             self.password = password
 129             self.project_name = project_name
 130             self.email = email
 131             self.enabled = enabled
 132             self.domain_name = domain_name
 133
 134         if not self.name or not self.password:
 135             raise Exception('The attributes name and password are required for UserSettings')
 136
 137         if not isinstance(self.enabled, bool):
 138             raise Exception('The attribute enabled must be of type boolean')