ceph/src/pybind/mgr/dashboard/tests/test_ganesha.py

   1 # -*- coding: utf-8 -*-
   2 from __future__ import absolute_import
   3
   4 import unittest
   5
   6 try:
   7     from mock import MagicMock, Mock
   8 except ImportError:
   9     from unittest.mock import MagicMock, Mock
  10
  11 import orchestrator
  12 from . import KVStoreMockMixin
  13 from .. import mgr
  14 from ..settings import Settings
  15 from ..services import ganesha
  16 from ..services.ganesha import GaneshaConf, Export, GaneshaConfParser
  17
  18
  19 class GaneshaConfTest(unittest.TestCase, KVStoreMockMixin):
  20     export_1 = """
  21 EXPORT {
  22     Export_ID=1;
  23     Protocols = 4;
  24     Path = /;
  25     Pseudo = /cephfs_a/;
  26     Access_Type = RW;
  27     Protocols = 4;
  28     Attr_Expiration_Time = 0;
  29     # Delegations = R;
  30     # Squash = root;
  31
  32     FSAL {
  33         Name = CEPH;
  34         Filesystem = "a";
  35         User_Id = "ganesha";
  36         # Secret_Access_Key = "YOUR SECRET KEY HERE";
  37     }
  38
  39     CLIENT
  40     {
  41         Clients = 192.168.0.10, 192.168.1.0/8;
  42         Squash = None;
  43     }
  44
  45     CLIENT
  46     {
  47         Clients = 192.168.0.0/16;
  48         Squash = All;
  49         Access_Type = RO;
  50     }
  51 }
  52 """
  53
  54     export_2 = """
  55 EXPORT
  56 {
  57     Export_ID=2;
  58
  59     Path = "/";
  60
  61     Pseudo = "/rgw";
  62
  63     Access_Type = RW;
  64
  65     squash = AllAnonymous;
  66
  67     Protocols = 4, 3;
  68
  69     Transports = TCP, UDP;
  70
  71     FSAL {
  72         Name = RGW;
  73         User_Id = "testuser";
  74         Access_Key_Id ="access_key";
  75         Secret_Access_Key = "secret_key";
  76     }
  77 }
  78 """
  79
  80     conf_nodea = '''
  81 %url rados://ganesha/ns/export-2
  82
  83 %url "rados://ganesha/ns/export-1"'''
  84
  85     conf_nodeb = '%url "rados://ganesha/ns/export-1"'
  86
  87     class RObject(object):
  88         def __init__(self, key, raw):
  89             self.key = key
  90             self.raw = raw
  91
  92         def read(self, _):
  93             return self.raw.encode('utf-8')
  94
  95         def stat(self):
  96             return len(self.raw), None
  97
  98     def _ioctx_write_full_mock(self, key, content):
  99         if key not in self.temp_store:
 100             self.temp_store[key] = GaneshaConfTest.RObject(key,
 101                                                            content.decode('utf-8'))
 102         else:
 103             self.temp_store[key].raw = content.decode('utf-8')
 104
 105     def _ioctx_remove_mock(self, key):
 106         del self.temp_store[key]
 107
 108     def _ioctx_list_objects_mock(self):
 109         return [obj for _, obj in self.temp_store.items()]
 110
 111     def setUp(self):
 112         self.mock_kv_store()
 113
 114         Settings.GANESHA_CLUSTERS_RADOS_POOL_NAMESPACE = "ganesha/ns"
 115
 116         self.temp_store = {
 117             'export-1': GaneshaConfTest.RObject("export-1", self.export_1),
 118             'conf-nodea': GaneshaConfTest.RObject("conf-nodea", self.conf_nodea),
 119             'export-2': GaneshaConfTest.RObject("export-2", self.export_2),
 120             'conf-nodeb': GaneshaConfTest.RObject("conf-nodeb", self.conf_nodeb)
 121         }
 122
 123         self.io_mock = MagicMock()
 124         self.io_mock.list_objects.side_effect = self._ioctx_list_objects_mock
 125         self.io_mock.write_full.side_effect = self._ioctx_write_full_mock
 126         self.io_mock.remove_object.side_effect = self._ioctx_remove_mock
 127
 128         ioctx_mock = MagicMock()
 129         ioctx_mock.__enter__ = Mock(return_value=(self.io_mock))
 130         ioctx_mock.__exit__ = Mock(return_value=None)
 131
 132         mgr.rados = MagicMock()
 133         mgr.rados.open_ioctx.return_value = ioctx_mock
 134
 135         # pylint: disable=protected-access
 136         mgr._select_orchestrator.side_effect = orchestrator.NoOrchestrator()
 137
 138         ganesha.CephX = MagicMock()
 139         ganesha.CephX.list_clients.return_value = ['ganesha']
 140         ganesha.CephX.get_client_key.return_value = 'ganesha'
 141
 142         ganesha.CephFS = MagicMock()
 143
 144     def test_export_parser_1(self):
 145         blocks = GaneshaConfParser(self.export_1).parse()
 146         self.assertIsInstance(blocks, list)
 147         self.assertEqual(len(blocks), 1)
 148         export = Export.from_export_block(blocks[0], '_default_',
 149                                           GaneshaConf.ganesha_defaults({}))
 150
 151         self.assertEqual(export.export_id, 1)
 152         self.assertEqual(export.path, "/")
 153         self.assertEqual(export.pseudo, "/cephfs_a")
 154         self.assertIsNone(export.tag)
 155         self.assertEqual(export.access_type, "RW")
 156         self.assertEqual(export.squash, "root_squash")
 157         self.assertEqual(export.protocols, {4})
 158         self.assertEqual(export.transports, {"TCP", "UDP"})
 159         self.assertEqual(export.fsal.name, "CEPH")
 160         self.assertEqual(export.fsal.user_id, "ganesha")
 161         self.assertEqual(export.fsal.fs_name, "a")
 162         self.assertEqual(export.fsal.sec_label_xattr, None)
 163         self.assertEqual(len(export.clients), 2)
 164         self.assertEqual(export.clients[0].addresses,
 165                          ["192.168.0.10", "192.168.1.0/8"])
 166         self.assertEqual(export.clients[0].squash, "no_root_squash")
 167         self.assertIsNone(export.clients[0].access_type)
 168         self.assertEqual(export.clients[1].addresses, ["192.168.0.0/16"])
 169         self.assertEqual(export.clients[1].squash, "all_squash")
 170         self.assertEqual(export.clients[1].access_type, "RO")
 171         self.assertEqual(export.cluster_id, '_default_')
 172         self.assertEqual(export.attr_expiration_time, 0)
 173         self.assertEqual(export.security_label, False)
 174
 175     def test_export_parser_2(self):
 176         blocks = GaneshaConfParser(self.export_2).parse()
 177         self.assertIsInstance(blocks, list)
 178         self.assertEqual(len(blocks), 1)
 179         export = Export.from_export_block(blocks[0], '_default_',
 180                                           GaneshaConf.ganesha_defaults({}))
 181
 182         self.assertEqual(export.export_id, 2)
 183         self.assertEqual(export.path, "/")
 184         self.assertEqual(export.pseudo, "/rgw")
 185         self.assertIsNone(export.tag)
 186         self.assertEqual(export.access_type, "RW")
 187         self.assertEqual(export.squash, "all_squash")
 188         self.assertEqual(export.protocols, {4, 3})
 189         self.assertEqual(export.transports, {"TCP", "UDP"})
 190         self.assertEqual(export.fsal.name, "RGW")
 191         self.assertEqual(export.fsal.rgw_user_id, "testuser")
 192         self.assertEqual(export.fsal.access_key, "access_key")
 193         self.assertEqual(export.fsal.secret_key, "secret_key")
 194         self.assertEqual(len(export.clients), 0)
 195         self.assertEqual(export.cluster_id, '_default_')
 196
 197     def test_daemon_conf_parser_a(self):
 198         blocks = GaneshaConfParser(self.conf_nodea).parse()
 199         self.assertIsInstance(blocks, list)
 200         self.assertEqual(len(blocks), 2)
 201         self.assertEqual(blocks[0]['block_name'], "%url")
 202         self.assertEqual(blocks[0]['value'], "rados://ganesha/ns/export-2")
 203         self.assertEqual(blocks[1]['block_name'], "%url")
 204         self.assertEqual(blocks[1]['value'], "rados://ganesha/ns/export-1")
 205
 206     def test_daemon_conf_parser_b(self):
 207         blocks = GaneshaConfParser(self.conf_nodeb).parse()
 208         self.assertIsInstance(blocks, list)
 209         self.assertEqual(len(blocks), 1)
 210         self.assertEqual(blocks[0]['block_name'], "%url")
 211         self.assertEqual(blocks[0]['value'], "rados://ganesha/ns/export-1")
 212
 213     def test_ganesha_conf(self):
 214         ganesha_conf = GaneshaConf.instance('_default_')
 215         exports = ganesha_conf.exports
 216
 217         self.assertEqual(len(exports.items()), 2)
 218         self.assertIn(1, exports)
 219         self.assertIn(2, exports)
 220
 221         # export_id = 1 asserts
 222         export = exports[1]
 223         self.assertEqual(export.export_id, 1)
 224         self.assertEqual(export.path, "/")
 225         self.assertEqual(export.pseudo, "/cephfs_a")
 226         self.assertIsNone(export.tag)
 227         self.assertEqual(export.access_type, "RW")
 228         self.assertEqual(export.squash, "root_squash")
 229         self.assertEqual(export.protocols, {4})
 230         self.assertEqual(export.transports, {"TCP", "UDP"})
 231         self.assertEqual(export.fsal.name, "CEPH")
 232         self.assertEqual(export.fsal.user_id, "ganesha")
 233         self.assertEqual(export.fsal.fs_name, "a")
 234         self.assertEqual(export.fsal.sec_label_xattr, None)
 235         self.assertEqual(len(export.clients), 2)
 236         self.assertEqual(export.clients[0].addresses,
 237                          ["192.168.0.10", "192.168.1.0/8"])
 238         self.assertEqual(export.clients[0].squash, "no_root_squash")
 239         self.assertIsNone(export.clients[0].access_type)
 240         self.assertEqual(export.clients[1].addresses, ["192.168.0.0/16"])
 241         self.assertEqual(export.clients[1].squash, "all_squash")
 242         self.assertEqual(export.clients[1].access_type, "RO")
 243         self.assertEqual(export.attr_expiration_time, 0)
 244         self.assertEqual(export.security_label, False)
 245
 246         # export_id = 2 asserts
 247         export = exports[2]
 248         self.assertEqual(export.export_id, 2)
 249         self.assertEqual(export.path, "/")
 250         self.assertEqual(export.pseudo, "/rgw")
 251         self.assertIsNone(export.tag)
 252         self.assertEqual(export.access_type, "RW")
 253         self.assertEqual(export.squash, "all_squash")
 254         self.assertEqual(export.protocols, {4, 3})
 255         self.assertEqual(export.transports, {"TCP", "UDP"})
 256         self.assertEqual(export.fsal.name, "RGW")
 257         self.assertEqual(export.fsal.rgw_user_id, "testuser")
 258         self.assertEqual(export.fsal.access_key, "access_key")
 259         self.assertEqual(export.fsal.secret_key, "secret_key")
 260         self.assertEqual(len(export.clients), 0)
 261
 262     def test_config_dict(self):
 263         conf = GaneshaConf.instance('_default_')
 264         export = conf.exports[1]
 265         ex_dict = export.to_dict()
 266         self.assertDictEqual(ex_dict, {
 267             'daemons': ['nodea', 'nodeb'],
 268             'export_id': 1,
 269             'path': '/',
 270             'pseudo': '/cephfs_a',
 271             'cluster_id': '_default_',
 272             'tag': None,
 273             'access_type': 'RW',
 274             'squash': 'root_squash',
 275             'security_label': False,
 276             'protocols': [4],
 277             'transports': ['TCP', 'UDP'],
 278             'clients': [{
 279                 'addresses': ["192.168.0.10", "192.168.1.0/8"],
 280                 'access_type': None,
 281                 'squash': 'no_root_squash'
 282             }, {
 283                 'addresses': ["192.168.0.0/16"],
 284                 'access_type': 'RO',
 285                 'squash': 'all_squash'
 286             }],
 287             'fsal': {
 288                 'name': 'CEPH',
 289                 'user_id': 'ganesha',
 290                 'fs_name': 'a',
 291                 'sec_label_xattr': None
 292             }
 293         })
 294
 295         export = conf.exports[2]
 296         ex_dict = export.to_dict()
 297         self.assertDictEqual(ex_dict, {
 298             'daemons': ['nodea'],
 299             'export_id': 2,
 300             'path': '/',
 301             'pseudo': '/rgw',
 302             'cluster_id': '_default_',
 303             'tag': None,
 304             'access_type': 'RW',
 305             'squash': 'all_squash',
 306             'security_label': False,
 307             'protocols': [3, 4],
 308             'transports': ['TCP', 'UDP'],
 309             'clients': [],
 310             'fsal': {
 311                 'name': 'RGW',
 312                 'rgw_user_id': 'testuser'
 313             }
 314         })
 315
 316     def test_config_from_dict(self):
 317         export = Export.from_dict(1, {
 318             'daemons': ['nodea', 'nodeb'],
 319             'export_id': 1,
 320             'path': '/',
 321             'cluster_id': '_default_',
 322             'pseudo': '/cephfs_a',
 323             'tag': None,
 324             'access_type': 'RW',
 325             'squash': 'root_squash',
 326             'security_label': True,
 327             'protocols': [4],
 328             'transports': ['TCP', 'UDP'],
 329             'clients': [{
 330                 'addresses': ["192.168.0.10", "192.168.1.0/8"],
 331                 'access_type': None,
 332                 'squash': 'no_root_squash'
 333             }, {
 334                 'addresses': ["192.168.0.0/16"],
 335                 'access_type': 'RO',
 336                 'squash': 'all_squash'
 337             }],
 338             'fsal': {
 339                 'name': 'CEPH',
 340                 'user_id': 'ganesha',
 341                 'fs_name': 'a',
 342                 'sec_label_xattr': 'security.selinux'
 343             }
 344         })
 345
 346         self.assertEqual(export.export_id, 1)
 347         self.assertEqual(export.path, "/")
 348         self.assertEqual(export.pseudo, "/cephfs_a")
 349         self.assertIsNone(export.tag)
 350         self.assertEqual(export.access_type, "RW")
 351         self.assertEqual(export.squash, "root_squash")
 352         self.assertEqual(export.protocols, {4})
 353         self.assertEqual(export.transports, {"TCP", "UDP"})
 354         self.assertEqual(export.fsal.name, "CEPH")
 355         self.assertEqual(export.fsal.user_id, "ganesha")
 356         self.assertEqual(export.fsal.fs_name, "a")
 357         self.assertEqual(export.fsal.sec_label_xattr, 'security.selinux')
 358         self.assertEqual(len(export.clients), 2)
 359         self.assertEqual(export.clients[0].addresses,
 360                          ["192.168.0.10", "192.168.1.0/8"])
 361         self.assertEqual(export.clients[0].squash, "no_root_squash")
 362         self.assertIsNone(export.clients[0].access_type)
 363         self.assertEqual(export.clients[1].addresses, ["192.168.0.0/16"])
 364         self.assertEqual(export.clients[1].squash, "all_squash")
 365         self.assertEqual(export.clients[1].access_type, "RO")
 366         self.assertEqual(export.daemons, {"nodeb", "nodea"})
 367         self.assertEqual(export.cluster_id, '_default_')
 368         self.assertEqual(export.attr_expiration_time, 0)
 369         self.assertEqual(export.security_label, True)
 370
 371         export = Export.from_dict(2, {
 372             'daemons': ['nodea'],
 373             'export_id': 2,
 374             'path': '/',
 375             'pseudo': '/rgw',
 376             'cluster_id': '_default_',
 377             'tag': None,
 378             'access_type': 'RW',
 379             'squash': 'all_squash',
 380             'security_label': False,
 381             'protocols': [4, 3],
 382             'transports': ['TCP', 'UDP'],
 383             'clients': [],
 384             'fsal': {
 385                 'name': 'RGW',
 386                 'rgw_user_id': 'testuser'
 387             }
 388         })
 389
 390         self.assertEqual(export.export_id, 2)
 391         self.assertEqual(export.path, "/")
 392         self.assertEqual(export.pseudo, "/rgw")
 393         self.assertIsNone(export.tag)
 394         self.assertEqual(export.access_type, "RW")
 395         self.assertEqual(export.squash, "all_squash")
 396         self.assertEqual(export.protocols, {4, 3})
 397         self.assertEqual(export.transports, {"TCP", "UDP"})
 398         self.assertEqual(export.fsal.name, "RGW")
 399         self.assertEqual(export.fsal.rgw_user_id, "testuser")
 400         self.assertIsNone(export.fsal.access_key)
 401         self.assertIsNone(export.fsal.secret_key)
 402         self.assertEqual(len(export.clients), 0)
 403         self.assertEqual(export.daemons, {"nodea"})
 404         self.assertEqual(export.cluster_id, '_default_')
 405
 406     def test_gen_raw_config(self):
 407         conf = GaneshaConf.instance('_default_')
 408         # pylint: disable=W0212
 409         export = conf.exports[1]
 410         del conf.exports[1]
 411         conf._save_export(export)
 412         conf = GaneshaConf.instance('_default_')
 413         exports = conf.exports
 414         self.assertEqual(len(exports.items()), 2)
 415         self.assertIn(1, exports)
 416         self.assertIn(2, exports)
 417
 418         # export_id = 1 asserts
 419         export = exports[1]
 420         self.assertEqual(export.export_id, 1)
 421         self.assertEqual(export.path, "/")
 422         self.assertEqual(export.pseudo, "/cephfs_a")
 423         self.assertIsNone(export.tag)
 424         self.assertEqual(export.access_type, "RW")
 425         self.assertEqual(export.squash, "root_squash")
 426         self.assertEqual(export.protocols, {4})
 427         self.assertEqual(export.transports, {"TCP", "UDP"})
 428         self.assertEqual(export.fsal.name, "CEPH")
 429         self.assertEqual(export.fsal.user_id, "ganesha")
 430         self.assertEqual(export.fsal.fs_name, "a")
 431         self.assertEqual(export.fsal.sec_label_xattr, None)
 432         self.assertEqual(len(export.clients), 2)
 433         self.assertEqual(export.clients[0].addresses,
 434                          ["192.168.0.10", "192.168.1.0/8"])
 435         self.assertEqual(export.clients[0].squash, "no_root_squash")
 436         self.assertIsNone(export.clients[0].access_type)
 437         self.assertEqual(export.clients[1].addresses, ["192.168.0.0/16"])
 438         self.assertEqual(export.clients[1].squash, "all_squash")
 439         self.assertEqual(export.clients[1].access_type, "RO")
 440         self.assertEqual(export.daemons, {"nodeb", "nodea"})
 441         self.assertEqual(export.cluster_id, '_default_')
 442         self.assertEqual(export.attr_expiration_time, 0)
 443         self.assertEqual(export.security_label, False)
 444
 445         # export_id = 2 asserts
 446         export = exports[2]
 447         self.assertEqual(export.export_id, 2)
 448         self.assertEqual(export.path, "/")
 449         self.assertEqual(export.pseudo, "/rgw")
 450         self.assertIsNone(export.tag)
 451         self.assertEqual(export.access_type, "RW")
 452         self.assertEqual(export.squash, "all_squash")
 453         self.assertEqual(export.protocols, {4, 3})
 454         self.assertEqual(export.transports, {"TCP", "UDP"})
 455         self.assertEqual(export.fsal.name, "RGW")
 456         self.assertEqual(export.fsal.rgw_user_id, "testuser")
 457         self.assertEqual(export.fsal.access_key, "access_key")
 458         self.assertEqual(export.fsal.secret_key, "secret_key")
 459         self.assertEqual(len(export.clients), 0)
 460         self.assertEqual(export.daemons, {"nodea"})
 461         self.assertEqual(export.cluster_id, '_default_')
 462
 463     def test_update_export(self):
 464         ganesha.RgwClient = MagicMock()
 465         admin_inst_mock = MagicMock()
 466         admin_inst_mock.get_user_keys.return_value = {
 467             'access_key': 'access_key',
 468             'secret_key': 'secret_key'
 469         }
 470         ganesha.RgwClient.admin_instance.return_value = admin_inst_mock
 471
 472         conf = GaneshaConf.instance('_default_')
 473         conf.update_export({
 474             'export_id': 2,
 475             'daemons': ["nodeb"],
 476             'path': 'bucket',
 477             'pseudo': '/rgw/bucket',
 478             'cluster_id': '_default_',
 479             'tag': 'bucket_tag',
 480             'access_type': 'RW',
 481             'squash': 'all_squash',
 482             'security_label': False,
 483             'protocols': [4, 3],
 484             'transports': ['TCP', 'UDP'],
 485             'clients': [{
 486                 'addresses': ["192.168.0.0/16"],
 487                 'access_type': None,
 488                 'squash': None
 489             }],
 490             'fsal': {
 491                 'name': 'RGW',
 492                 'rgw_user_id': 'testuser'
 493             }
 494         })
 495
 496         conf = GaneshaConf.instance('_default_')
 497         export = conf.get_export(2)
 498         self.assertEqual(export.export_id, 2)
 499         self.assertEqual(export.path, "bucket")
 500         self.assertEqual(export.pseudo, "/rgw/bucket")
 501         self.assertEqual(export.tag, "bucket_tag")
 502         self.assertEqual(export.access_type, "RW")
 503         self.assertEqual(export.squash, "all_squash")
 504         self.assertEqual(export.protocols, {4, 3})
 505         self.assertEqual(export.transports, {"TCP", "UDP"})
 506         self.assertEqual(export.fsal.name, "RGW")
 507         self.assertEqual(export.fsal.rgw_user_id, "testuser")
 508         self.assertEqual(export.fsal.access_key, "access_key")
 509         self.assertEqual(export.fsal.secret_key, "secret_key")
 510         self.assertEqual(len(export.clients), 1)
 511         self.assertEqual(export.clients[0].addresses, ["192.168.0.0/16"])
 512         self.assertIsNone(export.clients[0].squash)
 513         self.assertIsNone(export.clients[0].access_type)
 514         self.assertEqual(export.daemons, {"nodeb"})
 515         self.assertEqual(export.cluster_id, '_default_')
 516
 517     def test_remove_export(self):
 518         conf = GaneshaConf.instance('_default_')
 519         conf.remove_export(1)
 520         exports = conf.list_exports()
 521         self.assertEqual(len(exports), 1)
 522         self.assertEqual(2, exports[0].export_id)
 523         export = conf.get_export(2)
 524         self.assertEqual(export.export_id, 2)
 525         self.assertEqual(export.path, "/")
 526         self.assertEqual(export.pseudo, "/rgw")
 527         self.assertIsNone(export.tag)
 528         self.assertEqual(export.access_type, "RW")
 529         self.assertEqual(export.squash, "all_squash")
 530         self.assertEqual(export.protocols, {4, 3})
 531         self.assertEqual(export.transports, {"TCP", "UDP"})
 532         self.assertEqual(export.fsal.name, "RGW")
 533         self.assertEqual(export.fsal.rgw_user_id, "testuser")
 534         self.assertEqual(export.fsal.access_key, "access_key")
 535         self.assertEqual(export.fsal.secret_key, "secret_key")
 536         self.assertEqual(len(export.clients), 0)
 537         self.assertEqual(export.daemons, {"nodea"})
 538         self.assertEqual(export.cluster_id, '_default_')
 539
 540     def test_create_export_rgw(self):
 541         ganesha.RgwClient = MagicMock()
 542         admin_inst_mock = MagicMock()
 543         admin_inst_mock.get_user_keys.return_value = {
 544             'access_key': 'access_key2',
 545             'secret_key': 'secret_key2'
 546         }
 547         ganesha.RgwClient.admin_instance.return_value = admin_inst_mock
 548
 549         conf = GaneshaConf.instance('_default_')
 550         ex_id = conf.create_export({
 551             'daemons': ["nodeb"],
 552             'path': 'bucket',
 553             'pseudo': '/rgw/bucket',
 554             'tag': 'bucket_tag',
 555             'cluster_id': '_default_',
 556             'access_type': 'RW',
 557             'squash': 'all_squash',
 558             'security_label': False,
 559             'protocols': [4, 3],
 560             'transports': ['TCP', 'UDP'],
 561             'clients': [{
 562                 'addresses': ["192.168.0.0/16"],
 563                 'access_type': None,
 564                 'squash': None
 565             }],
 566             'fsal': {
 567                 'name': 'RGW',
 568                 'rgw_user_id': 'testuser'
 569             }
 570         })
 571
 572         conf = GaneshaConf.instance('_default_')
 573         exports = conf.list_exports()
 574         self.assertEqual(len(exports), 3)
 575         export = conf.get_export(ex_id)
 576         self.assertEqual(export.export_id, ex_id)
 577         self.assertEqual(export.path, "bucket")
 578         self.assertEqual(export.pseudo, "/rgw/bucket")
 579         self.assertEqual(export.tag, "bucket_tag")
 580         self.assertEqual(export.access_type, "RW")
 581         self.assertEqual(export.squash, "all_squash")
 582         self.assertEqual(export.protocols, {4, 3})
 583         self.assertEqual(export.transports, {"TCP", "UDP"})
 584         self.assertEqual(export.fsal.name, "RGW")
 585         self.assertEqual(export.fsal.rgw_user_id, "testuser")
 586         self.assertEqual(export.fsal.access_key, "access_key2")
 587         self.assertEqual(export.fsal.secret_key, "secret_key2")
 588         self.assertEqual(len(export.clients), 1)
 589         self.assertEqual(export.clients[0].addresses, ["192.168.0.0/16"])
 590         self.assertIsNone(export.clients[0].squash)
 591         self.assertIsNone(export.clients[0].access_type)
 592         self.assertEqual(export.daemons, {"nodeb"})
 593         self.assertEqual(export.cluster_id, '_default_')
 594
 595     def test_create_export_cephfs(self):
 596         ganesha.CephX = MagicMock()
 597         ganesha.CephX.list_clients.return_value = ["fs"]
 598         ganesha.CephX.get_client_key.return_value = "fs_key"
 599
 600         ganesha.CephFS = MagicMock()
 601         ganesha.CephFS.dir_exists.return_value = True
 602
 603         conf = GaneshaConf.instance('_default_')
 604         ex_id = conf.create_export({
 605             'daemons': ['nodea', 'nodeb'],
 606             'path': '/',
 607             'pseudo': '/cephfs2',
 608             'cluster_id': '_default_',
 609             'tag': None,
 610             'access_type': 'RW',
 611             'squash': 'all_squash',
 612             'security_label': True,
 613             'protocols': [4],
 614             'transports': ['TCP'],
 615             'clients': [],
 616             'fsal': {
 617                 'name': 'CEPH',
 618                 'user_id': 'fs',
 619                 'fs_name': None,
 620                 'sec_label_xattr': 'security.selinux'
 621             }
 622         })
 623
 624         conf = GaneshaConf.instance('_default_')
 625         exports = conf.list_exports()
 626         self.assertEqual(len(exports), 3)
 627         export = conf.get_export(ex_id)
 628         self.assertEqual(export.export_id, ex_id)
 629         self.assertEqual(export.path, "/")
 630         self.assertEqual(export.pseudo, "/cephfs2")
 631         self.assertIsNone(export.tag)
 632         self.assertEqual(export.access_type, "RW")
 633         self.assertEqual(export.squash, "all_squash")
 634         self.assertEqual(export.protocols, {4})
 635         self.assertEqual(export.transports, {"TCP"})
 636         self.assertEqual(export.fsal.name, "CEPH")
 637         self.assertEqual(export.fsal.user_id, "fs")
 638         self.assertEqual(export.fsal.cephx_key, "fs_key")
 639         self.assertEqual(export.fsal.sec_label_xattr, "security.selinux")
 640         self.assertIsNone(export.fsal.fs_name)
 641         self.assertEqual(len(export.clients), 0)
 642         self.assertEqual(export.daemons, {"nodeb", "nodea"})
 643         self.assertEqual(export.cluster_id, '_default_')
 644         self.assertEqual(export.attr_expiration_time, 0)
 645         self.assertEqual(export.security_label, True)