214 lines
9.2 KiB
Python
214 lines
9.2 KiB
Python
import logging
|
|
import os
|
|
|
|
from keystoneclient.v2_0 import client as kclient
|
|
from keystoneclient.v3 import client as kv3client
|
|
from keystoneclient.exceptions import AuthorizationFailure as KeystoneAuthorizationFailure
|
|
from keystoneclient.exceptions import Unauthorized as KeystoneUnauthorized
|
|
from keystoneclient.exceptions import NotFound as KeystoneNotFound
|
|
from data.users.federated import FederatedUsers, UserInformation
|
|
from util.itertoolrecipes import take
|
|
|
|
logger = logging.getLogger(__name__)
|
|
|
|
DEFAULT_TIMEOUT = 10 # seconds
|
|
|
|
def get_keystone_users(auth_version, auth_url, admin_username, admin_password, admin_tenant,
|
|
timeout=None, requires_email=True):
|
|
if auth_version == 3:
|
|
return KeystoneV3Users(auth_url, admin_username, admin_password, admin_tenant, timeout,
|
|
requires_email)
|
|
else:
|
|
return KeystoneV2Users(auth_url, admin_username, admin_password, admin_tenant, timeout,
|
|
requires_email)
|
|
|
|
|
|
class KeystoneV2Users(FederatedUsers):
|
|
""" Delegates authentication to OpenStack Keystone V2. """
|
|
def __init__(self, auth_url, admin_username, admin_password, admin_tenant, timeout=None,
|
|
requires_email=True):
|
|
super(KeystoneV2Users, self).__init__('keystone', requires_email)
|
|
self.auth_url = auth_url
|
|
self.admin_username = admin_username
|
|
self.admin_password = admin_password
|
|
self.admin_tenant = admin_tenant
|
|
self.timeout = timeout or DEFAULT_TIMEOUT
|
|
self.debug = os.environ.get('USERS_DEBUG') == '1'
|
|
self.requires_email = requires_email
|
|
|
|
def ping(self):
|
|
try:
|
|
keystone_client = kclient.Client(username=self.admin_username, password=self.admin_password,
|
|
tenant_name=self.admin_tenant, auth_url=self.auth_url,
|
|
timeout=self.timeout, debug=self.debug)
|
|
keystone_client.user_id # Make sure we loaded a valid user.
|
|
except KeystoneUnauthorized as kut:
|
|
logger.exception('Keystone unauthorized admin')
|
|
return (False, 'Keystone admin credentials are invalid: %s' % kut.message)
|
|
except Exception:
|
|
logger.exception('Keystone unauthorized admin')
|
|
return (False, 'Keystone ping check failed: %s' % kut.message)
|
|
|
|
return (True, None)
|
|
|
|
def verify_credentials(self, username_or_email, password):
|
|
try:
|
|
keystone_client = kclient.Client(username=username_or_email, password=password,
|
|
auth_url=self.auth_url, timeout=self.timeout,
|
|
debug=self.debug)
|
|
user_id = keystone_client.user_id
|
|
except KeystoneAuthorizationFailure as kaf:
|
|
logger.exception('Keystone auth failure for user: %s', username_or_email)
|
|
return (None, kaf.message or 'Invalid username or password')
|
|
except KeystoneUnauthorized as kut:
|
|
logger.exception('Keystone unauthorized for user: %s', username_or_email)
|
|
return (None, kut.message or 'Invalid username or password')
|
|
|
|
try:
|
|
admin_client = kclient.Client(username=self.admin_username, password=self.admin_password,
|
|
tenant_name=self.admin_tenant, auth_url=self.auth_url,
|
|
timeout=self.timeout, debug=self.debug)
|
|
user = admin_client.users.get(user_id)
|
|
except KeystoneUnauthorized as kut:
|
|
logger.exception('Keystone unauthorized admin')
|
|
return (None, 'Keystone admin credentials are invalid: %s' % kut.message)
|
|
|
|
if self.requires_email and not hasattr(user, 'email'):
|
|
return (None, 'Missing email field for user %s' % user_id)
|
|
|
|
email = user.email if hasattr(user, 'email') else None
|
|
return (UserInformation(username=username_or_email, email=email, id=user_id), None)
|
|
|
|
def query_users(self, query, limit=20):
|
|
return (None, self.federated_service, 'Unsupported in Keystone V2')
|
|
|
|
def get_user(self, username_or_email):
|
|
return (None, 'Unsupported in Keystone V2')
|
|
|
|
|
|
class KeystoneV3Users(FederatedUsers):
|
|
""" Delegates authentication to OpenStack Keystone V3. """
|
|
def __init__(self, auth_url, admin_username, admin_password, admin_tenant, timeout=None,
|
|
requires_email=True):
|
|
super(KeystoneV3Users, self).__init__('keystone', requires_email)
|
|
self.auth_url = auth_url
|
|
self.admin_username = admin_username
|
|
self.admin_password = admin_password
|
|
self.admin_tenant = admin_tenant
|
|
self.timeout = timeout or DEFAULT_TIMEOUT
|
|
self.debug = os.environ.get('USERS_DEBUG') == '1'
|
|
self.requires_email = requires_email
|
|
|
|
def _get_admin_client(self):
|
|
return kv3client.Client(username=self.admin_username, password=self.admin_password,
|
|
tenant_name=self.admin_tenant, auth_url=self.auth_url,
|
|
timeout=self.timeout, debug=self.debug)
|
|
|
|
def ping(self):
|
|
try:
|
|
self._get_admin_client().user_id # Make sure we loaded a valid user
|
|
except KeystoneUnauthorized as kut:
|
|
logger.exception('Keystone unauthorized admin')
|
|
return (False, 'Keystone admin credentials are invalid: %s' % kut.message)
|
|
except Exception:
|
|
logger.exception('Keystone unauthorized admin')
|
|
return (False, 'Keystone ping check failed: %s' % kut.message)
|
|
|
|
return (True, None)
|
|
|
|
def verify_credentials(self, username_or_email, password):
|
|
try:
|
|
keystone_client = kv3client.Client(username=username_or_email, password=password,
|
|
auth_url=self.auth_url, timeout=self.timeout,
|
|
debug=self.debug)
|
|
user_id = keystone_client.user_id
|
|
user = keystone_client.users.get(user_id)
|
|
|
|
if self.requires_email and not hasattr(user, 'email'):
|
|
return (None, 'Missing email field for user %s' % user_id)
|
|
|
|
return (self._user_info(user), None)
|
|
except KeystoneAuthorizationFailure as kaf:
|
|
logger.exception('Keystone auth failure for user: %s', username_or_email)
|
|
return (None, kaf.message or 'Invalid username or password')
|
|
except KeystoneUnauthorized as kut:
|
|
logger.exception('Keystone unauthorized for user: %s', username_or_email)
|
|
return (None, kut.message or 'Invalid username or password')
|
|
|
|
def get_user(self, username_or_email):
|
|
users_found, _, err_msg = self.query_users(username_or_email)
|
|
if err_msg is not None:
|
|
return (None, err_msg)
|
|
|
|
if len(users_found) != 1:
|
|
return (None, 'Single user not found')
|
|
|
|
user = users_found[0]
|
|
if self.requires_email and not user.email:
|
|
return (None, 'Missing email field for user %s' % user.id)
|
|
|
|
return (user, None)
|
|
|
|
def check_group_lookup_args(self, group_lookup_args):
|
|
if not group_lookup_args.get('group_id'):
|
|
return (False, 'Missing group_id')
|
|
|
|
group_id = group_lookup_args['group_id']
|
|
return self._check_group(group_id)
|
|
|
|
def _check_group(self, group_id):
|
|
try:
|
|
return (bool(self._get_admin_client().groups.get(group_id)), None)
|
|
except KeystoneNotFound:
|
|
return (False, 'Group not found')
|
|
except KeystoneAuthorizationFailure as kaf:
|
|
logger.exception('Keystone auth failure for admin user for group lookup %s', group_id)
|
|
return (False, kaf.message or 'Invalid admin username or password')
|
|
except KeystoneUnauthorized as kut:
|
|
logger.exception('Keystone unauthorized for admin user for group lookup %s', group_id)
|
|
return (False, kut.message or 'Invalid admin username or password')
|
|
|
|
def iterate_group_members(self, group_lookup_args, page_size=None, disable_pagination=False):
|
|
group_id = group_lookup_args['group_id']
|
|
|
|
(status, err) = self._check_group(group_id)
|
|
if not status:
|
|
return (None, err)
|
|
|
|
try:
|
|
user_info_iterator = self._get_admin_client().users.list(group=group_id)
|
|
def iterator():
|
|
for user in user_info_iterator:
|
|
yield (self._user_info(user), None)
|
|
|
|
return (iterator(), None)
|
|
except KeystoneAuthorizationFailure as kaf:
|
|
logger.exception('Keystone auth failure for admin user for group lookup %s', group_id)
|
|
return (False, kaf.message or 'Invalid admin username or password')
|
|
except KeystoneUnauthorized as kut:
|
|
logger.exception('Keystone unauthorized for admin user for group lookup %s', group_id)
|
|
return (False, kut.message or 'Invalid admin username or password')
|
|
|
|
@staticmethod
|
|
def _user_info(user):
|
|
email = user.email if hasattr(user, 'email') else None
|
|
return UserInformation(user.name, email, user.id)
|
|
|
|
def query_users(self, query, limit=20):
|
|
if len(query) < 3:
|
|
return ([], self.federated_service, None)
|
|
|
|
try:
|
|
found_users = list(take(limit, self._get_admin_client().users.list(name=query)))
|
|
logger.debug('For Keystone query %s found users: %s', query, found_users)
|
|
if not found_users:
|
|
return ([], self.federated_service, None)
|
|
|
|
return ([self._user_info(user) for user in found_users], self.federated_service, None)
|
|
except KeystoneAuthorizationFailure as kaf:
|
|
logger.exception('Keystone auth failure for admin user for query %s', query)
|
|
return (None, self.federated_service, kaf.message or 'Invalid admin username or password')
|
|
except KeystoneUnauthorized as kut:
|
|
logger.exception('Keystone unauthorized for admin user for query %s', query)
|
|
return (None, self.federated_service, kut.message or 'Invalid admin username or password')
|
|
|