def hello_heketi(heketi_client_node, heketi_server_url, **kwargs):
"""Executes curl command to check if heketi server is alive.
Args:
heketi_client_node (str): Node on which cmd has to be executed.
heketi_server_url (str): Heketi server url
Kwargs:
The keys, values in kwargs are:
- secret : (str)|None
- user : (str)|None
Returns:
bool: True, if heketi server is alive
Raises:
exceptions.ExecutionError: if command fails.
Example:
hello_heketi(heketi_client_node, heketi_server_url)
"""
heketi_server_url, json_arg, admin_key, user = _set_heketi_global_flags(
heketi_server_url, **kwargs)
cmd = "curl %s/hello" % heketi_server_url
ret, out, err = g.run(heketi_client_node, cmd)
if ret != 0:
msg = (
"Failed to execute '%s' command on '%s' node with following "
"error: %s" % (cmd, heketi_client_node, err))
g.log.error(msg)
raise exceptions.ExecutionError(msg)
return True
def heketi_node_list(heketi_client_node, heketi_server_url,
heketi_user=None, heketi_secret=None):
"""Execute CLI 'heketi node list' command and parse its output.
Args:
heketi_client_node (str): Node on which cmd has to be executed
heketi_server_url (str): Heketi server url to perform request to
heketi_user (str): Name of the user to perform request with
heketi_secret (str): Secret for 'heketi_user'
Returns:
list of strings which are node IDs
Raises: cnslibs.common.exceptions.ExecutionError when CLI command fails.
"""
heketi_server_url, json_arg, admin_key, user = _set_heketi_global_flags(
heketi_server_url, user=heketi_user, secret=heketi_secret)
cmd = "heketi-cli -s %s node list %s %s %s" % (
heketi_server_url, json_arg, admin_key, user)
ret, out, err = g.run(heketi_client_node, cmd)
if ret != 0:
msg = (
"Failed to execute '%s' command on '%s' node with following "
"error: %s" % (cmd, heketi_client_node, err))
g.log.error(msg)
raise exceptions.ExecutionError(msg)
heketi_node_id_list = []
for line in out.strip().split("\n"):
# Line looks like this: 'Id:nodeIdString\tCluster:clusterIdString'
heketi_node_id_list.append(
line.strip().split("Cluster")[0].strip().split(":")[1])
return heketi_node_id_list
def get_heketi_metrics(heketi_client_node, heketi_server_url,
prometheus_format=False):
"""Execute curl command to get metrics output.
Args:
- heketi_client_node (str) : Node where we want to run our commands.
- heketi_server_url (str) : This is a heketi server url.
- prometheus_format (bool) : control the format of output
by default it is False, So it will parse prometheus format into
python dict. If we need prometheus format we have to set it True.
Raises:
exceptions.ExecutionError: if command fails.
Returns:
Metrics output: if successful
"""
cmd = "curl %s/metrics" % heketi_server_url
ret, out, err = g.run(heketi_client_node, cmd)
if ret != 0:
msg = "failed to get Heketi metrics with following error: %s" % err
g.log.error(msg)
raise exceptions.ExecutionError(msg)
if prometheus_format:
return out.strip()
return parse_prometheus_data(out)
def _get_heketi_client_version_str(hostname=None):
"""Gets Heketi client package version from heketi client node.
Args:
hostname (str): Node on which the version check command should run.
Returns:
str : heketi version, i.e. '7.0.0-1'
Raises: 'exceptions.ExecutionError' if failed to get version
"""
if not hostname:
openshift_config = g.config.get("cns", g.config.get("openshift"))
heketi_config = openshift_config['heketi_config']
hostname = heketi_config['heketi_client_node'].strip()
cmd = ("rpm -q heketi-client --queryformat '%{version}-%{release}\n' | "
"cut -d '.' -f 1,2,3")
ret, out, err = g.run(hostname, cmd, "root")
if ret != 0:
msg = ("Failed to get heketi client version. "
"\n'err': %s\n 'out': %s" % (err, out))
g.log.error(msg)
raise AssertionError(msg)
out = out.strip()
if not out:
error_msg = "Empty output for '%s' cmd: '%s'" % (cmd, out)
g.log.error(error_msg)
raise exceptions.ExecutionError(error_msg)
return out
def heketi_volume_expand(heketi_client_node, heketi_server_url, volume_id,
expand_size, raw_cli_output=False, **kwargs):
"""Executes heketi volume expand command.
Args:
heketi_client_node (str): Node on which cmd has to be executed.
heketi_server_url (str): Heketi server url
volume_id (str): Volume ID
expand_size (str): volume expand size
Kwargs:
The keys, values in kwargs are:
- json : (bool)
- secret : (str)|None
- user : (str)|None
Returns:
dict: volume expand info on success, only cli option is specified
without --json option, then it returns raw string output.
Tuple (ret, out, err): if raw_cli_output is True
Raises:
exceptions.ExecutionError: if command fails.
Example:
heketi_volume_expand(heketi_client_node, heketi_server_url, volume_id,
expand_size)
"""
heketi_server_url, json_arg, admin_key, user = _set_heketi_global_flags(
heketi_server_url, **kwargs)
cmd = ("heketi-cli -s %s volume expand --volume=%s "
"--expand-size=%s %s %s %s" % (
heketi_server_url, volume_id, expand_size, json_arg,
admin_key, user))
ret, out, err = g.run(heketi_client_node, cmd)
if raw_cli_output:
return ret, out, err
if ret != 0:
msg = (
"Failed to execute '%s' command on '%s' node with following "
"error: %s" % (cmd, heketi_client_node, err))
g.log.error(msg)
raise exceptions.ExecutionError(msg)
if json_arg:
return json.loads(out)
return out
def _get_gluster_pod(gluster_pod, hostname=None):
"""create glusto.podcmd object if gluster_pod is string and
hostname is given else returns gluster_pod object given
Args:
gluster_pod (podcmd | str): gluster pod class object has gluster
pod and ocp master node or gluster
pod name
hostname (str): master node on which gluster pod exists
"""
if isinstance(gluster_pod, podcmd.Pod):
return gluster_pod
elif isinstance(gluster_pod, six.string_types):
if hostname:
return podcmd.Pod(hostname, gluster_pod)
else:
raise exceptions.ExecutionError(
"gluster pod is string '%s' but hostname '%s' not valid" %
(gluster_pod, hostname))
else:
raise exceptions.ExecutionError(
"invalid gluster pod parameter '%s', '%s'" %
(gluster_pod, type(gluster_pod)))
def heketi_device_info(heketi_client_node, heketi_server_url, device_id,
raw_cli_output=False, **kwargs):
"""Executes heketi device info command.
Args:
heketi_client_node (str): Node on which cmd has to be executed.
heketi_server_url (str): Heketi server url
device_id (str): Device ID
Kwargs:
The keys, values in kwargs are:
- json : (bool)
- secret : (str)|None
- user : (str)|None
Returns:
Str: device info as raw CLI output if "json" arg is not provided.
Dict: device info parsed to dict if "json" arg is provided.
Tuple (ret, out, err): if raw_cli_output is True
Raises:
exceptions.ExecutionError: if command fails.
Example:
heketi_device_info(heketi_client_node, heketi_server_url, device_id)
"""
heketi_server_url, json_arg, admin_key, user = _set_heketi_global_flags(
heketi_server_url, **kwargs)
cmd = "heketi-cli -s %s device info %s %s %s %s" % (
heketi_server_url, device_id, json_arg, admin_key, user)
ret, out, err = g.run(heketi_client_node, cmd)
if raw_cli_output:
return ret, out, err
if ret != 0:
msg = (
"Failed to execute '%s' command on '%s' node with following "
"error: %s" % (cmd, heketi_client_node, err))
g.log.error(msg)
raise exceptions.ExecutionError(msg)
if json_arg:
device_info = json.loads(out)
return device_info
else:
return out
def heketi_volume_info(heketi_client_node, heketi_server_url, volume_id,
raw_cli_output=False, **kwargs):
"""Executes heketi volume info command.
Args:
heketi_client_node (str): Node on which cmd has to be executed.
heketi_server_url (str): Heketi server url
volume_id (str): Volume ID
Kwargs:
The keys, values in kwargs are:
- json : (bool)
- secret : (str)|None
- user : (str)|None
Returns:
dict: volume info on success
False: in case of failure
Tuple (ret, out, err): if raw_cli_output is True
Raises:
exceptions.ExecutionError: if command fails.
Example:
heketi_volume_info(heketi_client_node, volume_id)
"""
heketi_server_url, json_arg, admin_key, user = _set_heketi_global_flags(
heketi_server_url, **kwargs)
cmd = "heketi-cli -s %s volume info %s %s %s %s" % (
heketi_server_url, volume_id, json_arg, admin_key, user)
ret, out, err = g.run(heketi_client_node, cmd)
if raw_cli_output:
return ret, out, err
if ret != 0:
msg = (
"Failed to execute '%s' command on '%s' node with following "
"error: %s" % (cmd, heketi_client_node, err))
g.log.error(msg)
raise exceptions.ExecutionError(msg)
if json_arg:
return json.loads(out)
return out
def set_tags(heketi_client_node, heketi_server_url, source, source_id, tag,
**kwargs):
"""Set any tags on Heketi node or device.
Args:
- heketi_client_node (str) : Node where we want to run our commands.
eg. "10.70.47.64"
- heketi_server_url (str) : This is a heketi server url
eg. "http://172.30.147.142:8080
- source (str) : This var is for node or device whether we
want to set tag on node or device.
Allowed values are "node" and "device".
- sorrce_id (str) : ID of node or device.
eg. "4f9c0249834919dd372e8fb3344cd7bd"
- tag (str) : This is a tag which we want to set
eg. "arbiter:required"
Kwargs:
user (str) : username
secret (str) : secret for that user
Returns:
True : if successful
Raises:
ValueError : when improper input data are provided.
exceptions.ExecutionError : when command fails.
"""
if source not in ('node', 'device'):
msg = ("Incorrect value we can use 'node' or 'device' instead of %s."
% source)
g.log.error(msg)
raise ValueError(msg)
heketi_server_url, json_args, secret, user = _set_heketi_global_flags(
heketi_server_url, **kwargs)
cmd = ("heketi-cli -s %s %s settags %s %s %s %s" %
(heketi_server_url, source, source_id, tag, user, secret))
ret, out, err = g.run(heketi_client_node, cmd)
if not ret:
g.log.info("Tagging of %s to %s is successful" % (source, tag))
return True
g.log.error(err)
raise exceptions.ExecutionError(err)
def heketi_volume_delete(heketi_client_node, heketi_server_url, volume_id,
raw_cli_output=False, raise_on_error=True, **kwargs):
"""Executes heketi volume delete command.
Args:
heketi_client_node (str): Node on which cmd has to be executed.
heketi_server_url (str): Heketi server url
volume_id (str): Volume ID
raise_on_error (bool): whether or not to raise exception
in case of an error.
Kwargs:
The keys, values in kwargs are:
- json : (bool)
- secret : (str)|None
- user : (str)|None
Returns:
str: volume delete command output on success
Tuple (ret, out, err): if raw_cli_output is True
Raises:
exceptions.ExecutionError when error occurs and raw_cli_output is False
Example:
heketi_volume_delete(heketi_client_node, heketi_server_url, volume_id)
"""
heketi_server_url, json_arg, admin_key, user = _set_heketi_global_flags(
heketi_server_url, **kwargs)
err_msg = "Failed to delete '%s' volume. " % volume_id
cmd = "heketi-cli -s %s volume delete %s %s %s %s" % (
heketi_server_url, volume_id, json_arg, admin_key, user)
ret, out, err = g.run(heketi_client_node, cmd)
if raw_cli_output:
return ret, out, err
if ret != 0:
err_msg += "Out: %s, \nErr: %s" % (out, err)
g.log.error(err_msg)
if raise_on_error:
raise exceptions.ExecutionError(err_msg)
return out
def heketi_device_add(heketi_client_node, heketi_server_url, device_name,
node_id, raw_cli_output=False, **kwargs):
"""Executes heketi device add command.
Args:
heketi_client_node (str): Node on which cmd has to be executed.
heketi_server_url (str): Heketi server url
device name (str): Device name to add
node_id (str): Node id to add the device
Kwargs:
The keys, values in kwargs are:
- json : (bool)
- secret : (str)|None
- user : (str)|None
Returns:
str: heketi device add command output on success.
Tuple (ret, out, err): if raw_cli_output is True
Raises:
exceptions.ExecutionError: if command fails.
Example:
heketi_device_add(heketi_client_node, heketi_server_url, device_name,
node_id)
"""
heketi_server_url, json_arg, admin_key, user = _set_heketi_global_flags(
heketi_server_url, **kwargs)
cmd = "heketi-cli -s %s device add --name=%s --node=%s %s %s %s" % (
heketi_server_url, device_name, node_id, json_arg, admin_key, user)
ret, out, err = g.run(heketi_client_node, cmd)
if raw_cli_output:
return ret, out, err
if ret != 0:
msg = (
"Failed to execute '%s' command on '%s' node with following "
"error: %s" % (cmd, heketi_client_node, err))
g.log.error(msg)
raise exceptions.ExecutionError(msg)
return out
def heketi_topology_info(heketi_client_node, heketi_server_url,
raw_cli_output=False, **kwargs):
"""Executes heketi topology info command.
Args:
heketi_client_node (str): Node on which cmd has to be executed.
heketi_server_url (str): Heketi server url
Kwargs:
The keys, values in kwargs are:
- json : (bool)
- secret : (str)|None
- user : (str)|None
Returns:
dict: topology info if --json option is specified. If only cli option
is specified, raw command output is returned on success.
Tuple (ret, out, err): if raw_cli_output is True
Raises:
exceptions.ExecutionError: if command fails.
Example:
heketi_topology_info(heketi_client_node, heketi_server_url)
"""
heketi_server_url, json_arg, admin_key, user = _set_heketi_global_flags(
heketi_server_url, **kwargs)
cmd = "heketi-cli -s %s topology info %s %s %s" % (
heketi_server_url, json_arg, admin_key, user)
ret, out, err = g.run(heketi_client_node, cmd)
if raw_cli_output:
return ret, out, err
if ret != 0:
msg = (
"Failed to execute '%s' command on '%s' node with following "
"error: %s" % (cmd, heketi_client_node, err))
g.log.error(msg)
raise exceptions.ExecutionError(msg)
if json_arg:
return json.loads(out)
return out
def heketi_blockvolume_info(heketi_client_node, heketi_server_url,
block_volume_id, **kwargs):
"""Executes heketi blockvolume info command.
Args:
heketi_client_node (str): Node on which cmd has to be executed.
heketi_server_url (str): Heketi server url
block_volume_id (str): block volume ID
Kwargs:
The keys, values in kwargs are:
- json : (bool)
- secret : (str)|None
- user : (str)|None
Returns:
dict: block volume info on success.
str: raw output if 'json' arg is not provided.
Raises:
exceptions.ExecutionError: if command fails.
Example:
heketi_blockvolume_info(heketi_client_node, block_volume_id)
"""
heketi_server_url, json_arg, admin_key, user = _set_heketi_global_flags(
heketi_server_url, **kwargs)
cmd = "heketi-cli -s %s blockvolume info %s %s %s %s" % (
heketi_server_url, block_volume_id, json_arg, admin_key, user)
ret, out, err = g.run(heketi_client_node, cmd)
if ret != 0:
msg = (
"Failed to execute '%s' command on '%s' node with following "
"error: %s" % (cmd, heketi_client_node, err))
g.log.error(msg)
raise exceptions.ExecutionError(msg)
if json_arg:
return json.loads(out)
return out
def heketi_blockvolume_list(heketi_client_node, heketi_server_url, **kwargs):
"""Executes heketi blockvolume list command.
Args:
heketi_client_node (str): Node on which cmd has to be executed.
heketi_server_url (str): Heketi server url
Kwargs:
The keys, values in kwargs are:
- json : (bool)
- secret : (str)|None
- user : (str)|None
Returns:
dict: volume list with --json on success, if cli option is specified
without --json option or with url, it returns raw string output.
False otherwise
Raises:
exceptions.ExecutionError: if command fails.
Example:
heketi_volume_info(heketi_client_node, heketi_server_url)
"""
heketi_server_url, json_arg, admin_key, user = _set_heketi_global_flags(
heketi_server_url, **kwargs)
cmd = "heketi-cli -s %s blockvolume list %s %s %s" % (
heketi_server_url, json_arg, admin_key, user)
ret, out, err = g.run(heketi_client_node, cmd)
if ret != 0:
msg = (
"Failed to execute '%s' command on '%s' node with following "
"error: %s" % (cmd, heketi_client_node, err))
g.log.error(msg)
raise exceptions.ExecutionError(msg)
if json_arg:
return json.loads(out)
return out
def _get_heketi_server_version_str(ocp_client_node=None):
"""Gets Heketi server package version from Heketi POD.
Args:
ocp_client_node (str): Node on which the version check command should
run.
Returns:
str : heketi version, i.e. '7.0.0-1'
Raises: 'exceptions.ExecutionError' if failed to get version
"""
if not ocp_client_node:
ocp_client_node = g.config["ocp_servers"]["client"].keys()[0]
get_package_version_cmd = (
"rpm -q heketi --queryformat '%{version}-%{release}\n' | "
"cut -d '.' -f 1,2,3")
# NOTE(vponomar): we implement Heketi POD call command here, not in common
# module for OC commands just to avoid cross-reference imports.
get_pods_cmd = "oc get -o wide --no-headers=true pods --selector heketi"
heketi_pods = command.cmd_run(get_pods_cmd, hostname=ocp_client_node)
err_msg = ""
for heketi_pod_line in heketi_pods.split("\n"):
heketi_pod_data = heketi_pod_line.split()
if ("-deploy" in heketi_pod_data[0]
or heketi_pod_data[1].lower() != "1/1"
or heketi_pod_data[2].lower() != "running"):
continue
try:
pod_cmd = "oc exec %s -- %s" % (heketi_pod_data[0],
get_package_version_cmd)
return command.cmd_run(pod_cmd, hostname=ocp_client_node)
except Exception as e:
err = ("Failed to run '%s' command on '%s' Heketi POD. "
"Error: %s\n" % (pod_cmd, heketi_pod_data[0], e))
err_msg += err
g.log.error(err)
if not err_msg:
err_msg += "Haven't found 'Running' and 'ready' (1/1) Heketi PODs.\n"
err_msg += "Heketi PODs: %s" % heketi_pods
raise exceptions.ExecutionError(err_msg)
def verify_volume_name_prefix(hostname, prefix, namespace, pvc_name,
heketi_server_url, **kwargs):
"""Checks whether heketi voluem is present with volname prefix or not.
Args:
hostname (str): hostname on which we want
to check the heketi vol
prefix (str): volnameprefix given in storageclass
namespace (str): namespace
pvc_name (str): name of the pvc
heketi_server_url (str): Heketi server url
Kwargs:
The keys, values in kwargs are:
- json : (bool)
- secret : (str)|None
- user : (str)|None
Returns:
bool: True if volume found.
Raises:
exceptions.ExecutionError: if command fails.
"""
heketi_server_url, json_arg, admin_key, user = _set_heketi_global_flags(
heketi_server_url, **kwargs)
heketi_vol_name_prefix = "%s_%s_%s_" % (prefix, namespace, pvc_name)
cmd = "heketi-cli -s %s volume list %s %s %s | grep %s" % (
heketi_server_url, json_arg, admin_key, user, heketi_vol_name_prefix)
ret, out, err = g.run(hostname, cmd, "root")
if ret != 0:
msg = (
"Failed to execute '%s' command on '%s' node with following "
"error: %s" % (cmd, hostname, err))
g.log.error(msg)
raise exceptions.ExecutionError(msg)
output = out.strip()
g.log.info("heketi volume with volnameprefix present %s" % output)
return True
def heketi_cluster_delete(heketi_client_node, heketi_server_url, cluster_id,
**kwargs):
"""Executes heketi cluster delete command.
Args:
heketi_client_node (str): Node on which cmd has to be executed.
heketi_server_url (str): Heketi server url
cluster_id (str): Cluster ID
Kwargs:
The keys, values in kwargs are:
- json : (bool)
- secret : (str)|None
- user : (str)|None
Returns:
str: cluster delete command output on success
Raises:
exceptions.ExecutionError: if command fails.
Example:
heketi_cluster_delete(heketi_client_node, heketi_server_url,
cluster_id)
"""
heketi_server_url, json_arg, admin_key, user = _set_heketi_global_flags(
heketi_server_url, **kwargs)
cmd = "heketi-cli -s %s cluster delete %s %s %s %s" % (
heketi_server_url, cluster_id, json_arg, admin_key, user)
ret, out, err = g.run(heketi_client_node, cmd)
if ret != 0:
msg = (
"Failed to execute '%s' command on '%s' node with following "
"error: %s" % (cmd, heketi_client_node, err))
g.log.error(msg)
raise exceptions.ExecutionError(msg)
return out
def _get_openshift_version_str(hostname=None):
"""Gets OpenShift version from 'oc version' command.
Args:
hostname (str): Node on which the ocp command should run.
Returns:
str : oc version, i.e. 'v3.10.47'
Raises: 'exceptions.ExecutionError' if failed to get version
"""
if not hostname:
hostname = list(g.config['ocp_servers']['client'].keys())[0]
cmd = "oc version | grep openshift | cut -d ' ' -f 2"
ret, out, err = g.run(hostname, cmd, "root")
if ret != 0:
msg = "Failed to get oc version. \n'err': %s\n 'out': %s" % (err, out)
g.log.error(msg)
raise AssertionError(msg)
out = out.strip()
if not out:
error_msg = "Empty output from 'oc version' command: '%s'" % out
g.log.error(error_msg)
raise exceptions.ExecutionError(error_msg)
return out
def test_create_volumes_enabling_and_disabling_heketi_devices(self):
"""Validate enable/disable of heketi device"""
# Get nodes info
node_id_list = heketi_ops.heketi_node_list(self.heketi_client_node,
self.heketi_server_url)
node_info_list = []
for node_id in node_id_list[0:3]:
node_info = heketi_ops.heketi_node_info(self.heketi_client_node,
self.heketi_server_url,
node_id,
json=True)
node_info_list.append(node_info)
# Disable 4th and other nodes
if len(node_id_list) > 3:
for node in node_id_list[3:]:
heketi_ops.heketi_node_disable(self.heketi_client_node,
self.heketi_server_url, node_id)
self.addCleanup(heketi_ops.heketi_node_enable,
self.heketi_client_node,
self.heketi_server_url, node_id)
# Disable second and other devices on the first 3 nodes
for node_info in node_info_list[0:3]:
devices = node_info["devices"]
self.assertTrue(
devices, "Node '%s' does not have devices." % node_info["id"])
if devices[0]["state"].strip().lower() != "online":
self.skipTest("Test expects first device to be enabled.")
if len(devices) < 2:
continue
for device in node_info["devices"][1:]:
out = heketi_ops.heketi_device_disable(self.heketi_client_node,
self.heketi_server_url,
device["id"])
self.assertTrue(
out, "Failed to disable the device %s" % device["id"])
self.addCleanup(heketi_ops.heketi_device_enable,
self.heketi_client_node,
self.heketi_server_url, device["id"])
# Create heketi volume
out = heketi_ops.heketi_volume_create(self.heketi_client_node,
self.heketi_server_url,
1,
json=True)
self.assertTrue(out, "Failed to create heketi volume of size 1")
g.log.info("Successfully created heketi volume of size 1")
device_id = out["bricks"][0]["device"]
self.addCleanup(heketi_ops.heketi_volume_delete,
self.heketi_client_node, self.heketi_server_url,
out["bricks"][0]["volume"])
# Disable device
g.log.info("Disabling '%s' device" % device_id)
out = heketi_ops.heketi_device_disable(self.heketi_client_node,
self.heketi_server_url,
device_id)
self.assertTrue(out, "Failed to disable the device %s" % device_id)
g.log.info("Successfully disabled device %s" % device_id)
try:
# Get device info
g.log.info("Retrieving '%s' device info" % device_id)
out = heketi_ops.heketi_device_info(self.heketi_client_node,
self.heketi_server_url,
device_id,
json=True)
self.assertTrue(out, "Failed to get device info %s" % device_id)
g.log.info("Successfully retrieved device info %s" % device_id)
name = out["name"]
if out["state"].lower().strip() != "offline":
raise exceptions.ExecutionError(
"Device %s is not in offline state." % name)
g.log.info("Device %s is now offine" % name)
# Try to create heketi volume
g.log.info("Creating heketi volume: Expected to fail.")
try:
out = heketi_ops.heketi_volume_create(self.heketi_client_node,
self.heketi_server_url,
1,
json=True)
except exceptions.ExecutionError:
g.log.info("Volume was not created as expected.")
else:
self.addCleanup(heketi_ops.heketi_volume_delete,
self.heketi_client_node,
self.heketi_server_url,
out["bricks"][0]["volume"])
msg = "Volume unexpectedly created. Out: %s" % out
assert False, msg
finally:
# Enable the device back
g.log.info("Enable '%s' device back." % device_id)
out = heketi_ops.heketi_device_enable(self.heketi_client_node,
self.heketi_server_url,
device_id)
self.assertTrue(out, "Failed to enable the device %s" % device_id)
g.log.info("Successfully enabled device %s" % device_id)
# Get device info
out = heketi_ops.heketi_device_info(self.heketi_client_node,
self.heketi_server_url,
device_id,
json=True)
self.assertTrue(out, ("Failed to get device info %s" % device_id))
g.log.info("Successfully retrieved device info %s" % device_id)
name = out["name"]
if out["state"] != "online":
raise exceptions.ExecutionError(
"Device %s is not in online state." % name)
# Create heketi volume of size
out = heketi_ops.heketi_volume_create(self.heketi_client_node,
self.heketi_server_url,
1,
json=True)
self.assertTrue(out, "Failed to create volume of size 1")
self.addCleanup(heketi_ops.heketi_volume_delete,
self.heketi_client_node, self.heketi_server_url,
out["bricks"][0]["volume"])
g.log.info("Successfully created volume of size 1")
name = out["name"]
# Get gluster volume info
vol_info = get_volume_info('auto_get_gluster_endpoint', volname=name)
self.assertTrue(vol_info, "Failed to get '%s' volume info." % name)
g.log.info("Successfully got the '%s' volume info." % name)
def heketi_volume_create(heketi_client_node, heketi_server_url, size,
raw_cli_output=False, **kwargs):
"""Creates heketi volume with the given user options.
Args:
heketi_client_node (str): Node on which cmd has to be executed.
heketi_server_url (str): Heketi server url
size (str): Volume size
Kwargs:
The keys, values in kwargs are:
- block : (bool)
- clusters : (str)|None
- disperse_data : (int)|None
- durability : (str)|None
- gid : (int)|None
- gluster_volume_options : (str)|None
- name : (str)|None
- persistent_volume : (bool)
- persistent_volume_endpoint : (str)|None
- persistent_volume_file : (str)|None
- redundancy : (int):None
- replica : (int)|None
- size : (int):None
- snapshot-factor : (float)|None
- json : (bool)
- secret : (str)|None
- user : (str)|None
Returns:
dict: volume create info on success, only cli option is specified
without --json option, then it returns raw string output.
Tuple (ret, out, err): if raw_cli_output is True.
Raises:
exceptions.ExecutionError when error occurs and raw_cli_output is False
Example:
heketi_volume_create(heketi_client_node, heketi_server_url, size)
"""
if not kwargs.get('user'):
openshift_config = g.config.get("cns", g.config.get("openshift"))
heketi_cli_user = openshift_config['heketi_config']['heketi_cli_user']
if heketi_cli_user:
kwargs['user'] = heketi_cli_user
heketi_cli_key = openshift_config[
'heketi_config']['heketi_cli_key']
if heketi_cli_key is not None:
kwargs['secret'] = heketi_cli_key
heketi_server_url = (heketi_server_url if heketi_server_url else ("http:" +
"//heketi-storage-project.cloudapps.mystorage.com"))
block_arg = "--block" if kwargs.get("block") else ""
clusters_arg = ("--clusters %s" % kwargs.get("clusters")
if kwargs.get("clusters") else "")
disperse_data_arg = ("--disperse-data %d" % kwargs.get("disperse_data")
if kwargs.get("disperse_data") else "")
durability_arg = ("--durability %s" % kwargs.get("durability")
if kwargs.get("durability") else "")
gid_arg = "--gid %d" % int(kwargs.get("gid")) if kwargs.get("gid") else ""
gluster_volume_options_arg = ("--gluster-volume-options '%s'"
% kwargs.get("gluster_volume_options")
if kwargs.get("gluster_volume_options")
else "")
name_arg = "--name %s" % kwargs.get("name") if kwargs.get("name") else ""
persistent_volume_arg = ("--persistent-volume %s"
% kwargs.get("persistent_volume")
if kwargs.get("persistent_volume") else "")
persistent_volume_endpoint_arg = ("--persistent-volume-endpoint %s"
% (kwargs.get(
"persistent_volume_endpoint"))
if (kwargs.get(
"persistent_volume_endpoint"))
else "")
persistent_volume_file_arg = ("--persistent-volume-file %s"
% kwargs.get("persistent_volume_file")
if kwargs.get("persistent_volume_file")
else "")
redundancy_arg = ("--redundancy %d" % int(kwargs.get("redundancy"))
if kwargs.get("redundancy") else "")
replica_arg = ("--replica %d" % int(kwargs.get("replica"))
if kwargs.get("replica") else "")
snapshot_factor_arg = ("--snapshot-factor %f"
% float(kwargs.get("snapshot_factor"))
if kwargs.get("snapshot_factor") else "")
json_arg = "--json" if kwargs.get("json") else ""
secret_arg = (
"--secret %s" % kwargs.get("secret") if kwargs.get("secret") else "")
user_arg = "--user %s" % kwargs.get("user") if kwargs.get("user") else ""
err_msg = "Failed to create volume. "
cmd = ("heketi-cli -s %s volume create --size=%s %s %s %s %s %s %s "
"%s %s %s %s %s %s %s %s %s %s" % (
heketi_server_url, str(size), block_arg, clusters_arg,
disperse_data_arg, durability_arg, gid_arg,
gluster_volume_options_arg, name_arg,
persistent_volume_arg, persistent_volume_endpoint_arg,
persistent_volume_file_arg, redundancy_arg, replica_arg,
snapshot_factor_arg, json_arg, secret_arg, user_arg))
ret, out, err = g.run(heketi_client_node, cmd)
if raw_cli_output:
return ret, out, err
if ret != 0:
err_msg += "Out: %s \n Err: %s" % (out, err)
g.log.error(err_msg)
raise exceptions.ExecutionError(err_msg)
if json_arg:
return json.loads(out)
return out
def heketi_blockvolume_create(heketi_client_node, heketi_server_url, size,
**kwargs):
"""Executes heketi blockvolume create
Args:
heketi_client_node (str): Node on which cmd has to be executed.
heketi_server_url (str): Heketi server url
size (int): blockvolume size
Kwargs:
The keys, values in kwargs are:
- name : (str)|None
- cluster : (str)|None
- ha : (int)|None
- auth : (bool)
- json : (bool)
- secret : (str)|None
- user : (str)|None
Returns:
dict: blockvolume create info on success, only cli option is specified
without --json option, then it returns raw string output.
Raises:
exceptions.ExecutionError: if command fails.
Example:
heketi_blockvolume_create(heketi_client_node, heketi_server_url, size)
"""
heketi_server_url, json_arg, admin_key, user = _set_heketi_global_flags(
heketi_server_url, **kwargs)
auth = clusters = ha = name = None
if heketi_server_url is None:
heketi_server_url = ("http://" +
"heketi-storage-project.cloudapps.mystorage.com")
if 'auth' in kwargs:
auth = kwargs['auth']
if 'clusters' in kwargs:
clusters = kwargs['clusters']
if 'ha' in kwargs:
ha = int(kwargs['ha'])
if 'name' in kwargs:
name = kwargs['name']
auth_arg = clusters_arg = ha_arg = name_arg = ''
if auth:
auth_arg = "--auth"
if clusters is not None:
clusters_arg = "--clusters %s" % clusters
if ha is not None:
ha_arg = "--ha %d" % ha
if name is not None:
name_arg = "--name %s" % name
cmd = ("heketi-cli -s %s blockvolume create --size=%s %s %s %s %s "
"%s %s %s %s" % (heketi_server_url, str(size), auth_arg,
clusters_arg, ha_arg, name_arg, name_arg,
admin_key, user, json_arg))
ret, out, err = g.run(heketi_client_node, cmd)
if ret != 0:
msg = (
"Failed to execute '%s' command on '%s' node with following "
"error: %s" % (cmd, heketi_client_node, err))
g.log.error(msg)
raise exceptions.ExecutionError(msg)
if json_arg:
return json.loads(out)
return out
