Saimon/Bearer Authentication (#334)

Author: saimonation

cterasdk/__init__.py

@@ -1,7 +1,7 @@
 # pylint: disable=wrong-import-position
-import cterasdk.settings  # noqa: E402, F401
 import cterasdk.exceptions  # noqa: E402, F401
 
+from .settings import settings  # noqa: E402, F401
 from .common import Object, PolicyRule  # noqa: E402, F401
 from .convert import fromjsonstr, tojsonstr, fromxmlstr, toxmlstr  # noqa: E402, F401
 from .core import query  # noqa: E402, F401

cterasdk/cio/core/commands.py

@@ -797,7 +797,7 @@ def _before_command(self):
         logger.info('Creating Public Link: %s', self.path)
 
     def get_parameter(self):
-        access = {'RO': 'ReadOnly', 'RW': 'ReadWrite', 'PO': 'PreviewOnly'}.get(self.access)
+        access = {k: v for k, v in FileAccessMode.__dict__.items() if not k.startswith('_') and k != 'NA'}.get(self.access, None)
         expire_on = DateTimeUtils.get_expiration_date(self.expire_in).strftime('%Y-%m-%d')
         param = CreateShareParam.instance(path=self.path.absolute_encode, access=access, expire_on=expire_on)
         return param

cterasdk/cio/core/types.py

@@ -314,7 +314,7 @@ class PortalVolume(Object):
     :ivar str name: Cloud Drive Folder Name
     :ivar int group: Folder Group ID
     :ivar bool protected: Passphrase-Protected
-    :ivar cterasdk.core.types.VolumeOwner owner: Volume owner information.
+    :ivar cterasdk.cio.core.types.VolumeOwner owner: Volume owner information.
     """
     def __init__(self, i, name, group, protected, owner):
         super().__init__(id=i, name=name, group=group, protected=protected, owner=owner)

cterasdk/clients/async_requests.py

@@ -5,28 +5,30 @@
 
 from yarl import URL
 from ..exceptions.transport import TLSError
-
+from .settings import from_configuration
 
 logger = logging.getLogger('cterasdk.http')
 
 
 class Session:
     """Asynchronous HTTP Session"""
 
-    def __init__(self, settings, trace):
-        self._settings = settings
-        self._trace = trace
+    def __init__(self, configuration):
+        self._configuration = configuration
+        self._cookie_jar = CachedCookieJar()
         self._session = None
 
     @property
     def session(self):
         if self.closed:
-            self._session = aiohttp.ClientSession(**self._settings, **self._trace)
+            self._session = aiohttp.ClientSession(**from_configuration(self._configuration), trust_env=True)
+            self._cookie_jar.register(self._session)
+        self._cookie_jar.update_cookie_jar()
         return self._session
 
     @property
-    def cookies(self):
-        return CookieJar(self.session.cookie_jar)
+    def cookie_jar(self):
+        return self._cookie_jar
 
     async def request(self, r, *, await_promise=False, on_response=None):
         if await_promise:
@@ -80,22 +82,62 @@ async def wrapper(self, n=-1):
     return wrapper
 
 
-class CookieJar:
+def ensure_session(func):
+    def wrapper(self, *args, **kwargs):
+        if self._session is not None and not self._session.closed:  # pylint: disable=protected-access
+            return func(self, *args, **kwargs)
+        return None
+    return wrapper
 
-    def __init__(self, cookie_jar):
-        self._cookie_jar = cookie_jar
 
-    def update_cookies(self, cookies, response_url=None):
-        self._cookie_jar.update_cookies(cookies, URL(response_url))
+def update_session(func):
+    def wrapper(self, *args, **kwargs):
+        func(self, *args, **kwargs)
+        self.update_cookie_jar()
+    return wrapper
 
-    def get(self, key):
-        for cookie in self._cookie_jar:
-            if cookie.key == key:
-                return cookie.value
-        return None
 
+class CachedCookieJar:
+
+    def __init__(self):
+        self._cache = {}
+        self._session = None
+
+    def register(self, session):
+        self._session = session
+
+    @ensure_session
+    def update_cookie_jar(self):
+        for response_url, cookies in self._cache.items():
+            self._session.cookie_jar.update_cookies(cookies, URL(response_url))
+        self._cache.clear()
+
+    @update_session
+    def update_cookies(self, cookies, response_url=None):
+        logger.debug('Cookie update. Scope: %s', response_url)
+        self._cache[response_url] = cookies
+
+    @ensure_session
+    def filter_cookies(self, response_url):
+        return self._session.cookie_jar.filter_cookies(response_url)
+
+    @ensure_session
+    def get(self, response_url, key):
+        """
+        Get Cookie Value
+
+        :param str response_url: URL
+        :param str key: Cookie Key
+        :returns: Cookie Value
+        :rtype: str
+        """
+        cookies = self._session.cookie_jar.filter_cookies(response_url)
+        cookie = cookies.get(key, None)
+        return cookie.value if cookie else None
+
+    @ensure_session
     def clear(self):
-        self._cookie_jar.clear()
+        return self._session.cookie_jar.clear()
 
 
 class BaseRequest:

cterasdk/clients/base.py

@@ -3,7 +3,7 @@
 import threading
 import aiohttp
 from . import async_requests, errors
-from .settings import ClientSessionSettings, TraceSettings
+from .settings import get_configuration
 from ..common import utils
 
 
@@ -17,22 +17,7 @@
 logger = logging.getLogger('cterasdk.http')
 
 
-class CookieJar:
-
-    def __init__(self, cookies):
-        self._cookies = cookies
-
-    def get(self, key):
-        return self._cookies.get(key)
-
-    def update(self, cookies, response_url):
-        self._cookies.update_cookies(cookies, response_url)
-
-    def clear(self):
-        self._cookies.clear()
-
-
-class PersistentHeaders:
+class Headers:
     """Headers to include in every request"""
 
     def __init__(self):
@@ -48,6 +33,9 @@ def __init__(self):
     def all(self):
         return self._headers
 
+    def get(self, key):
+        return self._headers.get(key, None)
+
     def persist_response_header(self, response, header):
         """
         Persist header from response object.
@@ -68,24 +56,20 @@ def persist_headers(self, headers):
 class BaseClient:
     """Base Client"""
 
-    def __init__(self, builder=None, session=None, settings=None, authenticator=None):
+    def __init__(self, builder=None, session=None, settings=None, authenticator=None, headers=None):
         """
         Initialize a Client
 
         :param builder: Endpoint builder.
         :param ,optional session: Session.
-        :param ,optional settings: Client Session Settings.
+        :param pydantic.BaseModel,optional settings: Client Settings
         :param ,optional authenticator: Authenticator function.
+        :param cterasdk.clients.base.Headers,optional headers: Headers Object
         """
-        self._headers = PersistentHeaders()
         self._authenticator = authenticator
         self._builder = builder
-
-        default_settings = ClientSessionSettings()
-        if settings:
-            default_settings.update(**settings)
-
-        self._session = session if session else async_requests.Session(default_settings, TraceSettings())
+        self._session = session if session else async_requests.Session(get_configuration(settings))
+        self._headers = headers if headers else Headers()
 
     def clone(self, definition, builder=None, authenticator=None):
         """
@@ -100,11 +84,12 @@ def clone(self, definition, builder=None, authenticator=None):
             self._session,
             None,
             authenticator if authenticator is not None else self._authenticator,
+            self._headers
         )
 
     @property
-    def cookies(self):
-        return CookieJar(self._session.cookies)
+    def cookie_jar(self):
+        return self._session.cookie_jar
 
     @property
     def headers(self):

cterasdk/clients/clients.py

@@ -96,20 +96,20 @@ def _webdav_headers(self, destination, overwrite):
 
 class AsyncJSON(AsyncClient):
 
-    def __init__(self, builder=None, session=None, settings=None, authenticator=None):
-        super().__init__(builder, session, settings, authenticator)
-        self.headers.persist_headers({'Content-Type': 'application/json'})
-
     async def get(self, path, **kwargs):
         response = await super().get(path, on_error=JSONHandler(), **kwargs)
         return await response.json()
 
     async def put(self, path, data, **kwargs):
-        response = await super().put(path, data, data_serializer=Serializers.JSON, on_error=JSONHandler(), **kwargs)
+        response = await super().put(path, data, data_serializer=Serializers.JSON, headers={
+            'Content-Type': 'application/json'
+        }, on_error=JSONHandler(), **kwargs)
         return await response.json()
 
     async def post(self, path, data, **kwargs):
-        response = await super().post(path, data, data_serializer=Serializers.JSON, on_error=JSONHandler(), **kwargs)
+        response = await super().post(path, data, data_serializer=Serializers.JSON, headers={
+            'Content-Type': 'application/json'
+        }, on_error=JSONHandler(), **kwargs)
         return await response.json()
 
     async def delete(self, path, **kwargs):
@@ -305,20 +305,20 @@ def _webdav_headers(self, destination, overwrite):
 class XML(Client):
     """XML Serializer and Deserializer"""
 
-    def __init__(self, builder=None, session=None, settings=None, authenticator=None):
-        super().__init__(builder, session, settings, authenticator)
-        self._type = {'Content-Type': 'text/plain'}
-
     def get(self, path, **kwargs):
         response = super().get(path, on_error=XMLHandler(), **kwargs)
         return response.xml()
 
     def put(self, path, data, **kwargs):
-        response = super().put(path, data, data_serializer=Serializers.XML, headers=self._type, on_error=XMLHandler(), **kwargs)
+        response = super().put(path, data, data_serializer=Serializers.XML, headers={
+            'Content-Type': 'text/plain'
+        }, on_error=XMLHandler(), **kwargs)
         return response.xml()
 
     def post(self, path, data, **kwargs):
-        response = super().post(path, data, data_serializer=Serializers.XML, headers=self._type, on_error=XMLHandler(), **kwargs)
+        response = super().post(path, data, data_serializer=Serializers.XML, headers={
+            'Content-Type': 'text/plain'
+        }, on_error=XMLHandler(), **kwargs)
         return response.xml()
 
     def form_data(self, path, data, **kwargs):

cterasdk/clients/decorators.py

@@ -10,12 +10,16 @@
 def authenticated(execute_request):
     @functools.wraps(execute_request)
     def authenticate_then_execute(self, *args, **kwargs):
-        if callable(self._authenticator) and self._authenticator(self._builder(args[0])):  # pylint: disable=protected-access
+        if (
+            self.headers.get("Authorization") is not None
+        ) or (
+            callable(self._authenticator) and self._authenticator(self._builder(args[0]))  # pylint: disable=protected-access
+        ):
             try:
                 return execute_request(self, *args, **kwargs)
             except SessionExpired:
                 logger.error('Session expired.')
-                self.cookies.clear()
+                self.cookie_jar.clear()
                 raise
         logger.error('Not logged in.')
         raise NotLoggedIn()