src/nepi/resources/planetlab/openvswitch/ovs.py

   1 #
   2 #    NEPI, a framework to manage network experiments
   3 #    Copyright (C) 2013 INRIA
   4 #
   5 #    This program is free software: you can redistribute it and/or modify
   6 #    it under the terms of the GNU General Public License as published by
   7 #    the Free Software Foundation, either version 3 of the License, or
   8 #    (at your option) any later version.
   9 #
  10 #    This program is distributed in the hope that it will be useful,
  11 #    but WITHOUT ANY WARRANTY; without even the implied warranty of
  12 #    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  13 #    GNU General Public License for more details.
  14 #
  15 #    You should have received a copy of the GNU General Public License
  16 #    along with this program.  If not, see <http://www.gnu.org/licenses/>.
  17 #
  18 # Author: Alina Quereilhac <alina.quereilhac@inria.fr>
  19 #         Alexandros Kouvakas <alexandros.kouvakas@inria.fr>
  20
  21
  22 from nepi.execution.resource import ResourceManager, clsinit_copy, \
  23         ResourceState
  24 from nepi.execution.attribute import Attribute, Flags
  25 from nepi.resources.planetlab.node import PlanetlabNode
  26 from nepi.resources.linux.application import LinuxApplication
  27 import os
  28
  29 reschedule_delay = "0.5s"
  30
  31 @clsinit_copy
  32 class OVSWitch(LinuxApplication):
  33
  34     _rtype = "OVSWitch"
  35     _help = "Runs an OpenVSwitch on a PlanetLab host"
  36     _backend = "planetlab"
  37
  38     _authorized_connections = ["PlanetlabNode", "OVSPort", "LinuxNode"]
  39
  40     @classmethod
  41     def _register_attributes(cls):
  42         """ Register the attributes of OVSWitch RM
  43
  44         """
  45         bridge_name = Attribute("bridge_name", "Name of the switch/bridge",
  46                 flags = Flags.Design)
  47         virtual_ip_pref = Attribute("virtual_ip_pref", "Virtual IP/PREFIX of the switch",
  48                 flags = Flags.Design)
  49         controller_ip = Attribute("controller_ip", "IP of the controller",
  50                 flags = Flags.Design)
  51         controller_port = Attribute("controller_port", "Port of the controller",
  52                 flags = Flags.Design)
  53
  54         cls._register_attribute(bridge_name)
  55         cls._register_attribute(virtual_ip_pref)
  56         cls._register_attribute(controller_ip)
  57         cls._register_attribute(controller_port)
  58
  59     def __init__(self, ec, guid):
  60         """
  61         :param ec: The Experiment controller
  62         :type ec: ExperimentController
  63         :param guid: guid of the RM
  64         :type guid: int
  65
  66         """
  67         super(OVSWitch, self).__init__(ec, guid)
  68         self._pid = None
  69         self._ppid = None
  70         self._home = "ovswitch-%s" % self.guid
  71         self._checks = "ovsChecks-%s" % self.guid
  72
  73     @property
  74     def node(self):
  75         node = self.get_connected(PlanetlabNode.get_rtype())
  76         if node: return node[0]
  77         return None
  78
  79     @property
  80     def ovs_home(self):
  81         return os.path.join(self.node.exp_home, self._home)
  82
  83     @property
  84     def ovs_checks(self):
  85         return os.path.join(self.ovs_home, self._checks)
  86
  87     @property
  88     def pid(self):
  89         return self._pid
  90
  91     @property
  92     def ppid(self):
  93         return self._ppid
  94
  95 #    def valid_connection(self, guid):
  96 #        """ Check if the connection with the guid in parameter is possible. Only meaningful connections are allowed.
  97
  98 #        :param guid: Guid of the current RM
  99 #        :type guid: int
 100 #        :rtype:  Boolean
 101
 102 #        """
 103 #        rm = self.ec.get_resource(guid)
 104 #        if rm.get_rtype() in self._authorized_connections:
 105 #            msg = "Connection between %s %s and %s %s accepted" % \
 106 #                (self.get_rtype(), self._guid, rm.get_rtype(), guid)
 107 #            self.debug(msg)
 108 #            return True
 109 #        msg = "Connection between %s %s and %s %s refused" % \
 110 #             (self.get_rtype(), self._guid, rm.get_rtype(), guid)
 111 #        self.debug(msg)
 112 #        return False
 113
 114     def valid_connection(self, guid):
 115         # TODO: Validate!
 116         return True
 117
 118     def do_provision(self):
 119         # create home dir for ovs
 120         self.node.mkdir(self.ovs_home)
 121         # create dir for ovs checks
 122         self.node.mkdir(self.ovs_checks)
 123
 124         super(OVSWitch, self).do_provision()
 125
 126     def check_sliver_ovs(self):
 127         """ Check if sliver-ovs exists. If it does not exist, we interrupt
 128         the execution immediately.
 129         """
 130         cmd = "compgen -c | grep sliver-ovs"
 131         out = err = ""
 132
 133         (out,err), proc = self.node.run_and_wait(cmd, self.ovs_checks,
 134                     shfile = "check_cmd.sh",
 135                 pidfile = "check_cmd_pidfile",
 136                 ecodefile = "check_cmd_exitcode",
 137                 sudo = True,
 138                 stdout = "check_cmd_stdout",
 139                 stderr = "check_cmd_stderr")
 140
 141         (out, err), proc = self.node.check_output(self.ovs_checks, 'check_cmd_exitcode')
 142
 143         if out != "0\n":
 144             msg = "Command sliver-ovs does not exist on the VM"
 145             self.debug(msg)
 146             raise RuntimeError, msg
 147
 148         msg = "Command sliver-ovs exists"
 149         self.debug(msg)
 150
 151     def do_deploy(self):
 152         """ Wait until node is associated and deployed
 153         """
 154         node = self.node
 155         if not node or node.state < ResourceState.READY:
 156             #self.debug("---- RESCHEDULING DEPLOY ---- node state %s " % self.node.state )
 157             self.ec.schedule(reschedule_delay, self.deploy)
 158             return
 159
 160         self.do_discover()
 161         self.do_provision()
 162         self.check_sliver_ovs()
 163         self.servers_on()
 164         self.create_bridge()
 165         self.assign_controller()
 166         self.ovs_status()
 167
 168         super(OVSWitch, self).do_deploy()
 169
 170     def servers_on(self):
 171         """ Start the openvswitch servers and also checking
 172             if they started successfully
 173         """
 174         self.info("Starting the OVSWitch servers")
 175         command = ("sliver-ovs start")
 176
 177         out = err = ""
 178         (out, err), proc = self.node.run_and_wait(command, self.ovs_checks,
 179                 shfile = "start_srv.sh",
 180                 pidfile = "start_srv_pidfile",
 181                 ecodefile = "start_srv_exitcode",
 182                 sudo = True,
 183                 raise_on_error = True,
 184                 stdout = "start_srv_stdout",
 185                 stderr = "start_srv_stderr")
 186
 187         (out, err), proc = self.node.check_output(self.ovs_checks, 'start_srv_exitcode')
 188
 189         if out != "0\n":
 190             self.error("Servers have not started")
 191             raise RuntimeError, msg
 192
 193         cmd = "ps -A | grep ovsdb-server"
 194         out = err = ""
 195         (out, err), proc = self.node.run_and_wait(cmd, self.ovs_checks,
 196                 shfile = "status_srv.sh",
 197                 pidfile = "status_srv_pidfile",
 198                 ecodefile = "status_srv_exitcode",
 199                 sudo = True,
 200                 stdout = "status_srv_stdout",
 201                 stderr = "status_srv_stderr")
 202
 203         # Check if the servers are running or not
 204         (out, err), proc = self.node.check_output(self.ovs_checks, 'status_srv_exitcode')
 205
 206         if out != "0\n":
 207             self.error("Servers are not running")
 208             raise RuntimeError, msg
 209
 210         self.info("Servers started")
 211
 212     def del_old_br(self):
 213         # TODO: Delete old bridges that might exist maybe by adding atribute
 214         """ With ovs-vsctl list-br
 215         """
 216         pass
 217
 218     def create_bridge(self):
 219         """ Create the bridge/switch and we check if we have any
 220             error during the SSH connection
 221         """
 222         # TODO: Add check for virtual_ip belonging to vsys_tag
 223         self.del_old_br()
 224
 225         if not (self.get("bridge_name") and self.get("virtual_ip_pref")):
 226             msg = "No assignment in one or both attributes"
 227             self.error(msg)
 228             self.debug("Bridge name is %s and virtual_ip_pref is %s" %\
 229                 (self.get("bridge_name"), self.get("virtual_ip_pref")) )
 230             raise AttributeError, msg
 231
 232         bridge_name = self.get("bridge_name")
 233         virtual_ip_pref = self.get("virtual_ip_pref")
 234         self.info(" Creating the bridge %s and assigning %s" %\
 235             (bridge_name, virtual_ip_pref) )
 236         cmd = "sliver-ovs create-bridge '%s' '%s'" %\
 237             (bridge_name, virtual_ip_pref)
 238         out = err = ""
 239         (out, err), proc = self.node.run_and_wait(cmd, self.ovs_checks,
 240                 shfile = "create_br.sh",
 241                 pidfile = "create_br_pidfile",
 242                 ecodefile = "create_br_exitcode",
 243                 sudo = True,
 244                 stdout = "create_br_stdout",
 245                 stderr = "create_br_stderr")
 246
 247         (out, err), proc = self.node.check_output(self.ovs_checks, 'create_br_exitcode')
 248         if out != "0\n":
 249             msg = "No such pltap netdev\novs-appctl: ovs-vswitchd: server returned an error"
 250             self.debug("Check again the virtual IP")
 251             raise RuntimeError, msg
 252
 253         self.info("Bridge %s created" % bridge_name)
 254
 255
 256     def assign_controller(self):
 257         """ Set the controller IP
 258         """
 259         if self.get("controller_ip") and self.get("controller_port"):
 260             controller_ip = self.get("controller_ip")
 261             controller_port = self.get("controller_port")
 262             self.info("Assigning the controller to the %s" % self.get("bridge_name"))
 263             cmd = "ovs-vsctl set-controller %s tcp:%s:%s" %\
 264                 (self.get("bridge_name"), controller_ip, controller_port)
 265             out = err = ""
 266             (out, err), proc = self.node.run(cmd, self.ovs_checks,
 267                     sudo = True,
 268                     stdout = "stdout",
 269                     stderr = "stderr")
 270             if err != "":
 271                 self.debug("SSH connection refusing in assign_contr")
 272                 raise RuntimeError, msg
 273             self.info("Controller assigned")
 274
 275     def ovs_status(self):
 276         """ Print the status of the created bridge
 277         """
 278         cmd = "sliver-ovs show | tail -n +2"
 279         out = err = ""
 280         (out, err), proc = self.node.run_and_wait(cmd, self.ovs_home,
 281                 sudo = True,
 282                 stdout = "show_stdout",
 283                 stderr = "show_stderr")
 284         (out, err), proc = self.node.check_output(self.ovs_home, 'show_stdout')
 285         self.info(out)
 286
 287     def do_release(self):
 288         """ Delete the bridge and
 289             close the servers
 290         """
 291         # Node needs to wait until all associated RMs are released
 292         # to be released
 293         from nepi.resources.planetlab.openvswitch.ovsport import OVSPort
 294         rm = self.get_connected(OVSPort.get_rtype())
 295
 296         if rm[0].state < ResourceState.STOPPED:
 297             self.ec.schedule(reschedule_delay, self.release)
 298             return
 299
 300         msg = "Deleting the bridge %s" % self.get('bridge_name')
 301         self.info(msg)
 302         cmd = "sliver-ovs del-bridge %s" % self.get('bridge_name')
 303         (out, err), proc = self.node.run(cmd, self.ovs_checks,
 304                 sudo = True)
 305         cmd = "sliver-ovs stop"
 306         (out, err), proc = self.node.run(cmd, self.ovs_checks,
 307                 sudo = True)
 308
 309         if proc.poll():
 310             self.error(msg, out, err)
 311             raise RuntimeError, msg
 312
 313         super(OVSWitch, self).do_release()
 314