Exemplo n.º 1
0
def find_new_hashed(subvols, parent_path, oldname):
    '''
        This is written for rename case so that the new name will hash to a
        different subvol than that of the the old name.
        Note: The new hash will be searched under the same parent

        Args:
            subvols = list of subvols
            parent_path = parent path (relative to mount) of "oldname"
            oldname = name of the source file for rename operation

        Return Values:
            For success returns an object of type NewHashed holding
            information pertaining to new name.

            For Failure returns None
    '''
    # pylint: disable=protected-access
    # pylint: disable=pointless-string-statement
    # pylint: disable=too-many-locals
    # pylint: disable=too-many-statements
    # pylint: disable=too-many-branches
    # pylint: disable=too-many-return-statements
    brickobject = create_brickobjectlist(subvols, parent_path)
    if brickobject is None:
        g.log.error("could not form brickobject list")
        return None

    for bro in brickobject:
        bro._get_hashrange()
        low = bro._hashrange_low
        high = bro._hashrange_high
        g.log.debug("low hashrange %s high hashrange %s", str(low), str(high))
        g.log.debug("absoulte path %s", bro._fqpath)

    hash_num = calculate_hash(brickobject[0]._host, oldname)
    oldhashed, _ = find_hashed_subvol(subvols, parent_path, oldname)
    if oldhashed is None:
        g.log.error("could not find old hashed subvol")
        return None

    g.log.debug("oldhashed: %s oldname: %s oldhash %s", oldhashed._host,
                oldname, hash_num)

    count = -1
    for item in range(1, 5000, 1):
        newhash = calculate_hash(brickobject[0]._host, str(item))
        for brickdir in brickobject:
            count += 1
            ret = brickdir.hashrange_contains_hash(newhash)
            if ret == 1:
                if oldhashed._fqpath != brickdir._fqpath:
                    g.log.debug("oldhashed %s new %s count %s", oldhashed,
                                brickdir._host, str(count))
                    return NewHashed(item, brickdir, count)

        count = -1
    return None
Exemplo n.º 2
0
def find_specific_hashed(subvols, parent_path, subvol):
    """ Finds filename that hashes to a specific subvol.

    Args:
           subvols(list): list of subvols
           parent_path(str): parent path (relative to mount) of "oldname"
           subvol(str): The subvol to which the new name has to be hashed

    Returns:
             (Class Object): For success returns an object of type NewHashed
                            holding information pertaining to new name.
                            None, otherwise
     Note: The new hash will be searched under the same parent
    """
    # pylint: disable=protected-access
    brickobject = create_brickobjectlist(subvols, parent_path)
    if brickobject is None:
        g.log.error("could not form brickobject list")
        return None
    count = -1
    for item in range(1, 5000, 1):
        newhash = calculate_hash(brickobject[0]._host, str(item))
        for brickdir in brickobject:
            count += 1
            if subvol._fqpath == brickdir._fqpath:
                ret = brickdir.hashrange_contains_hash(newhash)
                if ret:
                    g.log.debug("oldhashed %s new %s count %s", subvol,
                                brickdir._host, str(count))
                    return NewHashed(item, brickdir, count)
        count = -1
    return None
Exemplo n.º 3
0
def find_nonhashed_subvol(subvols, parent_path, name):
    '''
        Args:
            subvols: subvol list
            parent_path: Immediate parent path of "name" relative from
                         mount point
                         e.g. if your mount is "/mnt" and the path from mount
                         is "/mnt/directory" then just pass "directory" as
                         parent_path

            name: file or directory name

        Return Values:
            nonhashed_subvol object: An object of type BrickDir type
                                     representing the nonhashed subvolume

            subvol_count: The subvol index in the subvol list
    '''
    # pylint: disable=protected-access
    if subvols is None or parent_path is None or name is None:
        g.log.error("empty arguments")
        return None, -1

    brickobject = create_brickobjectlist(subvols, parent_path)
    hash_num = calculate_hash(brickobject[0]._host, name)

    count = -1
    for brickdir in brickobject:
        count += 1
        ret = brickdir.hashrange_contains_hash(hash_num)
        if ret == 1:
            g.log.debug('hash subvolume is %s', brickdir.path)
            continue

        nonhashed_subvol = brickdir
        g.log.info('nonhashed subvol %s', brickdir._host)
        break

    return nonhashed_subvol, count
Exemplo n.º 4
0
    def test_create_file(self):
        '''
        Test file creation.
        '''
        # pylint: disable=too-many-locals
        # pylint: disable=protected-access
        # pylint: disable=too-many-statements
        mount_obj = self.mounts[0]
        mountpoint = mount_obj.mountpoint

        # files that needs to be created
        file_one = mountpoint + '/file1'

        # hash for file_one
        filehash = calculate_hash(self.servers[0], 'file1')

        # collect subvol info
        subvols = (get_subvols(self.mnode, self.volname))['volume_subvols']
        secondary_bricks = []
        for subvol in subvols:
            secondary_bricks.append(subvol[0])

        brickobject = []
        for item in secondary_bricks:
            temp = BrickDir(item)
            brickobject.append(temp)

        # create a file
        ret, _, _ = g.run(self.clients[0], ("touch %s" % file_one))
        self.assertEqual(ret, 0, ("File %s creation failed", file_one))

        # get pathinfo xattr on the file
        ret, out, err = g.run(self.clients[0],
                              ("getfattr -n trusted.glusterfs.pathinfo %s" %
                               file_one))
        g.log.info("pathinfo o/p %s", out)
        self.assertEqual(ret, 0, ("failed to get pathinfo on file %s err %s",
                                  file_one, err))

        vol_type = self.volume_type
        if vol_type == "distributed":
            brickhost = (out.split(":"))[3]
            brickpath = (out.split(":"))[4].split(">")[0]
        else:
            brickhost = (out.split(":"))[4]
            brickpath = (out.split(":")[5]).split(">")[0]

        g.log.debug("brickhost %s brickpath %s", brickhost, brickpath)

        # make sure the file is present only on the hashed brick
        count = -1
        for brickdir in brickobject:
            count += 1
            ret = brickdir.hashrange_contains_hash(filehash)
            if ret:
                hash_subvol = subvols[count]
                ret, _, err = g.run(brickdir._host, ("stat %s/file1" %
                                                     brickdir._fqpath))
                g.log.info("Hashed subvol is %s", brickdir._host)
                self.assertEqual(ret, 0, "Expected stat to succeed for file1")
                continue

            ret, _, err = g.run(brickdir._host, ("stat %s/file1" %
                                                 brickdir._fqpath))
            self.assertEqual(ret, 1, "Expected stat to fail for file1")

        # checking if pathinfo xattr has the right value
        ret, _, _ = g.run(brickhost, ("stat %s" % brickpath))
        self.assertEqual(ret, 0, ("Expected file1 to be present on %s",
                                  brickhost))

        # get permission from mount
        ret, out, _ = g.run(self.clients[0], ("ls -l %s" % file_one))
        mperm = (out.split(" "))[0]
        self.assertIsNotNone(mperm, "Expected stat to fail for file1")
        g.log.info("permission on mount %s", mperm)

        # get permission from brick
        ret, out, _ = g.run(brickhost, ("ls -l %s" % brickpath))
        bperm = (out.split(" "))[0]
        self.assertIsNotNone(bperm, "Expected stat to fail for file1")
        g.log.info("permission on brick %s", bperm)

        # check if the permission matches
        self.assertEqual(mperm, bperm, "Expected permission to match")

        # check that gfid xattr is present on the brick
        ret, _, _ = g.run(brickhost, ("getfattr -n trusted.gfid %s" %
                                      brickpath))
        self.assertEqual(ret, 0, "gfid is not present on file")

        # delete the file, bring down it's hash, create the file,
        ret, _, _ = g.run(self.clients[0], ("rm -f %s" % file_one))
        self.assertEqual(ret, 0, "file deletion for file1 failed")

        ret = bring_bricks_offline(self.volname, hash_subvol)
        self.assertTrue(ret, ('Error in bringing down subvolume %s',
                              hash_subvol))

        # check file creation should fail
        ret, _, _ = g.run(self.clients[0], ("touch %s" % file_one))
        self.assertTrue(ret, "Expected file creation to fail")
Exemplo n.º 5
0
    def test_directory_heal(self):
        '''
        Test directory healing.
        '''
        # pylint: disable=too-many-locals
        # pylint: disable=too-many-statements
        # pylint: disable=protected-access

        mount_obj = self.mounts[0]
        mountpoint = mount_obj.mountpoint

        # directory that needs to be created
        parent_dir = mountpoint + '/parent'
        target_dir = mountpoint + '/parent/child'

        # create parent dir
        ret, _, err = g.run(self.clients[0], ("mkdir %s" % parent_dir))
        g.log.info("mkdir of parent directory %s successful", parent_dir)
        self.assertEqual(ret, 0,
                         ('mkdir failed for %s err: %s', parent_dir, err))
        g.log.info("mkdir of parent successful")

        # find non-hashed subvol for child
        hashed, non_hashed = [], []
        hash_num = calculate_hash(self.mnode, "child")
        bricklist = get_all_bricks(self.mnode, self.volname)
        for brick in bricklist:
            ret = check_hashrange(brick + "/parent")
            hash_range_low = ret[0]
            hash_range_high = ret[1]
            if hash_range_low <= hash_num <= hash_range_high:
                hashed.append(brick)

        non_hashed = [brick for brick in bricklist if brick not in hashed]
        g.log.info("Non-hashed bricks are: %s", non_hashed)

        # bring non_hashed offline
        for brick in non_hashed:
            ret = bring_bricks_offline(self.volname, brick)
            self.assertTrue(ret, ('Error in bringing down brick %s', brick))
            g.log.info('Non-hashed brick %s is offline', brick)

        # create child directory
        runc = ("mkdir %s" % target_dir)
        ret, _, _ = g.run(self.clients[0], runc)
        self.assertEqual(ret, 0, ('failed to create dir %s' % target_dir))
        g.log.info('mkdir successful %s', target_dir)

        # Check that the dir is not created on the down brick
        for brick in non_hashed:
            non_hashed_host, dir_path = brick.split(":")
            brickpath = ("%s/parent/child" % dir_path)
            ret, _, _ = g.run(non_hashed_host, ("stat %s" % brickpath))
            self.assertEqual(ret, 1, ("Expected %s to be not present on %s" %
                                      (brickpath, non_hashed_host)))
            g.log.info("Stat of %s failed as expected", brickpath)

        # bring up the subvol
        ret = bring_bricks_online(
            self.mnode,
            self.volname,
            non_hashed,
            bring_bricks_online_methods='volume_start_force')
        self.assertTrue(ret, "Error in bringing back subvol online")
        g.log.info("Subvol is back online")

        runc = ("ls %s" % target_dir)
        ret, _, _ = g.run(self.clients[0], runc)
        self.assertEqual(ret, 0, ("Lookup on %s failed", target_dir))
        g.log.info("Lookup is successful on %s", target_dir)

        # check if the directory is created on non_hashed
        for brick in non_hashed:
            non_hashed_host, dir_path = brick.split(":")
            absolutedirpath = ("%s/parent/child" % dir_path)
            ret = get_file_stat(non_hashed_host, absolutedirpath)
            self.assertIsNotNone(ret, "Directory is not present on non_hashed")
            g.log.info("Directory is created on non_hashed subvol")

        # check if directory is healed => i.e. layout is zeroed out
        for brick in non_hashed:
            brick_path = ("%s/parent/child" % brick)
            ret = check_hashrange(brick_path)
            hash_range_low = ret[0]
            hash_range_high = ret[1]
            if not hash_range_low and not hash_range_high:
                g.log.info("Directory healing successful")
            else:
                g.log.error("Directory is not healed")