test/resources/linux/application.py

   1 #!/usr/bin/env python
   2 #
   3 #    NEPI, a framework to manage network experiments
   4 #    Copyright (C) 2013 INRIA
   5 #
   6 #    This program is free software: you can redistribute it and/or modify
   7 #    it under the terms of the GNU General Public License as published by
   8 #    the Free Software Foundation, either version 3 of the License, or
   9 #    (at your option) any later version.
  10 #
  11 #    This program is distributed in the hope that it will be useful,
  12 #    but WITHOUT ANY WARRANTY; without even the implied warranty of
  13 #    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  14 #    GNU General Public License for more details.
  15 #
  16 #    You should have received a copy of the GNU General Public License
  17 #    along with this program.  If not, see <http://www.gnu.org/licenses/>.
  18 #
  19 # Author: Alina Quereilhac <alina.quereilhac@inria.fr>
  20
  21
  22 from nepi.execution.ec import ExperimentController
  23 from nepi.execution.resource import ResourceState, ResourceAction
  24 from nepi.execution.trace import TraceAttr
  25 from nepi.resources.linux.node import LinuxNode
  26 from nepi.resources.linux.application import LinuxApplication
  27
  28 from test_utils import skipIfNotAlive, skipInteractive
  29
  30 import os
  31 import time
  32 import tempfile
  33 import unittest
  34
  35 class LinuxApplicationTestCase(unittest.TestCase):
  36     def setUp(self):
  37         self.fedora_host = "nepi2.pl.sophia.inria.fr"
  38         self.fedora_host = "planetlab2.u-strasbg.fr"
  39         self.fedora_user = "inria_nepi"
  40
  41         self.ubuntu_host = "roseval.pl.sophia.inria.fr"
  42         self.ubuntu_user = "alina"
  43
  44         self.target = "nepi5.pl.sophia.inria.fr"
  45
  46     @skipIfNotAlive
  47     def t_stdout(self, host, user):
  48         from nepi.execution.resource import ResourceFactory
  49
  50         ResourceFactory.register_type(LinuxNode)
  51         ResourceFactory.register_type(LinuxApplication)
  52
  53         ec = ExperimentController()
  54
  55         node = ec.register_resource("LinuxNode")
  56         ec.set(node, "hostname", host)
  57         ec.set(node, "username", user)
  58         ec.set(node, "cleanHome", True)
  59         ec.set(node, "cleanProcesses", True)
  60
  61         app = ec.register_resource("LinuxApplication")
  62         cmd = "echo 'HOLA'"
  63         ec.set(app, "command", cmd)
  64         ec.register_connection(app, node)
  65
  66         ec.deploy()
  67
  68         ec.wait_finished([app])
  69
  70         self.assertTrue(ec.state(node) == ResourceState.STARTED)
  71         self.assertTrue(ec.state(app) == ResourceState.FINISHED)
  72
  73         stdout = ec.trace(app, "stdout")
  74         self.assertTrue(stdout.strip() == "HOLA")
  75
  76         ec.shutdown()
  77
  78     @skipIfNotAlive
  79     def t_ping(self, host, user):
  80         from nepi.execution.resource import ResourceFactory
  81
  82         ResourceFactory.register_type(LinuxNode)
  83         ResourceFactory.register_type(LinuxApplication)
  84
  85         ec = ExperimentController()
  86
  87         node = ec.register_resource("LinuxNode")
  88         ec.set(node, "hostname", host)
  89         ec.set(node, "username", user)
  90         ec.set(node, "cleanHome", True)
  91         ec.set(node, "cleanProcesses", True)
  92
  93         app = ec.register_resource("LinuxApplication")
  94         cmd = "ping -c5 %s" % self.target
  95         ec.set(app, "command", cmd)
  96
  97         ec.register_connection(app, node)
  98
  99         ec.deploy()
 100
 101         ec.wait_finished([app])
 102
 103         self.assertTrue(ec.state(node) == ResourceState.STARTED)
 104         self.assertTrue(ec.state(app) == ResourceState.FINISHED)
 105
 106         stdout = ec.trace(app, "stdout")
 107         size = ec.trace(app, "stdout", attr = TraceAttr.SIZE)
 108         self.assertEquals(len(stdout), size)
 109
 110         block = ec.trace(app, "stdout", attr = TraceAttr.STREAM, block = 5, offset = 1)
 111         self.assertEquals(block, stdout[5:10])
 112
 113         path = ec.trace(app, "stdout", attr = TraceAttr.PATH)
 114         rm = ec.get_resource(app)
 115         p = os.path.join(rm.app_home, "stdout")
 116         self.assertEquals(path, p)
 117
 118         ec.shutdown()
 119
 120     @skipIfNotAlive
 121     def t_concurrency(self, host, user):
 122         from nepi.execution.resource import ResourceFactory
 123
 124         ResourceFactory.register_type(LinuxNode)
 125         ResourceFactory.register_type(LinuxApplication)
 126
 127         ec = ExperimentController()
 128
 129         node = ec.register_resource("LinuxNode")
 130         ec.set(node, "hostname", host)
 131         ec.set(node, "username", user)
 132         ec.set(node, "cleanHome", True)
 133         ec.set(node, "cleanProcesses", True)
 134
 135         apps = list()
 136         for i in xrange(50):
 137             app = ec.register_resource("LinuxApplication")
 138             cmd = "ping -c5 %s" % self.target
 139             ec.set(app, "command", cmd)
 140             ec.register_connection(app, node)
 141             apps.append(app)
 142
 143         ec.deploy()
 144
 145         ec.wait_finished(apps)
 146
 147         self.assertTrue(ec.state(node) == ResourceState.STARTED)
 148         self.assertTrue(
 149                all([ec.state(guid) == ResourceState.FINISHED \
 150                 for guid in apps])
 151                 )
 152
 153         for app in apps:
 154             stdout = ec.trace(app, 'stdout')
 155             size = ec.trace(app, 'stdout', attr = TraceAttr.SIZE)
 156             self.assertEquals(len(stdout), size)
 157
 158             block = ec.trace(app, 'stdout', attr = TraceAttr.STREAM, block = 5, offset = 1)
 159             self.assertEquals(block, stdout[5:10])
 160
 161             path = ec.trace(app, 'stdout', attr = TraceAttr.PATH)
 162             rm = ec.get_resource(app)
 163             p = os.path.join(rm.app_home, 'stdout')
 164             self.assertEquals(path, p)
 165
 166         ec.shutdown()
 167
 168     @skipIfNotAlive
 169     def t_condition(self, host, user, depends):
 170         from nepi.execution.resource import ResourceFactory
 171
 172         ResourceFactory.register_type(LinuxNode)
 173         ResourceFactory.register_type(LinuxApplication)
 174
 175         ec = ExperimentController()
 176
 177         node = ec.register_resource("LinuxNode")
 178         ec.set(node, "hostname", host)
 179         ec.set(node, "username", user)
 180         ec.set(node, "cleanHome", True)
 181         ec.set(node, "cleanProcesses", True)
 182
 183         server = ec.register_resource("LinuxApplication")
 184         cmd = "echo 'HOLA' | nc -l 3333"
 185         ec.set(server, "command", cmd)
 186         ec.set(server, "depends", depends)
 187         ec.register_connection(server, node)
 188
 189         client = ec.register_resource("LinuxApplication")
 190         cmd = "nc 127.0.0.1 3333"
 191         ec.set(client, "command", cmd)
 192         ec.register_connection(client, node)
 193
 194         ec.register_condition(client, ResourceAction.START, server, ResourceState.STARTED)
 195
 196         apps = [client, server]
 197
 198         ec.deploy()
 199
 200         ec.wait_finished(apps)
 201
 202         self.assertTrue(ec.state(node) == ResourceState.STARTED)
 203         self.assertTrue(ec.state(server) == ResourceState.FINISHED)
 204         self.assertTrue(ec.state(client) == ResourceState.FINISHED)
 205
 206         stdout = ec.trace(client, "stdout")
 207         self.assertTrue(stdout.strip() == "HOLA")
 208
 209         ec.shutdown()
 210
 211     @skipIfNotAlive
 212     def t_http_sources(self, host, user):
 213         from nepi.execution.resource import ResourceFactory
 214
 215         ResourceFactory.register_type(LinuxNode)
 216         ResourceFactory.register_type(LinuxApplication)
 217
 218         ec = ExperimentController()
 219
 220         node = ec.register_resource("LinuxNode")
 221         ec.set(node, "hostname", host)
 222         ec.set(node, "username", user)
 223         ec.set(node, "cleanHome", True)
 224         ec.set(node, "cleanProcesses", True)
 225
 226         sources = "http://nepi.inria.fr/code/nef/archive/tip.tar.gz " \
 227                 " http://nepi.inria.fr/code/nef/raw-file/8ace577d4079/src/nef/images/menu/connect.png"
 228
 229         app = ec.register_resource("LinuxApplication")
 230         ec.set(app, "sources", sources)
 231
 232         ec.register_connection(app, node)
 233
 234         ec.deploy()
 235
 236         ec.wait_finished([app])
 237
 238         self.assertTrue(ec.state(node) == ResourceState.STARTED)
 239         self.assertTrue(ec.state(app) == ResourceState.FINISHED)
 240
 241         exitcode = ec.trace(app, "http_sources_exitcode")
 242         self.assertTrue(exitcode.strip() == "0")
 243
 244         out = ec.trace(app, "http_sources_stdout")
 245         self.assertTrue(out.find("tip.tar.gz") > -1)
 246         self.assertTrue(out.find("connect.png") > -1)
 247
 248         ec.shutdown()
 249
 250     @skipIfNotAlive
 251     def t_xterm(self, host, user):
 252         from nepi.execution.resource import ResourceFactory
 253
 254         ResourceFactory.register_type(LinuxNode)
 255         ResourceFactory.register_type(LinuxApplication)
 256
 257         ec = ExperimentController()
 258
 259         node = ec.register_resource("LinuxNode")
 260         ec.set(node, "hostname", host)
 261         ec.set(node, "username", user)
 262         ec.set(node, "cleanHome", True)
 263         ec.set(node, "cleanProcesses", True)
 264
 265         app = ec.register_resource("LinuxApplication")
 266         ec.set(app, "command", "xterm")
 267         ec.set(app, "depends", "xterm")
 268         ec.set(app, "forwardX11", True)
 269
 270         ec.register_connection(app, node)
 271
 272         ec.deploy()
 273
 274         ec.wait_finished([app])
 275
 276         self.assertTrue(ec.state(app) == ResourceState.FINISHED)
 277
 278         ec.shutdown()
 279
 280     def test_stdout_fedora(self):
 281         self.t_stdout(self.fedora_host, self.fedora_user)
 282
 283     def test_stdout_ubuntu(self):
 284         self.t_stdout(self.ubuntu_host, self.ubuntu_user)
 285
 286     def test_ping_fedora(self):
 287         self.t_ping(self.fedora_host, self.fedora_user)
 288
 289     def test_ping_ubuntu(self):
 290         self.t_ping(self.ubuntu_host, self.ubuntu_user)
 291
 292     def test_concurrency_fedora(self):
 293         self.t_concurrency(self.fedora_host, self.fedora_user)
 294
 295     def test_concurrency_ubuntu(self):
 296         self.t_concurrency(self.ubuntu_host, self.ubuntu_user)
 297
 298     def test_condition_fedora(self):
 299         self.t_condition(self.fedora_host, self.fedora_user, "nc")
 300
 301     def test_condition_ubuntu(self):
 302         self.t_condition(self.ubuntu_host, self.ubuntu_user, "netcat")
 303
 304     def test_http_sources_fedora(self):
 305         self.t_http_sources(self.fedora_host, self.fedora_user)
 306
 307     def test_http_sources_ubuntu(self):
 308         self.t_http_sources(self.ubuntu_host, self.ubuntu_user)
 309
 310     @skipInteractive
 311     def test_xterm_ubuntu(self):
 312         """ Interactive test. Should not run automatically """
 313         self.t_xterm(self.ubuntu_host, self.ubuntu_user)
 314
 315
 316
 317 if __name__ == '__main__':
 318     unittest.main()
 319