Script for integration between Waldur and CSCS LDAP system.

cscs-waldur-ldap-integration.py

# Requires:
# python-waldur-client=^0.3.2
from waldur_client import WaldurClient, WaldurClientException
from collections import defaultdict

waldur_api_url = 'https://waldur.example.com/api/'
waldur_api_token = 'changeme' # Staff token
waldur_service_provider_uuid = 'changeme' # UUID of the service provider

def get_waldur_users():
    '''Get user list from Waldur RestAPI.

    Returns a dict where a key is user's username and value is list of person info.
    Example output:
    {
        {'username1':   [{'email': 'person1@example.com',
                        'firstName': 'Person1',
                        'lastName': 'Example1',
                        'personUsername': 'person1_username'}],
        'username2':    [{'email': 'person2@example.com',
                        'firstName': 'Person2',
                        'lastName': 'Example2',
                        'personUsername': 'person2_username'}],
        '':             [{'email': 'person3@example.com',
                        'firstName': 'Person3',
                        'lastName': 'Example3',
                        'personUsername': 'person3_username'},
                        {'email': 'person4@example.com',
                        'firstName': 'Person4',
                        'lastName': 'Example4',
                        'personUsername': 'person4_username'}]
    }
    '''
    waldur_client = WaldurClient(waldur_api_url, waldur_api_token)
    try:
        start_function = time.time()
        service_provider_info = waldur_client.list_service_providers(
            {"uuid": waldur_service_provider_uuid}
        )[0]
        customer_uuid = service_provider_info["customer_uuid"]
        offering_user_list = waldur_client.list_remote_offering_users(
            {"provider_uuid": customer_uuid}
        )[:20]
        end_function = time.time()
        print(
            "Downloaded users data from Waldur. (Time: {})(Size: {} bytes)".format(
                end_function - start_function, sys.getsizeof(offering_user_list)
            )
        )
        users = defaultdict(
            list
        )  # Key is a person's username in Waldur, value - list of linked users' info
        for offering_user in offering_user_list:
            username = offering_user["username"]
            person_username = offering_user["user_username"]
            user_info = waldur_client.list_users(
                {
                    "username": person_username,
                    "field": ["first_name", "last_name", "email"],
                }
            )[0]
            users[username].append(
                {
                    "email": user_info["email"],
                    "first_name": user_info["first_name"],
                    "last_name": user_info["last_name"],
                    "person_username": person_username,
                }
            )
        return users
    except WaldurClientException as exc:
        logger.error('Error! Waldur RestAPI: {}'.format(exc))
        send_message_to_slack(slack_id, slack_channel, 'Error! Waldur RestAPI: {}'.format(exc))
        sys.exit(1)

def get_waldur_groups():
    '''Get group list from Waldur RestAPI

    Example output:
    {
        'ce6e84bafc79448c9be167631f3edc3f': [
            {'group_name': 'Project1',
            'person_username': 'person1_username',
            'role': 'admin'},
            {'group_name': 'Project1',
            'person_username': 'person2_username',
            'role': 'member'}
        ]
}
    '''
    waldur_client = WaldurClient(waldur_api_url, waldur_api_token)
    try:
        start_function = time.time()
        permission_list = waldur_client.list_service_provider_project_permissions(
            waldur_service_provider_uuid
        )
        end_function = time.time()
        logger.info(
            "Downloaded groups data from Waldur. (Time: {})(Size: {} bytes)".format(
                end_function - start_function, sys.getsizeof(permission_list)
            )
        )
        groups = defaultdict(list)
        for permission in permission_list:
            project_uuid = permission["project_uuid"]
            groups[project_uuid].append(
                {
                    "group_name": permission["project_name"],
                    "person_username": permission["user_username"],
                    "role": permission["role"],
                }
            )
        return groups
    except WaldurClientException as exc:
        logger.error('Error! Waldur RestAPI: {}'.format(exc))
        send_message_to_slack(slack_id, slack_channel, 'Error! Waldur RestAPI: {}'.format(exc))
        sys.exit(1)

def get_waldur_persons():
    '''Get person list from Waldur RestAPI.

    Example output:
    {
        'person1_username': {'email': 'person1@example.com',
                            'first_name': 'Person1',
                            'last_name': 'Lastname1'},
        'person2_username': {'email': 'person2@example.com',
                            'first_name': 'Person2',
                            'last_name': 'Lastname2'},
    }
    '''
    waldur_client = WaldurClient(waldur_api_url, waldur_api_token)
    try:
        start_function = time.time()
        user_list = waldur_client.list_service_provider_users(
            waldur_service_provider_uuid
        )
        end_function = time.time()
        print(
            "Downloaded persons data from Waldur. (Time: {})(Size: {} bytes)".format(
                end_function - start_function, sys.getsizeof(user_list)
            )
        )
        persons = {
            user["username"]: {
                "email": user["email"],
                "first_name": user["first_name"],
                "last_name": user["last_name"],
            }
            for user in user_list
        }
        return persons
    except WaldurClientException as exc:
        logger.error('Error! Waldur RestAPI: {}'.format(exc))
        send_message_to_slack(slack_id, slack_channel, 'Error! Waldur RestAPI: {}'.format(exc))
        sys.exit(1)