summaryrefslogtreecommitdiffstats
path: root/tests/functional/heketi/test_node_enable_disable.py
blob: b8ce2c712245fcbf7b77ef3c53552b358cc91f62 (plain)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
"""Test cases to disable and enable node in heketi."""
import json

from cnslibs.common.baseclass import BaseClass
from cnslibs.common.heketi_ops import (heketi_node_enable,
                                       heketi_node_info,
                                       heketi_node_disable,
                                       heketi_node_list,
                                       heketi_volume_create,
                                       heketi_volume_delete
                                       )
from glusto.core import Glusto as g


class TestHeketiNodeState(BaseClass):
    """Test node enable and disable functionality."""

    def enable_node(self, node_id):
        """
        Enable node through heketi-cli.

        :param node_id: str node ID
        """
        out = heketi_node_enable(self.heketi_client_node,
                                 self.heketi_server_url,
                                 node_id)

        self.assertNotEqual(out, False,
                            "Failed to enable node of"
                            " id %s" % node_id)

    def disable_node(self, node_id):
        """
        Disable node through heketi-cli.

        :param node_id: str node ID
        """
        out = heketi_node_disable(self.heketi_client_node,
                                  self.heketi_server_url,
                                  node_id)

        self.assertNotEqual(out, False,
                            "Failed to disable node of"
                            " id %s" % node_id)

    def get_node_info(self, node_id):
        """
        Get node information from node_id.

        :param node_id: str node ID
        :return node_info: list node information
        """
        node_info = heketi_node_info(
            self.heketi_client_node, self.heketi_server_url,
            node_id, json=True)
        self.assertNotEqual(node_info, False,
                            "Node info on %s failed" % node_id)
        return node_info

    def get_online_nodes(self, node_list):
        """
        Get online nodes information from node_list.

        :param node_list: list of node ID's
        :return: list node information of online  nodes
        """
        online_hosts_info = []

        for node in node_list:
            node_info = self.get_node_info(node)
            if node_info["state"] == "online":
                online_hosts_info.append(node_info)

        return online_hosts_info

    def test_node_state(self):
        """
        Test node enable and disable functionality.

        If we have 4 gluster servers, if we disable 1/4 nodes from heketi
        and create a volume, the volume creation should be successful.

        If we disable 2/4 nodes from heketi-cli and create a volume
        the volume creation should fail.

        If we enable back one gluster server and create a volume
        the volume creation should be successful.
        """
        g.log.info("Disable node in heketi")
        node_list = heketi_node_list(self.heketi_client_node,
                                     self.heketi_server_url)
        self.assertTrue(node_list, "Failed to list heketi nodes")
        g.log.info("Successfully got the list of nodes")
        online_hosts = self.get_online_nodes(node_list)

        if len(online_hosts) < 3:
            raise self.skipTest(
                "This test can run only if online hosts are more "
                "than 2")
        # if we have n nodes, disable n-3 nodes
        for node_info in online_hosts[3:]:
            node_id = node_info["id"]
            g.log.info("going to disable node id %s", node_id)
            self.disable_node(node_id)
            self.addCleanup(self.enable_node, node_id)

        vol_size = 1
        # create volume when 3 nodes are online
        vol_info = heketi_volume_create(self.heketi_client_node,
                                        self.heketi_server_url, vol_size,
                                        json=True)
        self.addCleanup(
            heketi_volume_delete, self.heketi_client_node,
            self.heketi_server_url, vol_info['id'])

        node_id = online_hosts[0]['id']
        g.log.info("going to disable node id %s", node_id)
        self.disable_node(node_id)
        self.addCleanup(self.enable_node, node_id)

        # try to create a volume, volume creation should fail
        ret, out, err = heketi_volume_create(
            self.heketi_client_node, self.heketi_server_url,
            vol_size, raw_cli_output=True)
        if ret == 0:
            out_json = json.loads(out)
            self.addCleanup(
                heketi_volume_delete, self.heketi_client_node,
                self.heketi_server_url, out_json["id"])
        self.assertNotEqual(ret, 0,
                            ("Volume creation did not fail ret- %s "
                             "out- %s err- %s" % (ret, out, err)))

        g.log.info("Volume creation failed as expected, err- %s", err)
        # enable node
        self.enable_node(node_id)

        # create volume when node is enabled
        vol_info = heketi_volume_create(self.heketi_client_node,
                                        self.heketi_server_url, vol_size,
                                        json=True)
        self.addCleanup(
            heketi_volume_delete, self.heketi_client_node,
            self.heketi_server_url, vol_info['id'])