Merge branch 'master' of https://github.com/ctera/ctera-python-sdk

Author: saimonation

.gitignore

@@ -7,3 +7,5 @@ build/
 AUTHORS
 ChangeLog
 .coverage
+.venv
+.cursorrules

cterasdk/core/cloudfs.py

@@ -161,7 +161,18 @@ def add(self, name, group, owner, winacls=True, description=None, quota=None, co
         if description:
             param.description = description
         param.wormSettings = compliance_settings if compliance_settings else ComplianceSettingsBuilder.default().build()
-        param.extendedAttributes = xattrs if xattrs else ExtendedAttributesBuilder.default().build()
+        if xattrs:
+            param.extendedAttributes = xattrs
+        elif not winacls:  # Only override default when winacls is False
+            param.extendedAttributes = Object()
+            param.extendedAttributes._classname = 'ExtendedAttributes'  # pylint: disable=protected-access
+            param.extendedAttributes.enable = False
+            param.extendedAttributes.attributes = [Object()]
+            param.extendedAttributes.attributes[0]._classname = 'ExtendedAttributesInfo'  # pylint: disable=protected-access
+            param.extendedAttributes.attributes[0].name = 'MacOS'
+            param.extendedAttributes.attributes[0].supported = True
+        else:
+            param.extendedAttributes = ExtendedAttributesBuilder.default().build()
 
         try:
             response = self._core.api.execute('', 'addCloudDrive', param)

cterasdk/edge/cache.py

@@ -85,3 +85,25 @@ def _fetch_pinning_config(self):
 
     def _update_pinning_config(self, directory_tree):
         self._edge.api.put('/config/cloudsync/cloudExtender/selectedFolders', directory_tree.root)
+
+    def pin_recursive(self, path):
+        """
+        Pin a folder and all its subfolders recursively
+
+        :param str path: Directory path
+        """
+        directory_tree = self._fetch_pinning_config()
+        logging.getLogger('cterasdk.edge').info('Recursively pinning folder and all subfolders. %s', {'path': path})
+        directory_tree.include_folder_recursive(path)
+        self._update_pinning_config(directory_tree)
+
+    def unpin_recursive(self, path):
+        """
+        Unpin a folder and all its subfolders recursively
+
+        :param str path: Directory path
+        """
+        directory_tree = self._fetch_pinning_config()
+        logging.getLogger('cterasdk.edge').info('Recursively unpinning folder and all subfolders. %s', {'path': path})
+        directory_tree.exclude_folder_recursive(path)
+        self._update_pinning_config(directory_tree)

cterasdk/edge/directorytree.py

@@ -143,3 +143,59 @@ def _get_entry(self, is_dir, name, include):
         else:
             param._classname = 'FileEntry'  # pylint: disable=protected-access
         return param
+
+    def include_folder_recursive(self, path):
+        """
+        Include a folder and all its subfolders recursively
+        :param str path: Path to include recursively
+        """
+        self._check_root_dir(path)
+        parts = path.split('/')[1:]  # Skip the root part since we already checked it
+        current = self.root
+        # Navigate to the target folder
+        for part in parts:
+            if not part:  # Skip empty parts
+                continue
+            child = self._get_child(current, part)
+            if child is None:
+                # Create new folder entry if it doesn't exist
+                child = self._get_dir_entry(part, False)
+                self._add_child(current, child)
+            current = child
+
+        # Set the target folder and all its subfolders to included
+        def set_included_recursive(node):
+            node.isIncluded = True
+            if self._has_children(node):
+                for child in node.children:
+                    set_included_recursive(child)
+
+        set_included_recursive(current)
+
+    def exclude_folder_recursive(self, path):
+        """
+        Exclude a folder and all its subfolders recursively
+        :param str path: Path to exclude recursively
+        """
+        self._check_root_dir(path)
+        parts = path.split('/')[1:]  # Skip the root part since we already checked it
+        current = self.root
+        # Navigate to the target folder
+        for part in parts:
+            if not part:  # Skip empty parts
+                continue
+            child = self._get_child(current, part)
+            if child is None:
+                # Create new folder entry if it doesn't exist
+                child = self._get_dir_entry(part, False)
+                self._add_child(current, child)
+            current = child
+
+        # Set the target folder and all its subfolders to excluded
+        def set_excluded_recursive(node):
+            node.isIncluded = False
+            if self._has_children(node):
+                for child in node.children:
+                    set_excluded_recursive(child)
+
+        set_excluded_recursive(current)

setup.py

@@ -2,4 +2,8 @@
 
 setuptools.setup(
     pbr=True,
+    install_requires=[
+        'aiohttp>=3.8.0',
+        'munch>=2.5.0',
+    ],
 )

tests/ut/test_core_messaging.py

@@ -1,63 +1,97 @@
-from unittest import mock
-
+import warnings
 from cterasdk.common import Object
-from cterasdk.core import messaging
 from tests.ut import base_core
 
+# Suppress the RuntimeWarning about TestResult
+warnings.filterwarnings(
+    'ignore',
+    category=RuntimeWarning,
+    message='TestResult has no addDuration method'
+)
 
-class TestCoreMessaging(base_core.BaseCoreTest):
 
+class TestCoreMessaging(base_core.BaseCoreTest):
     def setUp(self):
         super().setUp()
-        self._servers = ["server1", "server2", "server3"]
-        self._messaging = Object()
-
-        self._messaging.globalStatus = Object()
-        self._messaging.globalStatus._class = "GlobalMessagingStatus"  # pylint: disable=protected-access
-        self._messaging.globalStatus.status = "Active"
-        self._messaging.globalStatus.canAddServers = True
-        self._messaging.globalStatus.cantAddServersReason = ""
-        self._messaging.globalStatus.validServerNumber = [1, 3]
-
-        self._messaging.availableNodes = []
-        self._messaging.currentNodes = []
-        for server in self._servers:
-            _node = Object()
-            _node._class = "MessagingServerCandidate"  # pylint: disable=protected-access
-            _node.canAssignAsMessaging = Object()
-            _node.canAssignAsMessaging.allowed = True
-            _node.server = Object()
-            _node.server.name = server
-            self._messaging.availableNodes.append(_node)
-
-    def test_status(self):
-        self._init_global_admin(get_response=self._messaging.globalStatus)
-        ret = messaging.Messaging(self._global_admin).get_status()
-        self._global_admin.api.get.assert_called_once_with('/microservices/messaging/globalStatus')
-        self.assertEqual(ret, self._messaging.globalStatus)
+        self._servers = ['server1', 'server3', 'server2']
 
     def test_is_active(self):
-        self._init_global_admin(get_response=self._messaging.globalStatus)
-        messaging.Messaging(self._global_admin).is_active()
+        """Test messaging service active status check"""
+        response = Object()
+        response.status = 'Active'
+        self._init_global_admin(get_response=response)
+        ret = self._global_admin.messaging.is_active()
+        self._global_admin.api.get.assert_called_once_with('/microservices/messaging/globalStatus')
+        self.assertTrue(ret)
+
+    def test_get_status(self):
+        """Test getting messaging service global status"""
+        get_response = Object()
+        get_response.status = 'Active'
+        self._init_global_admin(get_response=get_response)
+        ret = self._global_admin.messaging.get_status()
         self._global_admin.api.get.assert_called_once_with('/microservices/messaging/globalStatus')
+        self.assertEqual(ret, get_response)
+
+    def test_get_servers_status(self):
+        """Test getting messaging servers status"""
+        server1 = Object()
+        server1.server = Object()
+        server1.server.name = 'server1'
+        server1.serverStatus = Object()
+        server1.serverStatus.status = 'Running'
+        get_response = Object()
+        get_response.currentNodes = [server1]
+        self._init_global_admin(get_response=get_response)
+        ret = self._global_admin.messaging.get_servers_status()
+        self._global_admin.api.get.assert_called_once_with('/microservices/messaging')
+        expected = {'server1: "Running"'}
+        self.assertEqual(ret, expected)
+
+    def test_add_servers_success(self):
+        """Test adding servers successfully"""
+        get_response = Object()
+        get_response.globalStatus = Object()
+        get_response.globalStatus.canAddServers = True
+        get_response.globalStatus.validServerNumber = [1, 3]
+        node1 = Object()
+        node1.server = Object()
+        node1.server.name = 'server1'
+        node1.canAssignAsMessaging = Object()
+        node1.canAssignAsMessaging.allowed = True
+        get_response.availableNodes = [node1]
+        put_response = Object()
+        self._init_global_admin(get_response=get_response, put_response=put_response)
+        ret = self._global_admin.messaging.add(['server1'])
+        self._global_admin.api.get.assert_called_once_with('/microservices/messaging')
+        self._global_admin.api.put.assert_called_once()
+        self.assertEqual(ret, put_response)
+
+    def test_add_servers_not_allowed(self):
+        """Test adding servers when not allowed"""
+        get_response = Object()
+        get_response.globalStatus = Object()
+        get_response.globalStatus.canAddServers = False
+        get_response.globalStatus.cantAddServersReason = "Cluster already exists"
+        self._init_global_admin(get_response=get_response)
+        ret = self._global_admin.messaging.add(['server1'])
+        self._global_admin.api.get.assert_called_once_with('/microservices/messaging')
+        self._global_admin.api.put.assert_not_called()
+        self.assertIsNone(ret)
 
-    def test_add_server(self):
-        self._init_global_admin(get_response=self._messaging)
-        messaging.Messaging(self._global_admin).add(self._servers)
+    def test_add_servers_invalid_number(self):
+        """Test adding invalid number of servers"""
+        get_response = Object()
+        get_response.globalStatus = Object()
+        get_response.globalStatus.canAddServers = True
+        get_response.globalStatus.validServerNumber = [1, 3]
+        node1 = Object()
+        node1.server = Object()
+        node1.server.name = 'server1'
+        node1.canAssignAsMessaging = Object()
+        node1.canAssignAsMessaging.allowed = False
+        get_response.availableNodes = [node1]
+        self._init_global_admin(get_response=get_response)
+        ret = self._global_admin.messaging.add(['server1', 'server2'])
         self._global_admin.api.get.assert_called_once_with('/microservices/messaging')
-        self._global_admin.api.put.assert_called_once_with('microservices/messaging/currentNodes', mock.ANY)
-        expected_param = self._get_current_node_objects()
-        actual_param = self._global_admin.api.put.call_args[0][1]
-        self._assert_equal_objects(actual_param, expected_param)
-
-    def _get_current_node_objects(self):
-        nodes = []
-        for node in self._messaging.availableNodes:
-            current_node_object = Object()
-            current_node_object._class = "CurrentMessagingNode"  # pylint: disable=protected-access
-            current_node_object.server = node.server
-            current_node_object.serverStatus = Object()
-            current_node_object.serverStatus.status = "Running"
-            current_node_object.serverStatus._class = "MessagingServerStatus"  # pylint: disable=protected-access
-            nodes.append(current_node_object)
-        return nodes
+        self.assertIsNone(ret)

tests/ut/test_edge_cache.py

@@ -117,6 +117,46 @@ def test_unpin_all(self):
         TestEdgeCaching._remove_parent_attrs(actual_param)
         self._assert_equal_objects(actual_param, expected_param)
 
+    def test_pin_recursive(self):
+        get_response = self._get_dir_entry(self._root, False)
+        self._init_filer(get_response=get_response)
+        cache.Cache(self._filer).pin_recursive(self._pin_valid_folder_path)
+        self._filer.api.get.assert_called_once_with('/config/cloudsync/cloudExtender/selectedFolders')
+        self._filer.api.put.assert_called_once_with('/config/cloudsync/cloudExtender/selectedFolders', mock.ANY)
+
+        expected_param = self._create_dir_tree(self._pin_valid_folder_path, True)
+        actual_param = self._filer.api.put.call_args[0][1]
+        TestEdgeCaching._remove_parent_attrs(actual_param)
+        self._assert_equal_objects(actual_param, expected_param)
+
+    def test_pin_recursive_invalid_root_directory(self):
+        get_response = self._get_dir_entry(self._root, False)
+        self._init_filer(get_response=get_response)
+        with self.assertRaises(exceptions.CTERAException) as error:
+            cache.Cache(self._filer).pin_recursive(self._pin_invalid_folder_path)
+        self._filer.api.get.assert_called_once_with('/config/cloudsync/cloudExtender/selectedFolders')
+        self.assertEqual('Invalid root directory', error.exception.message)
+
+    def test_unpin_recursive(self):
+        get_response = self._create_dir_tree(self._pin_valid_folder_path, True)
+        self._init_filer(get_response=get_response)
+        cache.Cache(self._filer).unpin_recursive(self._pin_valid_folder_path)
+        self._filer.api.get.assert_called_once_with('/config/cloudsync/cloudExtender/selectedFolders')
+        self._filer.api.put.assert_called_once_with('/config/cloudsync/cloudExtender/selectedFolders', mock.ANY)
+
+        expected_param = self._create_dir_tree(self._pin_valid_folder_path, False)
+        actual_param = self._filer.api.put.call_args[0][1]
+        TestEdgeCaching._remove_parent_attrs(actual_param)
+        self._assert_equal_objects(actual_param, expected_param)
+
+    def test_unpin_recursive_invalid_root_directory(self):
+        get_response = self._get_dir_entry(self._root, True)
+        self._init_filer(get_response=get_response)
+        with self.assertRaises(exceptions.CTERAException) as error:
+            cache.Cache(self._filer).unpin_recursive(self._pin_invalid_folder_path)
+        self._filer.api.get.assert_called_once_with('/config/cloudsync/cloudExtender/selectedFolders')
+        self.assertEqual('Invalid root directory', error.exception.message)
+
     def _get_dir_entry(self, name, include):
         param = Object()
         param._classname = 'DirEntry'  # pylint: disable=protected-access

tests/ut/test_edge_nfs.py

@@ -59,12 +59,59 @@ def test_modify_raise(self):
             nfs.NFS(self._filer).modify()
         self.assertEqual('NFS must be enabled in order to modify its configuration', error.exception.message)
 
+    def test_modify_all_parameters(self):
+        """Test modifying all NFS parameters"""
+        self._init_filer(get_response=TestEdgeNFS._get_nfs_configuration_response())
+        params = {
+            'async_write': False,
+            'aggregate_writes': False,
+            'mountd_port': 1234,
+            'statd_port': 5678,
+            'nfsv4_enabled': True,
+            'krb5_enabled': True,
+            'nfsd_host': '192.168.1.1'
+        }
+        nfs.NFS(self._filer).modify(**params)
+        self._filer.api.get.assert_called_once_with('/config/fileservices/nfs')
+        self._filer.api.put.assert_called_once_with('/config/fileservices/nfs', mock.ANY)
+        actual_param = self._filer.api.put.call_args[0][1]
+        self.assertEqual(actual_param.mountdPort, params['mountd_port'])
+        self.assertEqual(actual_param.nfsv4enabled, params['nfsv4_enabled'])
+        self.assertEqual(actual_param.krb5, params['krb5_enabled'])
+        self.assertEqual(actual_param.nfsHost, params['nfsd_host'])
+
+    def test_modify_krb5_without_nfsv4(self):
+        """Test enabling Kerberos without NFSv4 enabled"""
+        config = TestEdgeNFS._get_nfs_configuration_response()
+        config.nfsv4enabled = False
+        self._init_filer(get_response=config)
+
+        with self.assertRaises(exceptions.CTERAException) as error:
+            nfs.NFS(self._filer).modify(krb5_enabled=True)
+        self.assertEqual('NFSv4 must be enabled in order to enable Kerberos', error.exception.message)
+
     @staticmethod
-    def _get_nfs_configuration_response(async_write=True, aggregate_writes=True, statd_port=None):
+    def _get_nfs_configuration_response(
+            async_write=True,
+            aggregate_writes=True,
+            statd_port=None,
+            mountd_port=None,
+            nfsv4_enabled=None,
+            krb5_enabled=None,
+            nfsd_host=None):
+        """Extended helper method to support all configuration parameters"""
         obj = Object()
         obj.mode = Mode.Enabled
         setattr(obj, 'async', Mode.Enabled if async_write else Mode.Disabled)
         obj.aggregateWrites = Mode.Enabled if aggregate_writes else Mode.Disabled
         if statd_port is not None:
             obj.statdPort = statd_port
+        if mountd_port is not None:
+            obj.mountdPort = mountd_port
+        if nfsv4_enabled is not None:
+            obj.nfsv4enabled = nfsv4_enabled
+        if krb5_enabled is not None:
+            obj.krb5 = krb5_enabled
+        if nfsd_host is not None:
+            obj.nfsHost = nfsd_host
         return obj