Backwards compatibility for get_service_endpoints

[kamaki] / kamaki / clients / astakos / __init__.py

diff --git a/kamaki/clients/astakos/__init__.py b/kamaki/clients/astakos/__init__.py
index f3d806a..68c77cd 100644 (file)
--- a/kamaki/clients/astakos/__init__.py
+++ b/kamaki/clients/astakos/__init__.py
@@ -32,34 +32,63 @@
 # or implied, of GRNET S.A.
 
 from logging import getLogger
-from astakosclient import AstakosClient as SynnefoAstakosClientOrig
-from astakosclient import AstakosClientException as SynnefoAstakosClientError
+from astakosclient import AstakosClient as OriginalAstakosClient
+from astakosclient import AstakosClientException, parse_endpoints
 
 from kamaki.clients import Client, ClientError, RequestManager, recvlog
 
 
+class AstakosClient(OriginalAstakosClient):
+    """Wrap Original AstakosClient to ensure compatibility in kamaki clients"""
+
+    def __init__(self, *args, **kwargs):
+        if args:
+            args = list(args)
+            url = args.pop(0)
+            token = args.pop(0) if args else kwargs.pop('token', None)
+            args = tuple([token, url] + args)
+        elif 'base_url' in kwargs:
+            kwargs['auth_url'] = kwargs.get('auth_url', kwargs['base_url'])
+        super(AstakosClient, self).__init__(*args, **kwargs)
+
+    def get_service_endpoints(self, service_type, version=None):
+        services = parse_endpoints(
+            self.get_endpoints(), ep_type=service_type, ep_version_id=version)
+        return services[0]['endpoints'][0] if services else []
+
+
 def _astakos_error(foo):
     def wrap(self, *args, **kwargs):
         try:
             return foo(self, *args, **kwargs)
-        except SynnefoAstakosClientError as sace:
+        except AstakosClientException as sace:
             self._raise_for_status(sace)
     return wrap
 
 
-class SynnefoAstakosClient(SynnefoAstakosClientOrig):
-    """A synnefo astakosclient.AstakosClient wrapper, that logs"""
+class LoggedAstakosClient(AstakosClient):
+    """An AstakosClient wrapper with modified logging
+
+    Logs are adjusted to appear similar to the ones of kamaki clients.
+    No other changes are made to the parent class.
+    """
+
+    LOG_TOKEN = False
+    LOG_DATA = False
 
     def _dump_response(self, request, status, message, data):
         recvlog.info('\n%d %s' % (status, message))
         recvlog.info('data size: %s' % len(data))
-        token = request.headers.get('X-Auth-Token', '')
-        data = data.replace(token, '...') if token else data
-        recvlog.info(data)
+        if not self.LOG_TOKEN:
+            token = request.headers.get('X-Auth-Token', '')
+            if self.LOG_DATA:
+                data = data.replace(token, '...') if token else data
+        if self.LOG_DATA:
+            recvlog.info(data)
         recvlog.info('-             -        -     -   -  - -')
 
     def _call_astakos(self, *args, **kwargs):
-        r = super(SynnefoAstakosClient, self)._call_astakos(*args, **kwargs)
+        r = super(LoggedAstakosClient, self)._call_astakos(*args, **kwargs)
         try:
             log_request = getattr(self, 'log_request', None)
             if log_request:
@@ -69,6 +98,7 @@ class SynnefoAstakosClient(SynnefoAstakosClientOrig):
                     path=log_request['path'],
                     data=log_request.get('body', None),
                     headers=log_request.get('headers', dict()))
+                req.LOG_TOKEN, req.LOG_DATA = self.LOG_TOKEN, self.LOG_DATA
                 req.dump_log()
                 log_response = getattr(self, 'log_response', None)
                 if log_response:
@@ -83,12 +113,12 @@ class SynnefoAstakosClient(SynnefoAstakosClientOrig):
             return r
 
 
-class AstakosClient(Client):
+class CachedAstakosClient(Client):
     """Synnefo Astakos cached client wraper"""
 
     @_astakos_error
     def __init__(self, base_url, token=None):
-        super(AstakosClient, self).__init__(base_url, token)
+        super(CachedAstakosClient, self).__init__(base_url, token)
         self._astakos = dict()
         self._uuids = dict()
         self._cache = dict()
@@ -115,14 +145,16 @@ class AstakosClient(Client):
     @_astakos_error
     def authenticate(self, token=None):
         """Get authentication information and store it in this client
-        As long as the AstakosClient instance is alive, the latest
+        As long as the CachedAstakosClient instance is alive, the latest
         authentication information for this token will be available
 
         :param token: (str) custom token to authenticate
         """
         token = self._resolve_token(token)
-        astakos = SynnefoAstakosClient(
-            token, self.base_url, logger=getLogger('astakosclient'))
+        astakos = LoggedAstakosClient(
+            self.base_url, token, logger=getLogger('astakosclient'))
+        astakos.LOG_TOKEN = getattr(self, 'LOG_TOKEN', False)
+        astakos.LOG_DATA = getattr(self, 'LOG_DATA', False)
         r = astakos.authenticate()
         uuid = r['access']['user']['id']
         self._uuids[token] = uuid
@@ -244,7 +276,7 @@ class AstakosClient(Client):
         self._validate_token(token)
         uuid = self._uuids[token]
         astakos = self._astakos[uuid]
-        if set(uuids).difference(self._uuids2usernames[uuid]):
+        if set(uuids or []).difference(self._uuids2usernames[uuid]):
             self._uuids2usernames[uuid].update(astakos.get_usernames(uuids))
         return self._uuids2usernames[uuid]
 
@@ -254,6 +286,6 @@ class AstakosClient(Client):
         self._validate_token(token)
         uuid = self._uuids[token]
         astakos = self._astakos[uuid]
-        if set(usernames).difference(self._usernames2uuids[uuid]):
+        if set(usernames or []).difference(self._usernames2uuids[uuid]):
             self._usernames2uuids[uuid].update(astakos.get_uuids(usernames))
         return self._usernames2uuids[uuid]