Revision 2ea2e173

b/snf-django-lib/snf_django/lib/astakos.py
31 31
# interpreted as representing official policies, either expressed
32 32
# or implied, of GRNET S.A.
33 33

  
34
import logging
35

  
34 36
from astakosclient import AstakosClient
35
from astakosclient.errors import Unauthorized
37
from astakosclient.errors import (Unauthorized, NoUUID, NoUserName,
38
                                  AstakosClientException)
36 39

  
37 40

  
38 41
def user_for_token(client, token, usage=False):
......
74 77
    """uuid<->displayname user 'cache'"""
75 78

  
76 79
    def __init__(self, astakos_url, astakos_token, split=100, logger=None):
80
        if logger is None:
81
            logger = logging.getLogger(__name__)
82
        self.logger = logger
83

  
77 84
        self.astakos = AstakosClient(astakos_url, retry=2,
78 85
                                     use_pool=True, logger=logger)
79 86
        self.astakos_token = astakos_token
......
85 92
    def fetch_names(self, uuid_list):
86 93
        total = len(uuid_list)
87 94
        split = self.split
95
        count = 0
88 96

  
89 97
        for start in range(0, total, split):
90 98
            end = start + split
91 99
            try:
92 100
                names = self.astakos.service_get_usernames(
93 101
                    self.astakos_token, uuid_list[start:end])
102
                count += len(names)
103

  
94 104
                self.users.update(names)
95
            except:
105
            except AstakosClientException:
96 106
                pass
107
            except Exception as err:
108
                self.logger.error("Unexpected error while fetching "
109
                                  "user display names: %s" % repr(err))
110

  
111
        diff = (total - count)
112
        assert(diff >= 0), "fetched more displaynames than requested"
113

  
114
        if diff:
115
            self.logger.debug("Failed to fetch %d displaynames", diff)
97 116

  
98 117
    def get_uuid(self, name):
118
        uuid = name
119

  
99 120
        if not name in self.users:
100 121
            try:
101
                self.users[name] = \
102
                    self.astakos.service_get_uuid(
103
                        self.astakos_token, name)
104
            except:
105
                self.users[name] = name
122
                uuid = self.astakos.service_get_uuid(
123
                    self.astakos_token, name)
124
            except NoUUID:
125
                self.logger.debug("Failed to fetch uuid for %s", name)
126
            except AstakosClientException:
127
                pass
128
            except Exception as err:
129
                self.logger.error("Unexpected error while fetching "
130
                                  "user uuid %s: %s" % (name, repr(err)))
131
            finally:
132
                self.users[name] = uuid
106 133

  
107 134
        return self.users[name]
108 135

  
109 136
    def get_name(self, uuid):
110
        """Do the uuid-to-email resolving"""
137
        name = "-"
111 138

  
112 139
        if not uuid in self.users:
113 140
            try:
114
                self.users[uuid] = \
115
                    self.astakos.service_get_username(
116
                        self.astakos_token, uuid)
117
            except:
118
                self.users[uuid] = "-"
141
                name = self.astakos.service_get_username(
142
                    self.astakos_token, uuid)
143
            except NoUserName:
144
                self.logger.debug("Failed to fetch display name for %s", uuid)
145
            except AstakosClientException:
146
                pass
147
            except Exception as err:
148
                self.logger.error("Unexpected error while fetching "
149
                                  "user displayname %s: %s"
150
                                  % (uuid, repr(err)))
151
            finally:
152
                self.users[uuid] = name
119 153

  
120 154
        return self.users[uuid]

Also available in: Unified diff