Saimon/async modules

cterasdk/asynchronous/core/buckets.py

@@ -0,0 +1,26 @@
+import logging
+
+from ...common import union
+from .base_command import BaseCommand
+from ...core.query import QueryParamBuilder
+from . import query
+
+
+logger = logging.getLogger('cterasdk.core')
+
+
+class Buckets(BaseCommand):
+    """
+    Portal Storage Node APIs
+    """
+    default = ['name']
+
+    def list_buckets(self, include=None):
+        """
+        List Buckets.
+
+        :param list[str],optional include: List of fields to retrieve, defaults to ``['name']``
+        """
+        include = union(include or [], Buckets.default)
+        param = QueryParamBuilder().include(include).build()
+        return query.iterator(self._core, '/locations', param)

cterasdk/asynchronous/core/cloudfs.py

@@ -14,15 +14,53 @@ class CloudFS(BaseCommand):
 
     def __init__(self, core):
         super().__init__(core)
+        self.groups = FolderGroups(self._core)
         self.drives = CloudDrives(self._core)
         self.zones = Zones(self._core)
+        self.exports = Exports(self._core)
+
+
+class FolderGroups(BaseCommand):
+    """ Cloud Drive Folder APIs """
+
+    default = ['name']
+
+    async def all(self, include=None, namespaces=None):
+        """
+        List folder groups
+
+        :param str,optional include: List of fields to retrieve, defaults to ['name']
+        :param list[str],optional namespaces: List of namespaces to query
+        :returns: Iterator for all folder groups
+        """
+        include = union(include or [], FolderGroups.default)
+
+        for resource in [f'/portals/{namespace}' for namespace in namespaces] if namespaces is not None else ['']:
+            param = QueryParamBuilder().include(include).build()
+            async for group in query.iterator(self._core, f'{resource}/foldersGroups', param):
+                yield group
 
 
 class CloudDrives(BaseCommand):
     """ Cloud Drive Folder APIs """
 
     default = ['name']
 
+    async def all(self, include=None, namespaces=None):
+        """
+        List Cloud Drive folders.
+
+        :param str,optional include: List of fields to retrieve, defaults to ['name']
+        :param list[str],optional namespaces: List of namespaces to query
+        :returns: Iterator for all Cloud Drive folders
+        """
+        include = union(include or [], CloudDrives.default)
+
+        for resource in [f'/portals/{namespace}' for namespace in namespaces] if namespaces is not None else ['']:
+            param = QueryParamBuilder().include(include).put('includeDeleted', True).build()
+            async for drive in query.iterator(self._core, f'{resource}/cloudDrives', param):
+                yield drive
+
     async def find(self, name, owner, include=None):
         """
         Find a Cloud Drive Folder
@@ -46,46 +84,48 @@ class Zones(BaseCommand):
     Portal Zones APIs
     """
 
-    async def all(self, filters=None):
+    async def all(self, expand_zone=False, namespaces=None):
         """
         List Zones
-        :param list[],optional filters: List of additional filters, defaults to None
+
+        :param list[str],optional namespaces: List of namespaces to query
 
         :return: Iterator for all Zones
-        :rtype: cterasdk.lib.iterator.QueryIterator
+        :rtype: cterasdk.asynchronous.core.iterator.QueryAsyncIterator
         """
-        builder = QueryParamBuilder().include_classname().startFrom(0).countLimit(25)
-        filters = filters or []
-        for query_filter in filters:
-            builder.addFilter(query_filter)
-        builder.orFilter((len(filters) > 1))
-        param = builder.build()
-        async for zone in query.iterator(self._core, '', param, 'getZonesDisplayInfo'):
-            yield zone
+        for resource in [f'/portals/{namespace}' for namespace in namespaces] if namespaces is not None else ['']:
+            param = QueryParamBuilder().include_classname().build()
+            async for zone in query.iterator(self._core, resource, param, 'getZonesDisplayInfo'):
+                if expand_zone:
+                    info = await self._core.v1.api.execute(resource, 'getZoneBasicInfo', zone.zoneId)
+                    zone.policyType = info.policyType
+                    zone.devices = [device async for device in query.iterator(self._core, resource,
+                                                                              ZoneQueryParams(info.zoneId, DevicesDelta()),
+                                                                              'getZoneDevices')]
+                    if zone.policyType == 'selectedFolders':
+                        zone.cloudfolders = [
+                            volume
+                            async for volume in query.iterator(
+                                self._core,
+                                resource,
+                                ZoneQueryParams(info.zoneId, FoldersDelta()),
+                                'getZoneFolders',
+                            )
+                        ]
+                yield zone
+
+
+class Exports(BaseCommand):
+    """ Fusion Gateway S3 APIs """
 
-    async def list_zones(self, filters=None, expand_zone=False):
+    async def all(self, namespaces=None):
         """
-        List Zones
-        :param list[],optional filters: List of additional filters, defaults to None
-        :param bool,optional expand_zone: Include Cloud Drive folders and devices
+        List Fusion Gateway S3 Exports
 
-        :return: Iterator for all Zones
-        :rtype: cterasdk.lib.iterator.QueryIterator
+        :param str,optional include: List of fields to retrieve, defaults to ['name']
+        :param list[str],optional namespaces: List of namespaces to query
+        :returns: Iterator for all Fusion Gateway exports
         """
-        async for zone in self.all(filters):
-            if expand_zone:
-                info = await self._core.v1.api.execute('', 'getZoneBasicInfo', zone.zoneId)
-                zone.devices = [device async for device in query.iterator(self._core, '',
-                                                                          ZoneQueryParams(info.zoneId, DevicesDelta()), 'getZoneDevices')]
-                if info.policyType == 'selectedFolders':
-                    zone.cloudfolders = [
-                        volume
-                        async for volume in query.iterator(
-                            self._core,
-                            '',
-                            ZoneQueryParams(info.zoneId, FoldersDelta()),
-                            'getZoneFolders',
-                        )
-                    ]
-                yield zone
-            yield zone
+        for resource in [f'/portals/{namespace}' for namespace in namespaces] if namespaces is not None else ['']:
+            for export in await self._core.v1.api.get(f'{resource}/buckets'):
+                yield export

cterasdk/asynchronous/core/plans.py

@@ -0,0 +1,36 @@
+import logging
+from .base_command import BaseCommand
+from ...common import union
+from ...core.query import QueryParamBuilder
+from . import query
+
+
+logger = logging.getLogger('cterasdk.core')
+
+
+class Plans(BaseCommand):
+    """
+    Portal Plan APIs
+
+    :ivar cterasdk.core.plans.PlanAutoAssignPolicy auto_assign: Object holding the Portal subscription plan auto assignment rules APIs
+    """
+    default = ['name']
+
+    def list_plans(self, include=None, filters=None):
+        """
+        List Plans
+
+        :param list[str],optional include: List of fields to retrieve, defaults to ['name']
+        :param list[],optional filters: List of additional filters, defaults to None
+
+        :return: Iterator for all matching Plans
+        :rtype: cterasdk.asynchronous.core.iterator.QueryAsyncIterator
+        """
+        include = union(include or [], Plans.default)
+        builder = QueryParamBuilder().include(include)
+        filters = filters or []
+        for query_filter in filters:
+            builder.addFilter(query_filter)
+        builder.orFilter((len(filters) > 1))
+        param = builder.build()
+        return query.iterator(self._core, '/plans', param)

cterasdk/asynchronous/core/portals.py

@@ -1,5 +1,7 @@
 from .base_command import BaseCommand
 from ...core import decorator
+from ...core.query import QueryParamBuilder
+from . import query
 
 
 class Portals(BaseCommand):
@@ -18,3 +20,12 @@ async def browse_global_admin(self):
         Browse the Global Admin
         """
         await self.browse('')
+
+    def tenants(self, include_deleted=False):
+        """
+        Get all tenants
+
+        :param bool,optional include_deleted: Include deleted tenants, defaults to False
+        """
+        param = QueryParamBuilder().include_classname().put('isTrashcan', include_deleted).build()
+        return query.iterator(self._core, '', param, 'getPortalsDisplayInfo')

cterasdk/asynchronous/core/servers.py

@@ -0,0 +1,43 @@
+import logging
+import asyncio
+
+from ...common import union
+from .base_command import BaseCommand
+from ...core.query import QueryParamBuilder
+from . import query
+
+
+logger = logging.getLogger('cterasdk.core')
+
+
+class Servers(BaseCommand):
+    """
+    Global Admin Servers APIs
+    """
+
+    default = ['name']
+
+    async def system_info(self, server):
+        return await self._core.v1.api.get(f'/servers/{server.name}/systemInfo')
+
+    async def list_servers(self, include=None):
+        """
+        Retrieve the servers that comprise CTERA Portal.
+        Restricted to the Global Administration Portal. Browse it using :py:func:`cterasdk.core.portals.browse_global_admin`.
+
+        :param list[str],optional include: List of fields to retrieve, defaults to ['name']
+        """
+        include = union(include or [], Servers.default)
+        param = QueryParamBuilder().include(include).build()
+
+        servers = [server async for server in query.iterator(self._core, '/servers', param)]
+
+        if 'systemInfo' in include:
+            tasks = [self.system_info(server) for server in servers]
+            systems = await asyncio.gather(*tasks)
+
+            for server, sys_info in zip(servers, systems):
+                server.systemInfo = sys_info
+
+        for server in servers:
+            yield server