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 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 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 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 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()