summaryrefslogtreecommitdiffstats
path: root/glustolibs-gluster/glustolibs/gluster/gluster_base_class.py
diff options
context:
space:
mode:
authorValerii Ponomarov <vponomar@redhat.com>2019-11-28 14:49:54 +0530
committerValerii Ponomarov <vponomar@redhat.com>2019-11-28 15:15:33 +0530
commit2d04a06998a4c114a8aa22cb7cd2d58d9788ec43 (patch)
tree9dbd3f0f6618be7625db8d70c7d4b4dd752ae24d /glustolibs-gluster/glustolibs/gluster/gluster_base_class.py
parent948e4b088a14315e229faab3015a97806cae990e (diff)
[py2to3] Delete 'GlusterBlockBaseClass'
For following reasons: - It is unused. - It is not compatible with py3. Signed-off-by: Valerii Ponomarov <kiparis.kh@gmail.com> Change-Id: Ied6373c398406ffd08d7673892fde89ec6e04fe2
Diffstat (limited to 'glustolibs-gluster/glustolibs/gluster/gluster_base_class.py')
-rw-r--r--glustolibs-gluster/glustolibs/gluster/gluster_base_class.py647
1 files changed, 1 insertions, 646 deletions
diff --git a/glustolibs-gluster/glustolibs/gluster/gluster_base_class.py b/glustolibs-gluster/glustolibs/gluster/gluster_base_class.py
index ae842b0..fb6792c 100644
--- a/glustolibs-gluster/glustolibs/gluster/gluster_base_class.py
+++ b/glustolibs-gluster/glustolibs/gluster/gluster_base_class.py
@@ -24,16 +24,11 @@ import os
import random
import copy
import datetime
-import time
import socket
from glusto.core import Glusto as g
-from glustolibs.gluster.exceptions import ConfigError, ExecutionError
+from glustolibs.gluster.exceptions import ConfigError
from glustolibs.gluster.peer_ops import is_peer_connected, peer_status
from glustolibs.gluster.volume_ops import set_volume_options
-from glustolibs.gluster.block_ops import block_delete
-from glustolibs.gluster.block_libs import (setup_block, if_block_exists,
- get_block_list,
- get_block_info)
from glustolibs.gluster.volume_libs import (setup_volume,
cleanup_volume,
log_volume_info_and_status)
@@ -798,643 +793,3 @@ class GlusterBaseClass(unittest.TestCase):
msg = "Teardownclass: %s : %s" % (cls.__name__, cls.glustotest_run_id)
g.log.info(msg)
cls.inject_msg_in_gluster_logs(msg)
-
-
-class GlusterBlockBaseClass(GlusterBaseClass):
- """GlusterBlockBaseClass sets up the volume and blocks.
- """
- @classmethod
- def setup_blocks(cls, blocknames):
- """Create blocks and calls the methods:
- update_block_info_dict and create_client_block_map
-
- Args:
- blocknames(list): Blocks to be create
- Returns:
- bool: False if block creation is unsuccessful and
- true if all blocks created.
-
- """
- if not isinstance(blocknames, list):
- blocknames = [blocknames]
-
- g.log.info("Creating block devices on volume %s", cls.volname)
- for blockname in blocknames:
- each_block = cls.gluster_block_args_info.get(blockname)
- if each_block:
- # Form a dict for keyargs
- block_args_info = {}
- block_args_info['ha'] = each_block['ha']
- block_args_info['auth'] = each_block['auth']
- block_args_info['prealloc'] = each_block['prealloc']
- block_args_info['storage'] = each_block['storage']
- block_args_info['ring-buffer'] = each_block['ring-buffer']
-
- _rc = setup_block(
- mnode=cls.mnode,
- volname=each_block['volname'],
- blockname=each_block['blockname'],
- servers=each_block['servers'],
- size=each_block['size'],
- **block_args_info)
- if not _rc:
- g.log.error("Failed to create block on volume "
- "%s: \n%s", cls.volname, each_block)
- return False
- g.log.info("Successfully created block on volume "
- "%s: \n%s", cls.volname, each_block)
- else:
- g.log.error("Unable to get args info for block %s on "
- "volume %s", blockname, cls.volname)
- return False
-
- # Check if all the blocks are listed in block list command
- for blockname in blocknames:
- each_block = cls.gluster_block_args_info.get(blockname)
- _rc = if_block_exists(cls.mnode, each_block['volname'], blockname)
- if not _rc:
- return False
-
- # Update the block info dict
- cls.update_block_info_dict()
- # Create client-block map
- cls.create_client_block_map(cls.blocknames)
- return True
-
- @classmethod
- def update_block_info_dict(cls):
- """Updates the class's block_info_dict variable
- Calls the gluster-block info command and updates the block info.
- """
- # Get Block dict
- cls.blocknames = get_block_list(cls.mnode, cls.volname)
-
- if cls.blocknames:
- for blockname in cls.blocknames:
- cls.block_info_dict[blockname] = (get_block_info(cls.mnode,
- cls.volname,
- blockname))
- if cls.block_info_dict[blockname] is None:
- g.log.error("Could not get block info")
- return False
- # Update total_number_of_blocks
- cls.total_num_of_blocks = len(cls.blocknames)
-
- # Log the block_info_dict
- g.log.info("Logging Block Info:")
- for key, value in cls.block_info_dict.items():
- g.log.info("Glusto block info: %s\n %s" % (key, value))
-
- return True
-
- @classmethod
- def discover_blocks_on_clients(cls, blocknames):
- """Discover blocks on all the clients
- """
- # List all the block devices on clients (Logging)
-
- if not isinstance(blocknames, list):
- blocknames = [blocknames]
-
- # results = g.run_parallel(cls.clients, "lsblk -S")
- server_list = []
- for blockname in blocknames:
- block_info = get_block_info(cls.mnode, cls.volname, blockname)
- if block_info:
- servers_to_add = block_info.get("EXPORTED ON")
- for server_ip in servers_to_add:
- if server_ip not in server_list:
- server_list.append(server_ip)
- else:
- g.log.error("Failed to get block info for block %s"
- " on volume %s", blockname, cls.volname)
- return False
-
- g.log.info("Server list %s", server_list)
- # Discover the block devices from clients
- for client in cls.clients:
- for server in server_list:
- cmd = ("iscsiadm -m discovery -t st -p %s" %
- server)
- ret, out, err = g.run(client, cmd)
- if ret != 0:
- g.log.error("Failed to discover blocks on "
- "client %s: %s", client, err)
- return False
- g.log.info("Discovered blocks on client %s: %s",
- client, out)
- return True
-
- @classmethod
- def get_iqn_of_blocks_on_clients(cls, blocknames):
- """Get iqn number of each block on it's respective client.
-
- Args:
- blocknames: list
- Returns:
- bool: True if iqn of all blocks is obtained. False otherwise
- """
- if not isinstance(blocknames, list):
- blocknames = [blocknames]
- for blockname in blocknames:
-
- try:
- block_gbid = cls.block_info_dict[blockname]['GBID']
- except KeyError:
- g.log.error("Failed to get GBID of block %s on volume %s",
- blockname, cls.volname)
- return False
-
- try:
- block_mapped_client = (
- cls.clients_blocks_map[blockname]['client'])
- except KeyError:
- g.log.error("Failed to get the client which mounts the block "
- "%s on the volume %s", blockname, cls.volname)
- return False
-
- # Get the servers where the blocks are exported
- server_ip = cls.block_info_dict[blockname]['EXPORTED ON'][0]
-
- # Get iqn from gbid
- cmd = ("iscsiadm -m discovery -t st -p %s | grep -F %s | "
- "tail -1 | cut -d ' ' -f2" %
- (server_ip, block_gbid))
-
- # Not using async here as if two processes execute the above
- # command at the same time in background, it will cause:
- # 'iscsiadm: Connection to Discovery Address' error
- ret, out, err = g.run(block_mapped_client, cmd)
- if ret != 0:
- g.log.error("Failed to get iqn of block %s on client %s: %s",
- block_gbid, block_mapped_client, err)
- return False
- g.log.info("Iqn for gbid '%s' on client %s : '%s'",
- block_gbid, block_mapped_client, out)
- block_iqn = out.strip()
- cls.clients_blocks_map[blockname]['iqn'] = block_iqn
-
- return True
-
- @classmethod
- def login_to_iqn_on_clients(cls, blocknames):
- """Login the blocks on their clients/initiator.
-
- Return:
- Either bool or Execution error.
- """
- if not isinstance(blocknames, list):
- blocknames = [blocknames]
-
- ret = cls.update_block_info_dict()
- if not ret:
- return False
-
- result = cls.get_iqn_of_blocks_on_clients(blocknames)
- if not result:
- return False
-
- # ret_value = True
- # Login to the block from the client
- for blockname in blocknames:
- block_gbid = cls.block_info_dict[blockname]['GBID']
- block_mapped_client = (
- cls.clients_blocks_map[blockname]['client'])
-
- if not cls.clients_blocks_map[blockname].get('iqn'):
- g.log.error("Iqn info for block %s not there. So can't login",
- blockname)
- return False
-
- block_iqn = cls.clients_blocks_map[blockname]['iqn']
- cls.clients_blocks_map[blockname]['logged_in'] = False
-
- if cls.block_info_dict[blockname]['PASSWORD']:
- block_password = cls.block_info_dict[blockname]['PASSWORD']
- cmd = ("iscsiadm -m node -T %s -o update -n "
- "node.session.auth.authmethod -v CHAP -n "
- "node.session.auth.username -v %s -n "
- "node.session.auth.password -v %s " %
- (block_iqn, block_gbid, block_password))
- ret, out, err = g.run(block_mapped_client, cmd)
- if ret != 0:
- g.log.error("Unable to update login credentials for "
- "iqn %s on %s: %s",
- block_iqn, block_mapped_client, err)
- return False
- g.log.info("Credentials for iqn %s updated successfully "
- "on %s",
- block_iqn, block_mapped_client)
-
- # Login to iqn
- if not cls.clients_blocks_map[blockname].get('logged_in'):
- cmd = "iscsiadm -m node -T %s -l" % block_iqn
- ret, out, err = g.run(block_mapped_client, cmd)
- if ret != 0:
- raise ExecutionError("Failed to login to iqn %s on "
- "%s: %s Command o/p: %s ",
- block_iqn, block_mapped_client,
- err, out)
-
- g.log.info("Successfully logged in to iqn %s on %s: %s",
- block_iqn, block_mapped_client, out)
- cls.clients_blocks_map[blockname]['logged_in'] = True
-
- return True
-
- @classmethod
- def logout_iqn_on_clients(cls, blocknames):
- """Logout each block from the initiator
- """
- # Convert string or unicode type to list
- if not isinstance(blocknames, list):
- blocknames = [blocknames]
-
- for blockname in blocknames:
- block_mapped_client = (
- cls.clients_blocks_map[blockname]['client'])
- block_iqn = cls.clients_blocks_map[blockname]['iqn']
- cmd = "iscsiadm -m node -T %s -u" % block_iqn
- ret, out, err = g.run(block_mapped_client, cmd)
- if ret != 0:
- g.log.error("Failed to logout of iqn %s on %s: %s"
- " Command o/p: %s",
- block_iqn, block_mapped_client, err, out)
- return False
- g.log.info("Successfully logged out of iqn %s on %s: %s",
- block_iqn, block_mapped_client, out)
-
- return True
-
- @classmethod
- def get_mpath_of_iqn_on_clients(cls, blocknames):
- """Get mpath of the logged in blocks
-
- Return:
- True if successful and execution error if getting mpath fails.
- """
- # Get the mpath for iqn
- # Donot forget to install 'sg3_utils'
- # Convert string or unicode type to list
- if not isinstance(blocknames, list):
- blocknames = [blocknames]
-
- for blockname in blocknames:
- block_gbid = cls.block_info_dict[blockname]['GBID']
- block_mapped_client = cls.clients_blocks_map[blockname]['client']
- block_iqn = cls.clients_blocks_map[blockname]['iqn']
- if not cls.clients_blocks_map[blockname].get('mpath'):
- cmd = ("for i in `/dev/mapper/mpath*` ; do "
- "sg_inq -i $i | grep %s > /dev/null ; "
- "if [[ $? -eq 0 ]] ; then echo $i ; fi ; done" %
- (block_gbid))
- ret, out, err = g.run(block_mapped_client, cmd)
- if ret != 0:
- raise ExecutionError("Failed to get mpath for iqn %s on "
- "client %s: %s", block_iqn,
- block_mapped_client, err)
- block_mpath = out.strip()
- g.log.info("Successfully got mpath '%s' for iqn '%s' on "
- "client %s", block_mpath, block_iqn,
- block_mapped_client)
- cls.clients_blocks_map[blockname]['mpath'] = block_mpath
- time.sleep(1)
-
- return True
-
- @classmethod
- def create_client_block_map(cls, blocknames):
- """
- Mapping a single block to a client.
- Select a client randomly from the list
- """
- if not isinstance(blocknames, list):
- blocknames = [blocknames]
-
- tmp_client_list = cls.clients[:]
- for blockname in blocknames:
- if blockname not in cls.clients_blocks_map:
- if len(tmp_client_list) == 0:
- tmp_client_list = cls.clients[:]
- client_to_map = random.choice(tmp_client_list)
- tmp_client_list.remove(client_to_map)
- cls.clients_blocks_map[blockname] = {
- 'client': client_to_map,
- 'iqn': '',
- 'logged_in': False,
- 'mpath': '',
- 'is_formatted': False,
- 'is_mounted': False,
- }
- g.log.info("Blocks mapped to clients. Each block is mapped to a "
- "randomly selected client")
- for blockname in blocknames:
- g.log.info("Block %s mapped to %s", blockname,
- cls.clients_blocks_map[blockname]['client'])
-
- @classmethod
- def mount_blocks(cls, blocknames, filesystem='xfs'):
- """Mount the blocks on their clients
- """
- if not isinstance(blocknames, list):
- blocknames = [blocknames]
- # Discover the block on client
- ret = cls.discover_blocks_on_clients(blocknames)
- if not ret:
- return False
-
- for blockname in blocknames:
- if not cls.clients_blocks_map[blockname]['logged_in']:
-
- # Login inside the block on client
- ret = cls.login_to_iqn_on_clients(blockname)
- if not ret:
- return False
-
- # time.sleep added because the path /dev/mapper/mapth*
- # is getting read even before the logging is completed.
- time.sleep(2)
- # Get mpath of block on it's client
- ret = cls.get_mpath_of_iqn_on_clients(blockname)
- if not ret:
- return False
-
- # make fs
- block_mpath = cls.clients_blocks_map[blockname]['mpath']
- block_mapped_client = cls.clients_blocks_map[blockname]['client']
- if not cls.clients_blocks_map[blockname].get('is_formatted'):
- cmd = "mkfs.%s -f %s" % (filesystem, block_mpath)
- ret, out, err = g.run(block_mapped_client, cmd)
- if ret != 0:
- raise ExecutionError("Failed to make fs on %s on client "
- "%s: %s", block_mpath,
- block_mapped_client, err)
- g.log.info("Successfully created fs on %s on client %s: %s",
- block_mpath, block_mapped_client, out)
- cls.clients_blocks_map[blockname]['is_formatted'] = True
-
- # mount the block
- if not cls.clients_blocks_map[blockname].get('is_mounted'):
- temp_mount = {
- 'protocol': 'xfs',
- 'client': {
- 'host': cls.clients_blocks_map[blockname]['client'],
- },
- 'volname': cls.clients_blocks_map[blockname]['mpath'],
- 'mountpoint': "/mnt/%s" % blockname
- }
- mount_obj = create_mount_objs([temp_mount]).pop()
-
- g.log.info("Mount Obj %s", mount_obj)
- g.log.info("Mounting the device %s on %s:%s" %
- (mount_obj.volname, mount_obj.client_system,
- mount_obj.mountpoint))
-
- # The function is_mounted will give an error in log file:
- # "Missing arguments for mount"
- # Because this is also used for mounting glusterfs volumes and
- # a server name is needed But here mounting does not
- # require a server name and therefore the argument check
- # for server fails and an error is reported in the log file.
- # But that will not affect the block mounting.
- # So, we can live with it for now.
- ret = mount_obj.mount()
- if not ret:
- raise ExecutionError("Unable to mount the "
- "device %s on %s:%s" %
- (mount_obj.volname,
- mount_obj.client_system,
- mount_obj.mountpoint))
- g.log.info("Successfully mounted the device %s on %s:%s" %
- (mount_obj.volname, mount_obj.client_system,
- mount_obj.mountpoint))
- cls.mount_blocks_list.append(mount_obj)
- cls.clients_blocks_map[blockname]['is_mounted'] = True
-
- return True
-
- @classmethod
- def setup_block_mount_block(cls, blocknames):
- """Create and mount the blocks
- """
- # Setup block
- g.log.info("Setting up blocks")
- ret = cls.setup_blocks(blocknames)
- if not ret:
- raise ExecutionError("Failed to setup blocks")
- g.log.info("Successful in setting up blocks")
-
- # Mount Blocks
- g.log.info("Mounting the blocks on initiator nodes")
- ret = cls.mount_blocks(blocknames)
- if not ret:
- raise ExecutionError("Failed to mount the blocks of volume %s",
- cls.volname)
- g.log.info("Successful in mounting the blocks of the volume %s",
- cls.volname)
-
- return True
-
- @classmethod
- def get_block_args_info_from_config(cls):
- """Created the dict gluster_block_args_info which helps in
- providing block information during block creation
- """
- # Get gluster block info from config file
- if g.config.get('gluster_block_args_info'):
- cls.gluster_block_args_info = {}
- blocks_count = 0
- each_block_info = g.config['gluster_block_args_info']
- # for i, each_block_info in enumerate(
- # g.config['gluster_block_args_info']):
- # volname
- block_on_volume = cls.volname
- if each_block_info.get('volname'):
- block_on_volume = each_block_info['volname']
-
- # Block name
- block_base_name = "gluster_block"
- if each_block_info.get('blockname'):
- block_base_name = each_block_info['blockname']
-
- # servers
- block_servers = cls.servers
- if each_block_info.get('servers'):
- block_servers = each_block_info['servers']
- if not filter(None, block_servers):
- block_servers = cls.servers
-
- # Block size
- block_size = "1GiB"
- if each_block_info.get('size'):
- block_size = each_block_info['size']
-
- # HA
- block_ha = 3
- if each_block_info.get('ha'):
- block_ha = each_block_info['ha']
-
- # auth
- block_auth = None
- if each_block_info.get('auth'):
- block_auth = each_block_info['auth']
-
- # prealloc
- block_prealloc = None
- if each_block_info.get('prealloc'):
- block_prealloc = each_block_info['prealloc']
-
- # ring-buffer
- block_ring_buffer = None
- if each_block_info.get('ring-buffer'):
- block_ring_buffer = each_block_info['ring-buffer']
-
- # Number of blocks
- num_of_blocks = 1
- if each_block_info.get('num_of_blocks'):
- num_of_blocks = int(each_block_info['num_of_blocks'])
-
- # for count in range(blocks_count,num_of_blocks +blocks_count):
- for count in range(blocks_count, num_of_blocks):
- # blocks_count = int(count) + i
-
- if block_ha:
- selected_block_servers = random.sample(block_servers,
- block_ha)
- else:
- selected_block_servers = random.choice(block_servers)
-
- block_name = "_".join([block_base_name,
- str(count + 1)])
-
- cls.gluster_block_args_info[block_name] = (
- {'volname': block_on_volume,
- 'blockname': block_name,
- 'servers': cls.get_ip_from_hostname(
- selected_block_servers),
- 'size': block_size,
- 'ha': block_ha,
- 'auth': block_auth,
- 'prealloc': block_prealloc,
- 'storage': None,
- 'ring-buffer': block_ring_buffer}
- )
-
- for key in cls.gluster_block_args_info.keys():
- value = cls.gluster_block_args_info[key]
- g.log.info("Gluster-Block args info: %s\n %s" % (key, value))
-
- @classmethod
- def setUpClass(cls, setup_vol=True, setup_blk=True, mount_blk=True):
- """Setup volume, create blocks, mount the blocks if specified.
- """
- GlusterBaseClass.setUpClass.im_func(cls)
-
- cls.mount_blocks_list = []
- cls.total_num_of_blocks = 0
- cls.block_info_dict = {}
- cls.clients_blocks_map = {}
- cls.blocknames = []
-
- # Default gluster block info
- cls.gluster_block_args_info = {
- 'gluster_block_%d' % (cls.total_num_of_blocks + 1): {
- 'volname': cls.volname,
- 'blockname': 'gluster_block_%d'
- % (cls.total_num_of_blocks + 1),
- 'servers': random.sample(cls.servers_ips, 2),
- 'size': '1GiB',
- 'ha': 2,
- 'auth': None,
- 'prealloc': None,
- 'storage': None,
- 'ring-buffer': None
- }
- }
-
- if g.config.get('gluster_block_args_info'):
- cls.get_block_args_info_from_config()
-
- @classmethod
- def tearDownClass(cls, umount_blocks=True, cleanup_blocks=True,
- cleanup_vol=True, unlink_storage="yes"):
- """Teardown the mounts, deletes blocks, gluster volume.
- """
- # Unmount volume
- if umount_blocks:
- _rc = True
- g.log.info("Starting to UnMount Blocks")
- for mount_obj in cls.mount_blocks_list:
- ret = mount_obj.unmount()
- if not ret:
- g.log.error("Unable to unmount block '%s on cleint %s "
- "at %s'",
- mount_obj.volname, mount_obj.client_system,
- mount_obj.mountpoint)
- _rc = False
- if not _rc:
- raise ExecutionError("Unmount of all mounts are not "
- "successful")
- else:
- g.log.info("Successful in unmounting volume on all clients")
- else:
- g.log.info("Not Unmounting the Volume as 'umount_vol' is set "
- "to %s", umount_blocks)
-
- # Logout the blocks
- for blockname in cls.clients_blocks_map:
- block_iqn = cls.clients_blocks_map[blockname]['iqn']
- block_mapped_client = (
- cls.clients_blocks_map[blockname]['client'])
- g.log.info("Logging out iqn %s on client %s", block_iqn,
- block_mapped_client)
- cmd = "iscsiadm -m node -T %s -u" % block_iqn
- ret, out, err = g.run(block_mapped_client, cmd)
- if ret != 0:
- raise ExecutionError("Failed to logout iqn %s on client %s "
- ":%s", block_iqn, block_mapped_client,
- err)
- g.log.info("Successfully logged out iqn %s on client %s: %s",
- block_iqn, block_mapped_client, out)
-
- # Restarting multipathd on all clients
- g.log.info("Restarting multipathd on all clients")
- cmd = "service multipathd restart && service multipathd status"
- results = g.run_parallel(cls.clients, cmd)
- for client in results:
- ret, out, err = results[client]
- if ret != 0:
- raise ExecutionError("Failed to restart multipathd on "
- "client %s: %s", client, err)
- g.log.info("Successfully restarted multipathd on client %s: %s",
- client, out)
-
- # Cleanup blocks
- if cleanup_blocks:
- blocknames = get_block_list(cls.mnode, cls.volname)
- if blocknames:
- g.log.info("Listing blocks before deleting:\n%s",
- '\n'.join(blocknames))
- for blockname in blocknames:
- ret, out, err = block_delete(cls.mnode, cls.volname,
- blockname, unlink_storage)
- if ret != 0:
- raise ExecutionError("Failed to delete the block "
- "%s on volume %s", blockname,
- cls.volname)
- g.log.info("Successfully deleted the block %s on "
- "volume %s", blockname, cls.volname)
-
- # Cleanup volume
- if cleanup_vol:
- g.log.info("Cleanup Volume %s", cls.volname)
- ret = cleanup_volume(mnode=cls.mnode, volname=cls.volname)
- if not ret:
- raise ExecutionError("cleanup volume %s failed", cls.volname)
- else:
- g.log.info("Successfully cleaned-up volume")
- else:
- g.log.info("Not Cleaning-Up volume as 'cleanup_vol' is %s",
- cleanup_vol)
-
- GlusterBaseClass.tearDownClass.im_func(cls)