def testServers(self):
"""test ComponentGroup.servers()"""
fs = FileSystem('comp')
grp = ComponentGroup()
grp.add(Component(fs, Server('foo1', ['foo1@tcp'])))
grp.add(Component(fs, Server('foo2', ['foo2@tcp'])))
self.assertEqual(str(grp.servers()), "foo[1-2]")
def testHaNode(self):
"""test failover servers"""
fs = FileSystem('nonreg')
srv = Server('foo1', ['foo1@tcp'])
tgt = Target(fs, srv, 0, '/dev/null')
self.assertEqual(tgt.server, srv)
self.assertEqual(len(tgt.failservers), 0)
# Could not switch to an undefined failnode
self.assertFalse(tgt.failover(NodeSet("foo1")))
self.assertEqual(tgt.server, srv)
# Add a failserver and switch to it
foo2 = Server('foo2', ['foo2@tcp'])
tgt.add_server(foo2)
self.assertEqual(list(tgt.failservers), [foo2])
self.assertTrue(tgt.failover(NodeSet("foo2")))
self.assertEqual(tgt.server, foo2)
# Add a 2nd failserver and switch to it
foo3 = Server('foo3', ['foo3@tcp'])
tgt.add_server(foo3)
self.assertEqual(list(tgt.failservers), [foo2, foo3])
self.assertTrue(tgt.failover(NodeSet("foo3")))
self.assertEqual(tgt.server, foo3)
# Switch with more than 1 candidate but only one exist
self.assertTrue(tgt.failover(NodeSet("bar,foo2")))
self.assertEqual(tgt.server, foo2)
# Could not switch if more than one node matches
self.assertRaises(ComponentError, Target.failover, tgt,
NodeSet("foo[2,3]"))
def testAllServers(self):
"""test Target.allservers()"""
fs1 = FileSystem('allsrvr')
srv1 = Server('foo1', ['foo1@tcp'])
srv2 = Server('foo2', ['foo2@tcp'])
tgt = fs1.new_target(srv1, 'ost', 0, '/dev/null')
tgt.add_server(srv2)
self.assertEqual(list(iter(tgt.allservers())), [srv1, srv2])
def testSelect(self):
"""test ServerGroup.select()"""
srv1 = Server('foo1', ['foo1@tcp'])
srv2 = Server('foo2', ['foo2@tcp'])
srv3 = Server('foo3', ['foo3@tcp'])
grp = ServerGroup([srv1, srv2, srv3])
subgrp = grp.select(NodeSet("foo[1,3]"))
self.assertEqual(list(iter(subgrp)), [srv1, srv3])
def setUp(self):
CommonTestCase.setUp(self)
self.srv = Server(Utils.HOSTNAME, ["%s@tcp" % Utils.HOSTNAME],
hdlr=self.eh)
self.disk = Utils.make_disk()
self.tgt = self.fs.new_target(self.srv, 'mgt', 0, self.disk.name)
self.model = TuningModel()
self.model.create_parameter('/dev/null', 1, node_type_list=['mgs'])
class TuneActionTest(CommonTestCase):
def setUp(self):
CommonTestCase.setUp(self)
self.srv = Server(Utils.HOSTNAME, ["%s@tcp" % Utils.HOSTNAME],
hdlr=self.eh)
self.disk = Utils.make_disk()
self.tgt = self.fs.new_target(self.srv, 'mgt', 0, self.disk.name)
self.model = TuningModel()
self.model.create_parameter('/dev/null', 1, node_type_list=['mgs'])
def test_tune_ok(self):
"""Apply simple tuning is ok"""
# Create a working tuning
self.assertEqual(len(self.model.get_params_for_name(None, ['mgs'])), 1)
act = self.srv.tune(self.model, self.fs.components, 'action')
result = self.check_base(self.srv, 'server', act, ACT_OK,
['start', 'done'],
'apply tunings')
def test_tuning_depends_on_failed_action(self):
"""Apply tuning depeding on a failed action does not crash"""
# Create a working tuning
self.assertEqual(len(self.model.get_params_for_name(None, ['mgs'])), 1)
act1 = self.tgt.execute(addopts='/bin/false')
act2 = self.srv.tune(self.model, self.fs.components, 'action')
act2.depends_on(act1)
result = self.check_base(self.tgt, 'comp', act1, ACT_ERROR,
['start', 'failed'],
'execute of MGS (%s)' % self.tgt.dev)
def test_tune_dryrun(self):
"""Apply tuning in dry-run mode"""
act = self.srv.tune(self.model, self.fs.components, 'action',
dryrun=True)
text = 'echo -n 1 > /dev/null'
self.check_dryrun(act, text, 'server', 'tune', ['start', 'done'],
self.srv, 'apply tunings')
def test_tune_error(self):
"""Apply a bad tuning is correctly reported"""
# Add bad tuning
self.model.create_parameter('/proc/modules', 1, node_type_list=['mgs'])
self.model.create_parameter('/proc/cmdline', 1, node_type_list=['mgs'])
self.assertEqual(len(self.model.get_params_for_name(None, ['mgs'])), 3)
act = self.srv.tune(self.model, self.fs.components, 'action')
result = self.check_base(self.srv, 'server', act, ACT_ERROR,
['start', 'failed'],
'apply tunings')
self.assertEqual(result.retcode, None)
self.assertEqual(str(result),
"'echo -n 1 > /proc/modules' failed\n"
"'echo -n 1 > /proc/cmdline' failed")
def testAllServers(self):
"""test ComponentGroup.allservers()"""
fs = FileSystem('comp')
grp = ComponentGroup()
grp.add(Target(fs, Server('foo1', ['foo1@tcp']), 0, '/dev/sda'))
comp = Target(fs, Server('foo2', ['foo2@tcp']), 1, '/dev/sda')
grp.add(comp)
comp.add_server(Server('foo3', ['foo3@tcp0']))
self.assertEqual(str(grp.allservers()), "foo[1-3]")
class TuneActionTest(CommonTestCase):
def setUp(self):
CommonTestCase.setUp(self)
self.srv = Server(Utils.HOSTNAME, ["%s@tcp" % Utils.HOSTNAME],
hdlr=self.eh)
self.disk = Utils.make_disk()
self.tgt = self.fs.new_target(self.srv, 'mgt', 0, self.disk.name)
self.model = TuningModel()
self.model.create_parameter('/dev/null', 1, node_type_list=['mgs'])
def test_tune_ok(self):
"""Apply simple tuning is ok"""
# Create a working tuning
self.assertEqual(len(self.model.get_params_for_name(None, ['mgs'])), 1)
act = self.srv.tune(self.model, self.fs.components, 'action')
result = self.check_base(self.srv, 'server', act, ACT_OK,
['start', 'done'], 'apply tunings')
def test_tuning_depends_on_failed_action(self):
"""Apply tuning depeding on a failed action does not crash"""
# Create a working tuning
self.assertEqual(len(self.model.get_params_for_name(None, ['mgs'])), 1)
act1 = self.tgt.execute(addopts='/bin/false')
act2 = self.srv.tune(self.model, self.fs.components, 'action')
act2.depends_on(act1)
result = self.check_base(self.tgt, 'comp', act1, ACT_ERROR,
['start', 'failed'],
'execute of MGS (%s)' % self.tgt.dev)
def test_tune_dryrun(self):
"""Apply tuning in dry-run mode"""
act = self.srv.tune(self.model,
self.fs.components,
'action',
dryrun=True)
text = 'echo -n 1 > /dev/null'
self.check_dryrun(act, text, 'server', 'tune', ['start', 'done'],
self.srv, 'apply tunings')
def test_tune_error(self):
"""Apply a bad tuning is correctly reported"""
# Add bad tuning
self.model.create_parameter('/proc/modules', 1, node_type_list=['mgs'])
self.model.create_parameter('/proc/cmdline', 1, node_type_list=['mgs'])
self.assertEqual(len(self.model.get_params_for_name(None, ['mgs'])), 3)
act = self.srv.tune(self.model, self.fs.components, 'action')
result = self.check_base(self.srv, 'server', act, ACT_ERROR,
['start', 'failed'], 'apply tunings')
self.assertEqual(result.retcode, None)
self.assertEqual(
str(result), "'echo -n 1 > /proc/modules' failed\n"
"'echo -n 1 > /proc/cmdline' failed")
def testDistantServers(self):
"""test distant_servers()"""
nodes = NodeSet("foo,bar")
self.assertEqual(Server.distant_servers(nodes), nodes)
nodes_short = nodes | NodeSet(Server.hostname_short())
self.assertEqual(Server.distant_servers(nodes_short), nodes)
nodes_long = nodes | NodeSet(Server.hostname_long())
self.assertEqual(Server.distant_servers(nodes_long), nodes)
def testDistant(self):
"""test ServerGroup.nodeset()"""
fqdn = socket.getfqdn()
shortname = socket.gethostname().split('.', 1)[0]
srv1 = Server(shortname, ['%s@tcp' % shortname])
srv2 = Server('foo', ['foo@tcp'])
grp = ServerGroup([srv1, srv2])
subgrp = grp.distant()
self.assertEqual(list(iter(subgrp)), [srv2])
def testDistantServers(self):
"""test distant_servers()"""
nodes = NodeSet("foo,bar")
self.assertEqual(Server.distant_servers(nodes), nodes)
nodes_short = nodes | NodeSet(Server.hostname_short())
self.assertEqual(Server.distant_servers(nodes_short), nodes)
nodes_long = nodes | NodeSet(Server.hostname_long())
self.assertEqual(Server.distant_servers(nodes_long), nodes)
def test_uniqueid_diff_mountpath(self):
"""test client.uniqueid() (diff mount_path)"""
fs1 = FileSystem('uniqueid')
srv1 = Server('foo1', ['foo1@tcp'])
client1 = fs1.new_client(srv1, '/foo1')
fs2 = FileSystem('uniqueid')
srv2 = Server('foo1', ['foo1@tcp'])
client2 = fs2.new_client(srv2, '/foo2')
self.assertNotEqual(client1.uniqueid(), client2.uniqueid())
def testLabels(self):
"""test ComponentGroup.labels()"""
fs = FileSystem('comp')
grp = ComponentGroup()
comp = Component(fs, Server('foo1', ['foo1@tcp']))
comp.TYPE = 'A'
grp.add(comp)
comp = Component(fs, Server('foo2', ['foo2@tcp']))
comp.TYPE = 'B'
grp.add(comp)
self.assertEqual(str(grp.labels()), 'comp-A,comp-B')
def test_unique_id(self):
"""test target.uniqueid()"""
fs1 = FileSystem('uniqueid')
srv1 = Server('foo1', ['foo1@tcp'])
tgt1 = fs1.new_target(srv1, 'ost', 0, '/dev/null')
fs2 = FileSystem('uniqueid')
srv2 = Server('foo1', ['foo1@tcp'])
tgt2 = fs2.new_target(srv2, 'ost', 0, '/dev/null')
self.assertEqual(tgt2.uniqueid(), tgt1.uniqueid())
def test_unique_id(self):
"""test client.uniqueid()"""
fs1 = FileSystem('uniqueid')
srv1 = Server('foo1', ['foo1@tcp'])
client1 = fs1.new_client(srv1, '/foo')
fs2 = FileSystem('uniqueid')
srv2 = Server('foo1', ['foo1@tcp'])
client2 = fs2.new_client(srv2, '/foo')
self.assertEqual(client1.uniqueid(), client2.uniqueid())
def setUp(self):
fs1 = FileSystem('allsrvr')
self.srv1 = Server('foo1', ['foo1@tcp'])
self.srv2 = Server('foo2', ['foo2@tcp'])
self.srv3 = Server('foo3', ['foo3@tcp'])
self.srv1name = str(self.srv1.hostname)
self.srv2name = str(self.srv2.hostname)
self.srv3name = str(self.srv3.hostname)
self.tgt = fs1.new_target(self.srv1, 'ost', 0, '/dev/null')
self.tgt.add_server(self.srv2)
self.tgt.add_server(self.srv3)
def testUpdate(self):
"""test ComponentGroup.update()"""
fs = FileSystem('comp')
grp1 = ComponentGroup()
comp1 = Component(fs, Server('foo1', ['foo1@tcp']))
grp1.add(comp1)
grp2 = ComponentGroup()
comp2 = Component(fs, Server('foo2', ['foo2@tcp']))
grp2.add(comp2)
grp1.update(grp2)
self.assertEqual(len(grp1), 2)
self.assertTrue(comp1 in grp1)
self.assertTrue(comp2 in grp1)
def testOr(self):
"""test ComponentGroup.__or__()"""
fs = FileSystem('comp')
grp1 = ComponentGroup()
comp1 = Component(fs, Server('foo1', ['foo1@tcp']))
grp1.add(comp1)
grp2 = ComponentGroup()
comp2 = Component(fs, Server('foo2', ['foo2@tcp']))
grp2.add(comp2)
merge = grp1|grp2
self.assertEqual(len(merge), 2)
self.assertTrue(comp1 in merge)
self.assertTrue(comp2 in merge)
def _get_server(nodename, fs, fs_conf, handler, nodes=None, excluded=None):
"""Instantiate Server and cache them in _SERVERS"""
if nodename not in _SERVERS:
server = Server(nodename, fs_conf.get_nid(nodename), handler)
if (nodes is not None and server.hostname not in nodes) or \
(excluded is not None and server.hostname in excluded):
server.action_enabled = False
_SERVERS[nodename] = server
if _SERVERS[nodename].is_local():
fs.local_server = _SERVERS[nodename]
return _SERVERS[nodename]
def _get_server(nodename, fs, fs_conf, handler, nodes=None, excluded=None):
"""Instantiate Server and cache them in _SERVERS"""
if nodename not in _SERVERS:
server = Server(nodename, fs_conf.get_nid(nodename), handler)
if (nodes is not None and server.hostname not in nodes) or \
(excluded is not None and server.hostname in excluded):
server.action_enabled = False
_SERVERS[nodename] = server
if _SERVERS[nodename].is_local():
fs.local_server = _SERVERS[nodename]
return _SERVERS[nodename]
def testManaged(self):
"""test ComponentGroup.managed()"""
fs = FileSystem('comp')
grp = ComponentGroup()
comp1 = Component(fs, Server('foo1', ['foo1@tcp']), mode="external")
grp.add(comp1)
comp2 = Component(fs, Server('foo2', ['foo2@tcp']))
grp.add(comp2)
comp3 = Component(fs, Server('foo3', ['foo3@tcp']), enabled=False)
grp.add(comp3)
comp4 = Component(fs, Server('foo4', ['foo4@tcp']))
grp.add(comp4)
offgrp = grp.managed()
self.assertEqual(len(offgrp), 2)
self.assertTrue(comp2 in offgrp)
self.assertTrue(comp4 in offgrp)
def _create_comp(fs_conf, fs, comp):
comp_type = comp.get_type()
newcomp = None
server = Server(comp.get_nodename(), fs_conf.get_nid(comp.get_nodename()))
if comp_type == 'client':
newcomp = Client(
fs, server,
comp.get_mount_path() or fs_conf.get_default_mount_path(),
comp.get_mount_options() or fs_conf.get_default_mount_options())
elif comp_type == 'mgt':
newcomp = MGT(fs, server, comp.get_index(), comp.get_dev(),
comp.get_jdev())
elif comp_type == 'mdt':
newcomp = MDT(fs, server, comp.get_index(), comp.get_dev(),
comp.get_jdev())
elif comp_type == 'ost':
newcomp = OST(fs, server, comp.get_index(), comp.get_dev(),
comp.get_jdev())
elif comp_type == 'router':
newcomp = Router(fs, server)
else:
assert False, "Unknown component type: %s" % comp_type
return fs.components[newcomp.uniqueid()]
def testGenericComponent(self):
"""test ComponentGroup simple methods"""
fs = FileSystem('comp')
grp = ComponentGroup()
self.assertEqual(len(grp), 0)
comp = Component(fs, Server('foo', ['foo@tcp']))
comp.TYPE = 'A'
# add()
grp.add(comp)
# __len__
self.assertEqual(len(grp), 1)
# __str__
self.assertEqual(str(grp), 'comp-A')
# __getitem__
self.assertEqual(grp[comp.uniqueid()], comp)
# __contains__
self.assertTrue(comp in grp)
# __iter__
self.assertEqual(list(iter(grp)), [ comp ])
# Could not add() twice the same component
try:
grp.add(comp)
except KeyError as error:
txt = "'A component with id comp-A-foo@tcp already exists.'"
self.assertEqual(str(error), txt)
def test_unique_id_failover(self):
"""test target.uniqueid()"""
fs1 = FileSystem('uniqueid')
srv1a = Server('foo1', ['foo1@tcp'])
srv1b = Server('foo2', ['foo2@tcp'])
tgt1 = fs1.new_target(srv1a, 'ost', 0, '/dev/null')
tgt1.add_server(srv1b)
fs2 = FileSystem('uniqueid')
srv2a = Server('foo1', ['foo1@tcp'])
srv2b = Server('foo2', ['foo2@tcp'])
tgt2 = fs2.new_target(srv2a, 'ost', 0, '/dev/null')
tgt2.add_server(srv2b)
tgt2.failover(NodeSet('foo2'))
self.assertEqual(tgt2.uniqueid(), tgt1.uniqueid())
def setUp(self):
CommonTestCase.setUp(self)
srv1 = Server(Utils.HOSTNAME, ["%s@tcp" % Utils.HOSTNAME],
hdlr=self.eh)
self.fs.local_server = srv1
self.disk = Utils.make_disk()
self.tgt = self.fs.new_target(srv1, 'mgt', 0, self.disk.name)
def setUp(self):
CommonTestCase.setUp(self)
self.srv = Server(Utils.HOSTNAME, ["%s@tcp" % Utils.HOSTNAME],
hdlr=self.eh)
self.disk = Utils.make_disk()
self.tgt = self.fs.new_target(self.srv, 'mgt', 0, self.disk.name)
self.model = TuningModel()
self.model.create_parameter('/dev/null', 1, node_type_list=['mgs'])
def test_start_client_two_nids(self):
"""test command line start client (mgs two nids)"""
srv = Server('localhost', ['localhost@tcp','localhost@o2ib'])
self.fs.new_target(srv, 'mgt', 0, '/dev/root')
client = self.fs.new_client(self.srv1, "/foo")
action = StartClient(client)
self.check_cmd(action, 'mkdir -p "/foo" && ' +
'/bin/mount -t lustre localhost@tcp,localhost@o2ib:/action /foo')
def test_tunefs_target_network(self):
"""test command line tunefs network"""
self.fs.new_target(self.srv1, 'mgt', 0, '/dev/root')
ost = self.fs.new_target(self.srv1, 'ost', 0, '/dev/root', network='tcp')
ost.add_server(self.srv2)
ost.add_server(Server('localhost3', ['localhost3@o2ib']))
action = Tunefs(ost)
self.check_cmd_tunefs(action, '"--mgsnode=localhost@tcp" ' +
'"--failnode=localhost2@tcp" --network=tcp /dev/root')
def init_execute(self):
"""
Initialize execution of remote command, if needed. Should be called
first from derived classes before really executing the command.
"""
# Limit the scope of the command if called with local flag (-L) or
# called remotely (-R).
if self.has_local_flag():
self.options.nodes = NodeSet(Server.hostname_short())
def init_execute(self):
"""
Initialize execution of remote command, if needed. Should be called
first from derived classes before really executing the command.
"""
# Limit the scope of the command if called with local flag (-L) or
# called remotely (-R).
if self.has_local_flag():
self.options.nodes = NodeSet(Server.hostname_short())
def testSimple(self):
"""test ServerGroup simple tests"""
grp = ServerGroup()
self.assertEqual(len(grp), 0)
srv = Server('foo', ['foo@tcp'])
grp.append(srv)
self.assertEqual(len(grp), 1)
self.assertEqual(grp[0], srv)
def test_tunefs_target_network_zero3(self):
"""test command line tunefs network with non-zero suffix"""
self.fs.new_target(self.srv1, 'mgt', 0, '/dev/root')
ost = self.fs.new_target(self.srv1, 'ost', 0, '/dev/root', network='o2ib1')
ost.add_server(self.srv2)
ost.add_server(Server('localhost3', ['localhost3@o2ib1']))
action = Tunefs(ost)
self.check_cmd_tunefs(action, '"--mgsnode=localhost@tcp" ' +
'"--failnode=localhost3@o2ib1" --network=o2ib1 /dev/root')
def test_format_target_network_zero(self):
"""test command line format (network with zero suffix)"""
self.fs.new_target(self.srv1, 'mgt', 0, '/dev/root')
tgt = self.fs.new_target(self.srv1, 'ost', 0, '/dev/root', network='o2ib0')
tgt.add_server(self.srv2)
tgt.add_server(Server('localhost3', ['localhost3@o2ib']))
tgt.full_check(mountdata=False)
action = Format(tgt)
self.check_cmd_format(action, '--ost --index=0 ' +
'"--mgsnode=localhost@tcp" "--failnode=localhost3@o2ib" ' +
'--network=o2ib0 /dev/root')
def testFilterSupports(self):
"""test ComponentGroup.filter(supports and key)"""
fs = FileSystem('comp')
grp = ComponentGroup()
comp1 = Component(fs, Server('foo1', ['foo1@tcp']))
comp1.state = MOUNTED
grp.add(comp1)
comp2 = Component(fs, Server('foo2', ['foo2@tcp']))
comp2.state = OFFLINE
grp.add(comp2)
comp3 = Component(fs, Server('foo3', ['foo3@tcp']))
comp3.state = MOUNTED
grp.add(comp3)
comp4 = Component(fs, Server('foo4', ['foo4@tcp']))
comp4.state = OFFLINE
grp.add(comp4)
offgrp = grp.filter(supports='is_external', key=lambda comp: comp.state == OFFLINE)
self.assertEqual(len(offgrp), 2)
self.assertTrue(comp2 in offgrp)
self.assertTrue(comp4 in offgrp)
def testGroupBy(self):
"""test ComponentGroup.groupby()"""
fs = FileSystem('comp')
grp = ComponentGroup()
comp1 = Component(fs, Server('foo1', ['foo1@tcp']), mode="external")
grp.add(comp1)
comp2 = Component(fs, Server('foo2', ['foo2@tcp']))
grp.add(comp2)
comp3 = Component(fs, Server('foo3', ['foo3@tcp']), mode="external")
grp.add(comp3)
comp4 = Component(fs, Server('foo4', ['foo4@tcp']))
grp.add(comp4)
results = [[mode, list(comps)] for mode, comps in grp.groupby(attr='_mode')]
self.assertEqual(len(results), 2)
self.assertEqual(results[0][0], "external")
self.assertTrue(comp1 in results[0][1])
self.assertTrue(comp3 in results[0][1])
self.assertEqual(results[1][0], "managed")
self.assertTrue(comp2 in results[1][1])
self.assertTrue(comp4 in results[1][1])
class ServerActionTest(CommonTestCase):
def _clean_modules(self):
"""Remove all already loaded modules, before a test."""
self.srv.lustre_check()
if 'libcfs' in self.srv.modules or 'ldiskfs' in self.srv.modules:
self.srv.unload_modules().launch()
self.fs._run_actions()
self.eh.clear()
def setUp(self):
CommonTestCase.setUp(self)
self.srv = Server(Utils.HOSTNAME, ["%s@lo" % Utils.HOSTNAME],
hdlr=self.eh)
self._clean_modules()
def tearDown(self):
self._clean_modules()
#
# Modules
#
@Utils.rootonly
def test_module_load(self):
"""Load lustre modules is ok"""
act = self.srv.load_modules()
result = self.check_base(self.srv, 'server', act, ACT_OK,
['start', 'done'],
"load module 'lustre'")
self.assertEqual(result.retcode, 0)
self.assertEqual(sorted(self.srv.modules.keys()), ['libcfs', 'lustre'])
@Utils.rootonly
def test_module_load_dryrun(self):
"""Load lustre modules in dry-run mode"""
act = self.srv.load_modules(dryrun=True)
text = 'modprobe lustre'
self.check_dryrun(act, text, 'server', 'load modules',
['start', 'done'], self.srv, "load module 'lustre'")
self.assertEqual(sorted(self.srv.modules.keys()), [])
@Utils.rootonly
def test_module_load_custom(self):
"""Load a custom module is ok"""
act = self.srv.load_modules(modname='ldiskfs')
result = self.check_base(self.srv, 'server', act, ACT_OK,
['start', 'done'],
"load module 'ldiskfs'")
self.assertEqual(self.srv.modules.keys(), ['ldiskfs'])
@Utils.rootonly
def test_module_load_error(self):
"""Load a bad module is an error"""
act = self.srv.load_modules(modname='ERROR')
result = self.check_base(self.srv, 'server', act, ACT_ERROR,
['start', 'failed'],
"load module 'ERROR'")
self.assertEqual(result.retcode, 1)
self.assertEqual(self.srv.modules, {})
@Utils.rootonly
def test_module_load_already_done(self):
"""Load modules when already loaded is ok"""
def lustre_check(self):
self.modules = {'lustre': 0, 'libcfs': 1}
self.srv.lustre_check = types.MethodType(lustre_check, self.srv)
act = self.srv.load_modules()
result = self.check_base(self.srv, 'server', act, ACT_OK,
['start', 'done'],
"load module 'lustre'")
self.assertEqual(str(result), "'lustre' is already loaded")
self.assertEqual(result.retcode, None)
self.assertEqual(sorted(self.srv.modules.keys()), ['libcfs', 'lustre'])
@Utils.rootonly
def test_module_unload(self):
"""Unload modules"""
# First load modules
self.srv.load_modules().launch()
self.fs._run_actions()
self.eh.clear()
act = self.srv.unload_modules()
result = self.check_base(self.srv, 'server', act, ACT_OK,
['start', 'done'],
'unload modules')
self.assertEqual(result.retcode, 0)
self.assertEqual(self.srv.modules, {})
@Utils.rootonly
def test_module_unload_already_done(self):
"""Unload modules when already done is ok"""
# By default modules are not loaded
act = self.srv.unload_modules()
result = self.check_base(self.srv, 'server', act, ACT_OK,
['start', 'done'],
'unload modules')
self.assertEqual(str(result), 'modules already unloaded')
self.assertEqual(result.retcode, None)
self.assertEqual(self.srv.modules, {})
def testHostname(self):
"""test hostname resolution"""
# Check hostname methods returns something
self.assertTrue(Server.hostname_short())
self.assertTrue(Server.hostname_long())
def testIsLocal(self):
"""test is_local()"""
fqdn = socket.getfqdn()
shortname = socket.gethostname().split(".", 1)[0]
# Test shortname is local()
srv = Server(shortname, ["%s@tcp" % shortname])
self.assertTrue(srv.is_local())
# Test fqdn is local()
srv = Server(fqdn, ["%s@tcp" % fqdn])
self.assertTrue(srv.is_local())
# Test a dummy shortname should not be local
shortname = shortname + "-shine-false-suffix"
srv = Server(shortname, ["%s@tcp" % shortname])
self.assertFalse(srv.is_local())
# Test a false domain name with a good hostname
othername = shortname + ".shine-false-tld"
srv = Server(othername, ["%s@tcp" % othername])
self.assertFalse(srv.is_local())
# Test something else should not be local
othername = fqdn + ".shine-false-tld"
srv = Server(othername, ["%s@tcp" % othername])
self.assertFalse(srv.is_local())
# Check hostname methods are rightly seen as local
self.assertTrue(Server(Server.hostname_short(), ["foo"]).is_local())
self.assertTrue(Server(Server.hostname_long(), ["foo"]).is_local())
class RouterActionTest(CommonTestCase):
def net_up(self, options):
self.srv1.load_modules(modname='lnet', options=options).launch()
self.fs._run_actions()
self.eh.clear()
def setUp(self):
CommonTestCase.setUp(self)
self.srv1 = Server(Utils.HOSTNAME, ["%s@tcp" % Utils.HOSTNAME])
self.router = self.fs.new_router(self.srv1)
self.srv1.unload_modules().launch()
self.fs._run_actions()
def tearDown(self):
self.router.lustre_check()
if self.router.is_started():
self.router.stop().launch()
self.fs._run_actions()
self.srv1.unload_modules().launch()
self.fs._run_actions()
#
# Start Router
#
@Utils.rootonly
def test_start_router_ok(self):
"""Start a stopped router is ok"""
self.net_up('forwarding=enabled')
act = self.router.start()
result = self.check_base(self.router, 'comp', act, ACT_OK,
['start', 'done'],
'start of router on %s' % self.router.server)
self.assertEqual(result.retcode, 0)
self.assertEqual(self.router.state, MOUNTED)
@Utils.rootonly
def test_start_router_dryrun(self):
"""Start a router in dry-run mode"""
self.net_up('forwarding=enabled')
act = self.router.start(dryrun=True)
text = '/sbin/modprobe ptlrpc'
self.check_dryrun(act, text, 'comp', 'start', ['start', 'done'],
self.router,
'start of router on %s' % self.router.server)
self.assertEqual(self.router.state, OFFLINE)
@Utils.rootonly
def test_start_router_already_done(self):
"""Start an already started router is ok"""
self.net_up('forwarding=enabled')
# Start the router
self.router.start().launch()
self.fs._run_actions()
self.eh.clear()
# Then try to restart it
act = self.router.start()
result = self.check_base(self.router, 'comp', act, ACT_OK,
['start', 'done'],
'start of router on %s' % self.router.server)
self.assertEqual(str(result), "router is already enabled")
self.assertEqual(result.retcode, None)
self.assertEqual(self.router.state, MOUNTED)
#
# Stop Router
#
@Utils.rootonly
def test_stop_router_ok(self):
"""Stop a started router is ok"""
self.net_up('forwarding=enabled')
# Start the router
self.router.start().launch()
self.fs._run_actions()
self.eh.clear()
# Then stop it
act = self.router.stop()
result = self.check_base(self.router, 'comp', act, ACT_OK,
['start', 'done'],
'stop of router on %s' % self.router.server)
self.assertEqual(result.retcode, 0)
self.assertEqual(self.router.state, OFFLINE)
@Utils.rootonly
def test_stop_router_dryrun(self):
"""Stop a router in dryrun mode"""
self.net_up('forwarding=enabled')
# Start the router
self.router.start().launch()
self.fs._run_actions()
self.eh.clear()
# Then stop it
act = self.router.stop(dryrun=True)
text = 'lustre_rmmod'
self.check_dryrun(act, text, 'comp', 'stop', ['start', 'done'],
self.router, 'stop of router on %s' %
self.router.server)
self.assertEqual(self.router.state, MOUNTED)
@Utils.rootonly
def test_stop_router_already_done(self):
"""Stop an already stopped router fails"""
self.net_up('forwarding=enabled')
act = self.router.stop()
result = self.check_base(self.router, 'comp', act, ACT_OK,
['start', 'done'],
'stop of router on %s' % self.router.server)
self.assertEqual(str(result), "router is already disabled")
self.assertEqual(result.retcode, None)
self.assertEqual(self.router.state, OFFLINE)
def setUp(self):
CommonTestCase.setUp(self)
self.srv1 = Server(Utils.HOSTNAME, ["%s@tcp" % Utils.HOSTNAME])
self.router = self.fs.new_router(self.srv1)
self.srv1.unload_modules().launch()
self.fs._run_actions()
def setUp(self):
CommonTestCase.setUp(self)
self.srv = Server(Utils.HOSTNAME, ["%s@lo" % Utils.HOSTNAME],
hdlr=self.eh)
self._clean_modules()
