Saimon/ut file browser (#292)

Author: saimonation

cterasdk/asynchronous/core/base_command.py

@@ -3,3 +3,6 @@ class BaseCommand:
 
     def __init__(self, core):
         self._core = core
+
+    def session(self):
+        return self._core.session()

cterasdk/asynchronous/core/files/__init__.py

@@ -0,0 +1 @@
+from .browser import CloudDrive  # noqa: E402, F401

cterasdk/asynchronous/core/files/browser.py

@@ -0,0 +1,173 @@
+from ....cio.core import CorePath
+from ....lib import FileSystem
+from ..base_command import BaseCommand
+from . import io
+
+
+class FileBrowser(BaseCommand):
+
+    def __init__(self, core):
+        super().__init__(core)
+        self._scope = f'/{self._core.context}/webdav'
+        self._filesystem = FileSystem.instance()
+
+    async def handle(self, path):
+        """
+        Get File Handle.
+
+        :param str path: Path to a file
+        """
+        handle_function = await io.handle(self.normalize(path))
+        return await handle_function(self._core)
+
+    async def handle_many(self, directory, *objects):
+        """
+        Get a Zip Archive File Handle.
+
+        :param str directory: Path to a folder
+        :param args objects: List of files and folders
+        """
+        handle_many_function = await io.handle_many(self.normalize(directory), *objects)
+        return await handle_many_function(self._core)
+
+    async def listdir(self, path, depth=None, include_deleted=False):
+        """
+        List Directory
+
+        :param str path: Path
+        :param bool,optional include_deleted: Include deleted files, defaults to False
+        """
+        return await io.listdir(self._core, self.normalize(path), depth=depth, include_deleted=include_deleted)
+
+    async def versions(self, path):
+        """
+        List snapshots of a file or directory
+
+        :param str path: Path
+        """
+        return await io.versions(self._core, self.normalize(path))
+
+    async def walk(self, path, include_deleted=False):
+        """
+        Walk Directory Contents
+
+        :param str path: Path to walk
+        :param bool,optional include_deleted: Include deleted files, defaults to False
+        """
+        return io.walk(self._core, self._scope, path, include_deleted=include_deleted)
+
+    async def public_link(self, path, access='RO', expire_in=30):
+        """
+        Create a public link to a file or a folder
+
+        :param str path: The path of the file to create a link to
+        :param str,optional access: Access policy of the link, defaults to 'RO'
+        :param int,optional expire_in: Number of days until the link expires, defaults to 30
+        """
+        return await io.public_link(self._core, self.normalize(path), access, expire_in)
+
+    async def copy(self, *paths, destination=None):
+        """
+        Copy one or more files or folders
+
+        :param list[str] paths: List of paths
+        :param str destination: Destination
+        """
+        if destination is None:
+            raise ValueError('Copy destination was not specified.')
+        return await io.copy(self._core, *[self.normalize(path) for path in paths], destination=self.normalize(destination))
+
+    async def permalink(self, path):
+        """
+        Get Permalink for Path.
+
+        :param str path: Path.
+        """
+        p = self.normalize(path)
+        contents = [e async for e in await io.listdir(self._core,
+                                                      p.parent, 1, False, p.name, 1)]  # pylint: disable=unnecessary-comprehension
+        if contents and contents[0].name == p.name:
+            return contents[0].permalink
+        raise FileNotFoundError('File not found.', path)
+
+    def normalize(self, entries):
+        return CorePath.instance(self._scope, entries)
+
+
+class CloudDrive(FileBrowser):
+
+    async def upload(self, name, size, destination, handle):
+        """
+        Upload from file handle.
+
+        :param str name: File name.
+        :param str size: File size.
+        :param str destination: Path to remote directory.
+        :param object handle: Handle.
+        """
+        upload_function = await io.upload(name, size, self.normalize(destination), handle)
+        return await upload_function(self._core)
+
+    async def upload_file(self, path, destination):
+        """
+        Upload a file.
+
+        :param str path: Local path
+        :param str destination: Remote path
+        """
+        with open(path, 'rb') as handle:
+            metadata = self._filesystem.properties(path)
+            response = await self.upload(metadata['name'], metadata['size'], destination, handle)
+        return response
+
+    async def mkdir(self, path):
+        """
+        Create a new directory
+
+        :param str path: Directory path
+        """
+        return await io.mkdir(self._core, self.normalize(path))
+
+    async def makedirs(self, path):
+        """
+        Create a directory recursively
+
+        :param str path: Directory path
+        """
+        return await io.makedirs(self._core, self.normalize(path))
+
+    async def rename(self, path, name):
+        """
+        Rename a file
+
+        :param str path: Path of the file or directory to rename
+        :param str name: The name to rename to
+        """
+        return await io.rename(self._core, self.normalize(path), name)
+
+    async def delete(self, *paths):
+        """
+        Delete one or more files or folders
+
+        :param str path: Path
+        """
+        return await io.remove(self._core, *[self.normalize(path) for path in paths])
+
+    async def undelete(self, *paths):
+        """
+        Recover one or more files or folders
+
+        :param str path: Path
+        """
+        return await io.recover(self._core, *[self.normalize(path) for path in paths])
+
+    async def move(self, *paths, destination=None):
+        """
+        Move one or more files or folders
+
+        :param list[str] paths: List of paths
+        :param str destination: Destination
+        """
+        if destination is None:
+            raise ValueError('Move destination was not specified.')
+        return await io.move(self._core, *[self.normalize(path) for path in paths], destination=self.normalize(destination))

cterasdk/asynchronous/core/files/io.py

@@ -0,0 +1,156 @@
+import logging
+from ....cio.common import encode_request_parameter
+from ....cio import core as fs
+from ....cio import exceptions
+from .. import query
+from ....lib import FetchResourcesResponse
+
+
+logger = logging.getLogger('cterasdk.core')
+
+
+async def listdir(core, path, depth=None, include_deleted=False, search_criteria=None, limit=None):
+    with fs.fetch_resources(path, depth, include_deleted, search_criteria, limit) as param:
+        if param.depth > 0:
+            return query.iterator(core, '', param, 'fetchResources', callback_response=FetchResourcesResponse)
+        return await core.v1.api.execute('', 'fetchResources', param)
+
+
+async def root(core, path):
+    response = await listdir(core, path, 0)
+    if response.root is None:
+        raise exceptions.RemoteStorageException(path.absolute)
+    return response.root
+
+
+async def versions(core, path):
+    with fs.versions(path):
+        return await core.v1.api.execute('', 'listSnapshots', path.absolute)
+
+
+async def walk(core, scope, path, include_deleted=False):
+    paths = [fs.CorePath.instance(scope, path)]
+    while len(paths) > 0:
+        path = paths.pop(0)
+        entries = await listdir(core, path, include_deleted=include_deleted)
+        async for e in entries:
+            if e.isFolder:
+                paths.append(fs.CorePath.instance(scope, e))
+            yield e
+
+
+async def mkdir(core, path):
+    with fs.makedir(path) as param:
+        response = await core.v1.api.execute('', 'makeCollection', param)
+    fs.accept_response(response, path.reference.as_posix())
+
+
+async def makedirs(core, path):
+    directories = path.parts
+    for i in range(1, len(directories) + 1):
+        path = fs.CorePath.instance(path.scope, '/'.join(directories[:i]))
+        try:
+            await mkdir(core, path)
+        except exceptions.ResourceExistsError:
+            logger.debug('Resource already exists: %s', path.reference.as_posix())
+
+
+async def rename(core, path, name):
+    with fs.rename(path, name) as param:
+        return await core.v1.api.execute('', 'moveResources', param)
+
+
+async def remove(core, *paths):
+    with fs.delete(*paths) as param:
+        return await core.v1.api.execute('', 'deleteResources', param)
+
+
+async def recover(core, *paths):
+    with fs.recover(*paths) as param:
+        return await core.v1.api.execute('', 'restoreResources', param)
+
+
+async def copy(core, *paths, destination=None):
+    with fs.copy(*paths, destination=destination) as param:
+        return await core.v1.api.execute('', 'copyResources', param)
+
+
+async def move(core, *paths, destination=None):
+    with fs.move(*paths, destination=destination) as param:
+        return await core.v1.api.execute('', 'moveResources', param)
+
+
+async def retrieve_remote_dir(core, directory):
+    resource = await root(core, directory)
+    if not resource.isFolder:
+        raise exceptions.RemoteStorageException('The destination path is not a directory', None, path=directory.absolute)
+    return str(resource.cloudFolderInfo.uid)
+
+
+async def handle(path):
+    """
+    Create function to retrieve file handle.
+
+    :param cterasdk.cio.edge.CorePath path: Path to file.
+    :returns: Callable function to retrieve file handle.
+    :rtype: callable
+    """
+    async def wrapper(core):
+        """
+        Get file handle.
+
+        :param cterasdk.objects.synchronous.core.Portal core: Portal object.
+        """
+        with fs.handle(path) as param:
+            return await core.io.download(param)
+    return wrapper
+
+
+async def handle_many(directory, *objects):
+    """
+    Create function to retrieve zip archive
+
+    :param cterasdk.cio.edge.CorePath directory: Path to directory.
+    :param args objects: List of files and folders.
+    :returns: Callable function to retrieve file handle.
+    :rtype: callable
+    """
+    async def wrapper(core):
+        """
+        Upload file from metadata and file handle.
+
+        :param cterasdk.objects.synchronous.core.Portal core: Portal object.
+        :param str name: File name.
+        :param object handle: File handle.
+        """
+        with fs.handle_many(directory, objects) as param:
+            return await core.io.download_zip(await retrieve_remote_dir(core, directory), encode_request_parameter(param))
+    return wrapper
+
+
+async def upload(name, size, destination, fd):
+    """
+    Create upload function
+
+    :param str name: File name.
+    :param cterasdk.cio.core.CorePath destination: Path to directory.
+    :param object fd: File handle.
+    :returns: Callable function to start the upload.
+    :rtype: callable
+    """
+    async def wrapper(core):
+        """
+        Upload file from metadata and file handle.
+
+        :param cterasdk.objects.synchronous.core.Portal core: POrtal object.
+        """
+        target = await retrieve_remote_dir(core, destination)
+        with fs.upload(core, name, destination, size, fd) as param:
+            return await core.io.upload(target, param)
+    return wrapper
+
+
+async def public_link(core, path, access, expire_in):
+    with fs.public_link(path, access, expire_in) as param:
+        response = await core.v1.api.execute('', 'createShare', param)
+    return response.publicLink

cterasdk/asynchronous/core/login.py

@@ -4,6 +4,9 @@
 from ...exceptions import CTERAException
 
 
+logger = logging.getLogger('cterasdk.core')
+
+
 class Login(BaseCommand):
     """
     CTERA Portal Login APIs
@@ -19,14 +22,23 @@ async def login(self, username, password):
         host = self._core.host()
         try:
             await self._core.v1.api.form_data('/login', {'j_username': username, 'j_password': password})
-            logging.getLogger('cterasdk.core').info("User logged in. %s", {'host': host, 'user': username})
+            logger.info("User logged in. %s", {'host': host, 'user': username})
         except CTERAException:
-            logging.getLogger('cterasdk.core').error("Login failed. %s", {'host': host, 'user': username})
+            logger.error("Login failed. %s", {'host': host, 'user': username})
             raise
 
+    async def sso(self, ctera_ticket):
+        """
+        Login using a Portal ticket.
+
+        :param str ticket: SSO Ticket.
+        """
+        logger.info('Logging in using a Portal ticket.')
+        await self._core.v1.ctera.form_data('/sso', {'ctera_ticket': ctera_ticket})
+
     async def logout(self):
         """
         Log out of the portal
         """
         await self._core.v1.api.form_data('/logout', {})
-        logging.getLogger('cterasdk.core').info("User logged out. %s", {'host': self._core.host()})
+        logger.info("User logged out. %s", {'host': self._core.host()})

cterasdk/asynchronous/core/notifications.py

@@ -32,7 +32,6 @@ async def get(self, cloudfolders=None, cursor=None, max_results=None):
         param.max_results = max_results if max_results is not None else 2000
         logging.getLogger('cterasdk.metadata.connector').debug('Listing updates.')
         response = await self._core.v2.api.post('/metadata/list', param)
-        print(response)
         if response is not None:
             return CursorResponse(response)
         logging.getLogger('cterasdk.metadata.connector').error('An error occurred while trying to retrieve notifications.')