Coverage for keystoneclient/v2_0/tenants : 87%

# Copyright 2011 OpenStack LLC. 

# Copyright 2011 Nebula, Inc. 

# All Rights Reserved. 

# 

#    Licensed under the Apache License, Version 2.0 (the "License"); you may 

#    not use this file except in compliance with the License. You may obtain 

#    a copy of the License at 

# 

#         http://www.apache.org/licenses/LICENSE-2.0 

# 

#    Unless required by applicable law or agreed to in writing, software 

#    distributed under the License is distributed on an "AS IS" BASIS, WITHOUT 

#    WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the 

#    License for the specific language governing permissions and limitations 

#    under the License. 

import urllib 

from keystoneclient import base 

class Tenant(base.Resource): 

    """Represents a Keystone tenant 

    Attributes: 

        * id: a uuid that identifies the tenant 

        * name: tenant name 

        * description: tenant description 

        * enabled: boolean to indicate if tenant is enabled 

    """ 

    def __repr__(self): 

        return "<Tenant %s>" % self._info 

    def delete(self): 

        return self.manager.delete(self) 

    def update(self, name=None, description=None, enabled=None): 

        # Preserve the existing settings; keystone legacy resets these? 

        new_name = name if name else self.name 

44        if description is not None: 

            new_description = description 

        else: 

            new_description = self.description 

        new_enabled = enabled if enabled is not None else self.enabled 

        try: 

            retval = self.manager.update(self.id, tenant_name=new_name, 

                                         description=new_description, 

                                         enabled=new_enabled) 

            self = retval 

        except Exception: 

            retval = None 

        return retval 

    def add_user(self, user, role): 

        return self.manager.api.roles.add_user_role(base.getid(user), 

                                                    base.getid(role), 

                                                    self.id) 

    def remove_user(self, user, role): 

        return self.manager.api.roles.remove_user_role(base.getid(user), 

                                                       base.getid(role), 

                                                       self.id) 

    def list_users(self): 

        return self.manager.list_users(self.id) 

class TenantManager(base.ManagerWithFind): 

    """Manager class for manipulating Keystone tenants""" 

    resource_class = Tenant 

    def get(self, tenant_id): 

        return self._get("/tenants/%s" % tenant_id, "tenant") 

    def create(self, tenant_name, description=None, enabled=True): 

        """ 

        Create a new tenant. 

        """ 

        params = {"tenant": {"name": tenant_name, 

                             "description": description, 

                             "enabled": enabled}} 

        return self._create('/tenants', params, "tenant") 

    def list(self, limit=None, marker=None): 

        """ 

        Get a list of tenants. 

        :param integer limit: maximum number to return. (optional) 

        :param string marker: use when specifying a limit and making 

                              multiple calls for querying. (optional) 

        :rtype: list of :class:`Tenant` 

        """ 

        params = {} 

        if limit: 

            params['limit'] = limit 

        if marker: 

            params['marker'] = marker 

        query = "" 

        if params: 

            query = "?" + urllib.urlencode(params) 

        reset = 0 

        if self.api.management_url is None: 

            # special casing to allow tenant lists on the auth_url 

            # for unscoped tokens 

            reset = 1 

            self.api.management_url = self.api.auth_url 

        tenant_list = self._list("/tenants%s" % query, "tenants") 

        if reset: 

            self.api.management_url = None 

        return tenant_list 

    def update(self, tenant_id, tenant_name=None, description=None, 

               enabled=None): 

        """ 

        Update a tenant with a new name and description. 

        """ 

        body = {"tenant": {'id': tenant_id}} 

129        if tenant_name is not None: 

            body['tenant']['name'] = tenant_name 

131        if enabled is not None: 

            body['tenant']['enabled'] = enabled 

134        if description is not None: 

            body['tenant']['description'] = description 

        # Keystone's API uses a POST rather than a PUT here. 

        return self._create("/tenants/%s" % tenant_id, body, "tenant") 

    def delete(self, tenant): 

        """ 

        Delete a tenant. 

        """ 

        return self._delete("/tenants/%s" % (base.getid(tenant))) 

    def list_users(self, tenant): 

        """ List users for a tenant. """ 

        return self.api.users.list(base.getid(tenant)) 

    def add_user(self, tenant, user, role): 

        """ Add a user to a tenant with the given role. """ 

        return self.api.roles.add_user_role(base.getid(user), 

                                            base.getid(role), 

                                            base.getid(tenant)) 

    def remove_user(self, tenant, user, role): 

        """ Remove the specified role from the user on the tenant. """ 

        return self.api.roles.remove_user_role(base.getid(user), 

                                               base.getid(role), 

                                               base.getid(tenant))