Beispiel #1
0
 def test_fs_snap_shot(self):
     """
     Test creating a FS snap shot.
     :return: None
     """
     pool_name = p_n()
     fs_name = fs_n()
     fs_ss = fs_n()
     StratisCli.pool_create(pool_name, [DISKS[0]])
     StratisCli.fs_create(pool_name, fs_name)
     StratisCli.fs_ss_create(pool_name, fs_name, fs_ss)
     fs = StratisCli.fs_list()
     self.assertTrue(fs_ss in fs)
Beispiel #2
0
    def test_fs_rename(self):
        """
        Test renaming a FS
        :return: None
        """
        pool_name = p_n()
        fs_name = fs_n()
        fs_new_name = fs_n()
        StratisCli.pool_create(pool_name, [DISKS[0]])
        StratisCli.fs_create(pool_name, fs_name)
        StratisCli.fs_rename(pool_name, fs_name, fs_new_name)

        fs = StratisCli.fs_list()
        self.assertTrue(fs_new_name in fs.keys())
        self.assertFalse(fs_name in fs.keys())
        self.assertEqual(1, len(fs))
Beispiel #3
0
    def test_fs_destroy(self):
        """
        Test destroying a FS
        :return:
        """
        pool_name = p_n()
        fs_name = fs_n()
        fs_too = fs_n()
        StratisCli.pool_create(pool_name, [DISKS[0]])
        StratisCli.fs_create(pool_name, fs_name)
        StratisCli.fs_create(pool_name, fs_too)
        StratisCli.fs_destroy(pool_name, fs_name)

        fs = StratisCli.fs_list()
        self.assertEqual(1, len(fs))
        self.assertFalse(fs_n in fs)
        self.assertTrue(fs_too in fs)
Beispiel #4
0
 def test_fs_create(self):
     """
     Test creating a FS
     :return: None
     """
     pool_name = p_n()
     fs_name = fs_n()
     StratisCli.pool_create(pool_name, [DISKS[0]])
     StratisCli.fs_create(pool_name, fs_name)
     fs = StratisCli.fs_list()
     self.assertTrue(fs_name in fs.keys())
     self.assertEqual(1, len(fs))
     self.assertEqual(fs[fs_name]["POOL_NAME"], pool_name)
    def test_no_list_listings(self):
        """
        Test that commands that optionally take a list work both ways.
        :return: None
        """
        pool_name = p_n()
        fs_name = fs_n()
        StratisCli.pool_create(pool_name, block_devices=DISKS)
        StratisCli.fs_create(pool_name, fs_name)

        self.assertEqual(StratisCli.pool_list(), StratisCli.pool_list(False))
        self.assertEqual(StratisCli.fs_list(), StratisCli.fs_list(False))
        self.assertEqual(StratisCli.blockdev_list(),
                         StratisCli.blockdev_list(False))
Beispiel #6
0
    def test_simple_data_io(self):
        """
        Create a pool and fs, create some files on it and validate them to
        ensure very basic data path is working.
        :return: None
        """
        mount_path = None
        try:
            pool_name = p_n()
            fs_name = fs_n()
            StratisCli.pool_create(pool_name, block_devices=DISKS)
            StratisCli.fs_create(pool_name, fs_name)

            # mount the fs
            mount_path = os.path.join(os.path.sep + "mnt", rs(16))
            os.mkdir(mount_path)
            exec_command(
                ["mount",
                 stratis_link(pool_name, fs_name), mount_path])

            files = {}
            total_size = 0
            # Do some simple IO to it, creating at most about ~100MiB data
            while total_size < 1024 * 1024 * 100:
                fn, signature, size = file_create(mount_path)
                total_size += size
                files[fn] = signature

            # Validate them
            for name, signature in files.items():
                self.assertTrue(file_signature(name), signature)

        finally:
            # Make sure we un-mount the fs before we bail as we can't clean up
            # Stratis when the FS is mounted.
            if mount_path:
                exec_command(["umount", mount_path])
                os.rmdir(mount_path)