X-Git-Url: http://git.onelab.eu/?a=blobdiff_plain;f=test%2Fresources%2Fplanetlab%2Fnode.py;h=57146453058120853f4366ee99418c86033bb3ee;hb=e55924b6886bd7382a28e1ae235c4810f852e163;hp=a002c176c0f1b5981bafb09d58fbe7ef3967f957;hpb=82cf9668b586573e32ccd8e7c582230790a1406f;p=nepi.git diff --git a/test/resources/planetlab/node.py b/test/resources/planetlab/node.py index a002c176..57146453 100755 --- a/test/resources/planetlab/node.py +++ b/test/resources/planetlab/node.py @@ -4,9 +4,8 @@ # Copyright (C) 2013 INRIA # # This program is free software: you can redistribute it and/or modify -# it under the terms of the GNU General Public License as published by -# the Free Software Foundation, either version 3 of the License, or -# (at your option) any later version. +# it under the terms of the GNU General Public License version 2 as +# published by the Free Software Foundation; # # This program is distributed in the hope that it will be useful, # but WITHOUT ANY WARRANTY; without even the implied warranty of @@ -36,9 +35,9 @@ class DummyEC(ExperimentController): def create_node(ec, username, pl_user=None, pl_password=None, pl_url=None, hostname=None, country=None, operatingSystem=None, minBandwidth=None, minCpu=None, - architecture=None, city=None): + architecture=None, city=None, ip=None): - node = ec.register_resource("PlanetlabNode") + node = ec.register_resource("planetlab::Node") if username: ec.set(node, "username", username) @@ -63,8 +62,10 @@ def create_node(ec, username, pl_user=None, pl_password=None, pl_url=None, ec.set(node, "architecture", architecture) if city: ec.set(node, "city", city) + if ip: + ec.set(node, "ip", ip) - ec.set(node, "cleanHome", True) + ec.set(node, "cleanExperiment", True) ec.set(node, "cleanProcesses", True) return node @@ -72,13 +73,15 @@ def create_node(ec, username, pl_user=None, pl_password=None, pl_url=None, class PLNodeFactoryTestCase(unittest.TestCase): def test_creation_phase(self): - self.assertEquals(PlanetlabNode._rtype, "PlanetlabNode") - self.assertEquals(len(PlanetlabNode._attributes), 30) + self.assertEquals(PlanetlabNode._rtype, "planetlab::Node") + self.assertEquals(len(PlanetlabNode._attributes), 32) class PLNodeTestCase(unittest.TestCase): """ - This tests use inria_nepi slice, and already added to - the slice, and ONLY this one in order for the test not to fail. + This tests use inria_nepi slice, from the test instance of MyPLC + nepiplc.pl.sophia.inria.fr. This test can fail if the user running + the test does not have a user in this instance of MyPLC or is not + added to the inria_nepi slice. """ def setUp(self): @@ -87,14 +90,18 @@ class PLNodeTestCase(unittest.TestCase): self.pl_user = os.environ.get("PL_USER") self.pl_password = os.environ.get("PL_PASS") self.pl_url = "nepiplc.pl.sophia.inria.fr" + commonapi=PLCAPIFactory.get_api(self.pl_user, self.pl_password, + self.pl_url) + commonapi.add_slice_nodes(self.username, ['nepi2.pl.sophia.inria.fr']) + commonapi._reserved = set() + commonapi._blacklist = set() @skipIfNotPLCredentials def test_plapi(self): """ Check that the api to discover and reserve resources is well - instanciated, and is an instance of PLCAPI. Ignore error while - executing the ec.shutdown method, the error is due to the name - of the host not being defined yet for this test. + instanciated, and is an instance of PLCAPI. Check that using + the same credentials, the same object of the api is used. """ node1 = create_node(self.ec, self.username, pl_user=self.pl_user, pl_password=self.pl_password, pl_url=self.pl_url, @@ -140,8 +147,9 @@ class PLNodeTestCase(unittest.TestCase): def test_discover_inslice(self): """ This test uses the fact that the node nepi2.pl.sophia.inria.fr is already in - the slice and match the constraints OS Fedora12 and arch x86_64. + the slice and match the constraints OS Fedora12 and arch x86_64. Check nepi2.pl.sophia.inria.fr is alive if the test fails. + The node_id of nepi2.pl.sophia.inria.fr is 3. """ node = create_node(self.ec, self.username, pl_user=self.pl_user, pl_password=self.pl_password, pl_url=self.pl_url, architecture="x86_64", @@ -152,9 +160,6 @@ class PLNodeTestCase(unittest.TestCase): hostname = plnode_rm.get("hostname") self.assertIsNone(hostname) - api = plnode_rm.plapi - api.add_slice_nodes(self.username, ['nepi2.pl.sophia.inria.fr']) - plnode_rm.do_discover() self.assertEquals(plnode_rm._node_to_provision, 3) @@ -198,6 +203,23 @@ class PLNodeTestCase(unittest.TestCase): self.assertEquals(plnode_rm._node_to_provision, 3) self.assertEquals(plnode_rm.plapi.reserved(), set([3])) + @skipIfNotPLCredentials + def test_discover_ip(self): + """ + This test checks that if the user specify the ip, only that node + is discovered. + """ + node = create_node(self.ec, self.username, pl_user=self.pl_user, + pl_password=self.pl_password, pl_url=self.pl_url, + ip="138.96.116.32") + + plnode_rm = self.ec.get_resource(node) + plnode_rm.do_discover() + + self.assertEquals(plnode_rm._node_to_provision, 3) + self.assertEquals(plnode_rm.plapi.reserved(), set([3])) + self.assertEquals(plnode_rm.get("hostname"), "nepi2.pl.sophia.inria.fr") + @skipIfNotPLCredentials def test_discover_with_ranges(self): """ @@ -255,9 +277,6 @@ class PLNodeTestCase(unittest.TestCase): self.assertEquals(len(plnode_rm.plapi.blacklisted()), 0) self.assertEquals(len(plnode_rm.plapi.reserved()), 0) - api = plnode_rm.plapi - api.add_slice_nodes(self.username, ['nepi2.pl.sophia.inria.fr']) - plnode_rm.do_discover() plnode_rm.do_provision() ip = plnode_rm.get("ip") @@ -279,9 +298,6 @@ class PLNodeTestCase(unittest.TestCase): self.assertEquals(plnode_rm.plapi.blacklisted(), set()) self.assertEquals(plnode_rm.plapi.reserved(), set()) - api = plnode_rm.plapi - api.add_slice_nodes(self.username, ['nepi2.pl.sophia.inria.fr']) - plnode_rm.do_discover() plnode_rm.do_provision() ip = plnode_rm.get("ip") @@ -289,86 +305,71 @@ class PLNodeTestCase(unittest.TestCase): result = ["138.96.116.33","138.96.116.35"] self.assertIn(ip, result) -# @skipIfNotPLCredentials -# def test_provision_more_than_available(self): -# """ -# Check that if the user wants to provision 3 nodes in Paris, he -# gets RuntimeError, there are only 2 nodes with city=Paris. -# """ -# node1 = create_node(self.ec, self.username, pl_user=self.pl_user, -# pl_password=self.pl_password, pl_url=self.pl_url, -# city="Paris", operatingSystem="f12") -# -# plnode_rm1 = self.ec.get_resource(node1) -# -# api = plnode_rm.plapi -# api.add_slice_nodes(self.username, ['nepi2.pl.sophia.inria.fr']) -# -# plnode_rm1.do_discover() -# plnode_rm1.do_provision() -# -# node2 = create_node(self.ec, self.username, pl_user=self.pl_user, -# pl_password=self.pl_password, pl_url=self.pl_url, -# city="Paris", operatingSystem="f12") -# -# plnode_rm2 = self.ec.get_resource(node2) -# plnode_rm2.do_discover() -# plnode_rm2.do_provision() -# -# node3 = create_node(self.ec, self.username, pl_user=self.pl_user, -# pl_password=self.pl_password, pl_url=self.pl_url, -# city="Paris", operatingSystem="f12") -# -# plnode_rm3 = self.ec.get_resource(node3) -# with self.assertRaises(RuntimeError): -# plnode_rm3.do_discover() -# with self.assertRaises(RuntimeError): -# plnode_rm3.do_provision() -# -# host1 = plnode_rm1.get('hostname') -# -# plnode_rm3._set_hostname_attr(host1) -# -# @skipIfNotPLCredentials -# def test_concurrence(self): -# """ -# Test with the nodes being discover and provision at the same time. -# It should fail as the test before. -# """ -# node1 = create_node(self.ec, self.username, pl_user=self.pl_user, -# pl_password=self.pl_password, pl_url=self.pl_url, -# architecture="x86_64", operatingSystem="f12") -# -# node2 = create_node(self.ec, self.username, pl_user=self.pl_user, -# pl_password=self.pl_password, pl_url=self.pl_url, -# architecture="x86_64", operatingSystem="f12") -# -# node3 = create_node(self.ec, self.username, pl_user=self.pl_user, -# pl_password=self.pl_password, pl_url=self.pl_url, -# architecture="x86_64", operatingSystem="f12") -# -# node4 = create_node(self.ec, self.username, pl_user=self.pl_user, -# pl_password=self.pl_password, pl_url=self.pl_url, -# architecture="x86_64", operatingSystem="f12") -# -# self.ec.deploy() -# self.ec.wait_finished([node1, node2, node3, node4]) -# state = self.ec.state(node1, hr=True) -# self.assertIn(state, ['READY', 'FAILED']) -# state = self.ec.state(node2, hr=True) -# self.assertIn(state, ['READY', 'FAILED']) -# state = self.ec.state(node3, hr=True) -# self.assertIn(state, ['READY', 'FAILED']) -# state = self.ec.state(node4, hr=True) -# self.assertIn(state, ['READY', 'FAILED']) + @skipIfNotPLCredentials + def test_provision_more_than_available(self): + """ + Check that if the user wants to provision 3 nodes in Paris, he + gets RuntimeError, there are only 2 nodes with city=Paris. + """ + node1 = create_node(self.ec, self.username, pl_user=self.pl_user, + pl_password=self.pl_password, pl_url=self.pl_url, + city="Paris", operatingSystem="f12") + + plnode_rm1 = self.ec.get_resource(node1) + plnode_rm1.do_discover() + plnode_rm1.do_provision() + + node2 = create_node(self.ec, self.username, pl_user=self.pl_user, + pl_password=self.pl_password, pl_url=self.pl_url, + city="Paris", operatingSystem="f12") + + plnode_rm2 = self.ec.get_resource(node2) + plnode_rm2.do_discover() + plnode_rm2.do_provision() + + node3 = create_node(self.ec, self.username, pl_user=self.pl_user, + pl_password=self.pl_password, pl_url=self.pl_url, + city="Paris", operatingSystem="f12") + + plnode_rm3 = self.ec.get_resource(node3) + with self.assertRaises(RuntimeError): + plnode_rm3.do_discover() + with self.assertRaises(RuntimeError): + plnode_rm3.do_provision() + + host1 = plnode_rm1.get('hostname') + + plnode_rm3._set_hostname_attr(host1) + + @skipIfNotPLCredentials + def test_concurrence(self): + """ + Test with the nodes being discover and provision at the same time. + The deploy should fail as the test before, there aren't 4 nodes of + that carachteristics. + """ + node1 = create_node(self.ec, self.username, pl_user=self.pl_user, + pl_password=self.pl_password, pl_url=self.pl_url, + architecture="x86_64", operatingSystem="f12") + + node2 = create_node(self.ec, self.username, pl_user=self.pl_user, + pl_password=self.pl_password, pl_url=self.pl_url, + architecture="x86_64", operatingSystem="f12") + + node3 = create_node(self.ec, self.username, pl_user=self.pl_user, + pl_password=self.pl_password, pl_url=self.pl_url, + architecture="x86_64", operatingSystem="f12") + + node4 = create_node(self.ec, self.username, pl_user=self.pl_user, + pl_password=self.pl_password, pl_url=self.pl_url, + architecture="x86_64", operatingSystem="f12") + + self.ec.deploy() + self.ec.wait_deployed([node1, node2, node3, node4]) + failure_level = self.ec._fm._failure_level + self.assertEqual(failure_level, 2) def tearDown(self): - commonapi=PLCAPIFactory.get_api(self.pl_user, self.pl_password, - self.pl_url) - #commonapi.add_slice_nodes(self.username, ['nepi2.pl.sophia.inria.fr']) - commonapi._reserved = set() - commonapi._blacklist = set() - self.ec.shutdown()