# Author: Lucia Guevgeozian <lucia.guevgeozian_odizzio@inria.fr>
from nepi.execution.ec import ExperimentController
-#from nepi.execution.resource import ResourceAction, ResourceState, populate_factory
from nepi.resources.planetlab.node import PlanetlabNode
-from nepi.resources.planetlab.plcapi import PLCAPI
+from nepi.resources.planetlab.plcapi import PLCAPI, PLCAPIFactory
import os
import time
import unittest
+import multiprocessing
-
-class DummyEC(ExperimentController):
- pass
-
-def create_node(ec, username, pl_user, pl_password, hostname=None, country=None,
- operatingSystem=None, minBandwidth=None, minCpu=None):
+def create_node(ec, username, pl_user, pl_password, hostname = None,
+ country = None, operatingSystem = None, minBandwidth = None,
+ minCpu = None):
node = ec.register_resource("PlanetlabNode")
if pl_user:
ec.set(node, "pluser", pl_user)
if pl_password:
- ec.set(node, "password", pl_password)
+ ec.set(node, "plpassword", pl_password)
if hostname:
ec.set(node, "hostname", hostname)
ec.set(node, "cleanHome", True)
ec.set(node, "cleanProcesses", True)
- return ec
+ return node
class PLNodeFactoryTestCase(unittest.TestCase):
-
def test_creation_phase(self):
self.assertEquals(PlanetlabNode.rtype(), "PlanetlabNode")
- self.assertEquals(len(PlanetlabNode._attributes), 30)
- self.assertEquals(len(PlanetlabNode.blacklist), 0)
- self.assertEquals(len(PlanetlabNode.provisionlist), 0)
+ self.assertEquals(len(PlanetlabNode._attributes), 29)
class PLNodeTestCase(unittest.TestCase):
"""
- This tests use inria_sfatest slice, and certain nodes already added to the
- slice, and ONLY those in order for the test not to fail.
+ This tests use inria_sfatest slice, and planetlab2.utt.fr already added to
+ the slice, and ONLY this one in order for the test not to fail.
"""
def setUp(self):
- self.ec = DummyEC()
+ self.ec = ExperimentController()
self.username = "inria_sfatest"
self.pl_user = os.environ.get("PL_USER")
self.pl_password = os.environ.get("PL_PASS")
+ self.pl_url = "www.planet-lab.eu"
+ self.pl_ptn = "https://%(hostname)s:443/PLCAPI/"
def test_plapi(self):
"""
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.
- """
- self.ec = create_node(self.ec, self.username, self.pl_user,
+ """
+ node1 = create_node(self.ec, self.username, self.pl_user,
self.pl_password, country="France")
- plnode_rm = self.ec.get_resource(1)
- hostname = plnode_rm.get("hostname")
+ plnode_rm1 = self.ec.get_resource(node1)
+ hostname = plnode_rm1.get("hostname")
self.assertIsNone(hostname)
- self.assertIsNone(plnode_rm._node_to_provision)
+ self.assertIsNone(plnode_rm1._node_to_provision)
- api = plnode_rm.plapi
- self.assertIsInstance(api, PLCAPI)
+ api1 = plnode_rm1.plapi
+ self.assertIsInstance(api1, PLCAPI)
+ self.assertEquals(len(api1.reserved()), 0)
+ self.assertEquals(len(api1.blacklisted()), 0)
+
+ node2 = create_node(self.ec, self.username, self.pl_user,
+ self.pl_password, country="France")
+
+ plnode_rm2 = self.ec.get_resource(node2)
+ api2 = plnode_rm2.plapi
+ self.assertEquals(api1, api2)
# Set hostname attribute in order for the shutdown method not to fail
- plnode_rm._set_hostname_attr(7057)
+ plnode_rm1._set_hostname_attr(7057)
+ plnode_rm2._set_hostname_attr(7057)
def test_discover_inslice(self):
"""
the slice and match the constraints OS Fedora12 and country France.
Check planetlab2.utt.fr is alive if the test fails.
"""
- self.ec = create_node(self.ec, self.username, self.pl_user,
+ node = create_node(self.ec, self.username, self.pl_user,
self.pl_password, country="France", operatingSystem="f12")
- plnode_rm = self.ec.get_resource(1)
+ plnode_rm = self.ec.get_resource(node)
hostname = plnode_rm.get("hostname")
self.assertIsNone(hostname)
- plnode_rm.discoverl()
+ plnode_rm.discover()
self.assertEquals(plnode_rm._node_to_provision, 7057)
# Set hostname attribute in order for the shutdown method not to fail
discover method picks one that match constraints outside from the
slice.
"""
- self.ec = create_node(self.ec, self.username, self.pl_user,
+ node = create_node(self.ec, self.username, self.pl_user,
self.pl_password, country="France", operatingSystem="f14")
- plnode_rm = self.ec.get_resource(1)
- plnode_rm.discoverl()
+ plnode_rm = self.ec.get_resource(node)
+ plnode_rm.discover()
result = [14281, 1034, 7035] # nodes matching f14 and France
self.assertIn(plnode_rm._node_to_provision, result)
- self.assertIsNot(PlanetlabNode.provisionlist, list())
+ self.assertIsNot(plnode_rm.plapi.reserved(), set())
# Set hostname attribute in order for the shutdown method not to fail
plnode_rm._set_hostname_attr(plnode_rm._node_to_provision)
This test checks that if the user specify the hostname, only that node
is discovered.
"""
- self.ec = create_node(self.ec, self.username, self.pl_user,
+ node = create_node(self.ec, self.username, self.pl_user,
self.pl_password, hostname="planetlab1.sics.se")
- plnode_rm = self.ec.get_resource(1)
- plnode_rm.discoverl()
+ plnode_rm = self.ec.get_resource(node)
+ plnode_rm.discover()
self.assertEquals(plnode_rm._node_to_provision, 14871)
- self.assertEquals(PlanetlabNode.provisionlist, [14871])
+ self.assertEquals(plnode_rm.plapi.reserved(), set([14871]))
def test_discover_with_ranges(self):
"""
Checks that defining max or min attributes, the discover method works.
"""
- self.ec = create_node(self.ec, self.username, self.pl_user,
+ node = create_node(self.ec, self.username, self.pl_user,
self.pl_password, minCpu=50) #minBandwidth=500)
- plnode_rm = self.ec.get_resource(1)
- plnode_rm.discoverl()
+ plnode_rm = self.ec.get_resource(node)
+ plnode_rm.discover()
#result = [15815, 15814, 425, 417, 1054, 1102, 1107, 505, 1031]
result = [425, 15815, 15814, 14842, 427, 41, 14466]
self.assertIn(plnode_rm._node_to_provision, result)
- self.assertIsNot(PlanetlabNode.provisionlist, list())
+ self.assertIsNot(plnode_rm.plapi.reserved(), set())
# Set hostname attribute in order for the shutdown method not to fail
plnode_rm._set_hostname_attr(plnode_rm._node_to_provision)
planetlab-1a.ics.uci.edu is used, if the test fails, check that the
result of the plcapi query is actually empty.
"""
- self.ec = create_node(self.ec, self.username, self.pl_user,
+ node = create_node(self.ec, self.username, self.pl_user,
self.pl_password, hostname="planetlab-1a.ics.uci.edu")
- plnode_rm = self.ec.get_resource(1)
- self.assertEquals(PlanetlabNode.blacklist, list())
+ plnode_rm = self.ec.get_resource(node)
+ self.assertEquals(plnode_rm.plapi.blacklisted(), set())
# check that the node is actually malfunctioning
api = plnode_rm.plapi
if not node_id:
with self.assertRaises(RuntimeError):
- plnode_rm.discoverl()
- self.assertEquals(PlanetlabNode.blacklist, [14871])
+ plnode_rm.discover()
+ self.assertEquals(plnode_rm.plapi.blacklisted(), set([14871]))
def test_provision_node_inslice(self):
"""
Check provision of the node planetlab2.utt.fr.
"""
- self.ec = create_node(self.ec, self.username, self.pl_user,
+ node = create_node(self.ec, self.username, self.pl_user,
self.pl_password, country="France", operatingSystem="f12")
- plnode_rm = self.ec.get_resource(1)
- self.assertEquals(len(PlanetlabNode.blacklist), 0)
- self.assertEquals(len(PlanetlabNode.provisionlist), 0)
+ plnode_rm = self.ec.get_resource(node)
+ self.assertEquals(len(plnode_rm.plapi.blacklisted()), 0)
+ self.assertEquals(len(plnode_rm.plapi.reserved()), 0)
- plnode_rm.discoverl()
- plnode_rm.provisionl()
+ plnode_rm.discover()
+ plnode_rm.provision()
ip = plnode_rm.get("ip")
self.assertEquals(ip, "194.254.215.12")
+ self.assertEquals(len(plnode_rm.plapi.reserved()), 1)
def test_provision_node_not_inslice(self):
"""
ple5.ipv6.lip6.fr
node2pl.planet-lab.telecom-lille1.eu
"""
- self.ec = create_node(self.ec, self.username, self.pl_user,
+ node = create_node(self.ec, self.username, self.pl_user,
self.pl_password, country="France", operatingSystem="f14")
- plnode_rm = self.ec.get_resource(1)
- self.assertEquals(PlanetlabNode.blacklist, list())
- self.assertEquals(PlanetlabNode.provisionlist, list())
+ plnode_rm = self.ec.get_resource(node)
+ self.assertEquals(plnode_rm.plapi.blacklisted(), set())
+ self.assertEquals(plnode_rm.plapi.reserved(), set())
- plnode_rm.discoverl()
- plnode_rm.provisionl()
+ plnode_rm.discover()
+ plnode_rm.provision()
ip = plnode_rm.get("ip")
result = ["194.167.254.18","132.227.62.123","194.167.254.19"]
self.assertIn(ip, result)
-
def test_provision_more_than_available(self):
"""
Check that if the user wants to provision 4 nodes with fedora 14, he
gets RuntimeError, there are only 3 nodes f14.
"""
- self.ec = create_node(self.ec, self.username, self.pl_user,
+ node1 = create_node(self.ec, self.username, self.pl_user,
self.pl_password, country="France", operatingSystem="f14")
- plnode_rm1 = self.ec.get_resource(1)
- plnode_rm1.discoverl()
- plnode_rm1.provisionl()
+ plnode_rm1 = self.ec.get_resource(node1)
+ plnode_rm1.discover()
+ plnode_rm1.provision()
- self.ec = create_node(self.ec, self.username, self.pl_user,
+ node2 = create_node(self.ec, self.username, self.pl_user,
self.pl_password, country="France", operatingSystem="f14")
- plnode_rm2 = self.ec.get_resource(2)
- plnode_rm2.discoverl()
- plnode_rm2.provisionl()
+ plnode_rm2 = self.ec.get_resource(node2)
+ plnode_rm2.discover()
+ plnode_rm2.provision()
- self.ec = create_node(self.ec, self.username, self.pl_user,
+ node3 = create_node(self.ec, self.username, self.pl_user,
self.pl_password, country="France", operatingSystem="f14")
- plnode_rm3 = self.ec.get_resource(3)
+ plnode_rm3 = self.ec.get_resource(node3)
with self.assertRaises(RuntimeError):
- plnode_rm3.discoverl()
+ plnode_rm3.discover()
with self.assertRaises(RuntimeError):
- plnode_rm3.provisionl()
+ plnode_rm3.provision()
- self.ec = create_node(self.ec, self.username, self.pl_user,
+ node4 = create_node(self.ec, self.username, self.pl_user,
self.pl_password, country="France", operatingSystem="f14")
- plnode_rm4 = self.ec.get_resource(4)
+ plnode_rm4 = self.ec.get_resource(node4)
with self.assertRaises(RuntimeError):
- plnode_rm4.discoverl()
- with self.assertRaises(RuntimeError):
- plnode_rm4.provisionl()
+ plnode_rm4.discover()
+
+ host1 = plnode_rm1.get('hostname')
+
+ plnode_rm3._set_hostname_attr(host1)
+ plnode_rm4._set_hostname_attr(host1)
+
+ def test_concurrence(self):
+ """
+ Test with the nodes being discover and provision at the same time.
+ """
+ node1 = create_node(self.ec, self.username, self.pl_user,
+ self.pl_password, country="France", operatingSystem="f14")
+
+ node2 = create_node(self.ec, self.username, self.pl_user,
+ self.pl_password, country="France", operatingSystem="f14")
+
+ node3 = create_node(self.ec, self.username, self.pl_user,
+ self.pl_password, country="France", operatingSystem="f14")
+
+ node4 = create_node(self.ec, self.username, self.pl_user,
+ self.pl_password, country="France", operatingSystem="f14")
+ self.ec.deploy()
+ self.ec.wait_finished([node1, node2, node3, node4])
+ state = self.ec.ecstate
+ self.assertEquals(state, 2)
def tearDown(self):
- PlanetlabNode.provisionlist = list()
- PlanetlabNode.blacklist = list()
+ commonapi=PLCAPIFactory.get_api(self.pl_user, self.pl_password,
+ self.pl_url, self.pl_ptn)
+ commonapi._reserved = set()
+ commonapi._blacklist = set()
self.ec.shutdown()