src/nepi/resources/linux/interface.py

   1 from nepi.execution.attribute import Attribute, Types, Flags
   2 from nepi.execution.resource import ResourceManager, clsinit, ResourceState
   3 from nepi.resources.linux.node import LinuxNode
   4 from nepi.resources.linux.channel import LinuxChannel
   5
   6 import collections
   7 import logging
   8 import os
   9 import random
  10 import re
  11 import tempfile
  12 import time
  13
  14 # TODO: UP, MTU attributes!
  15
  16 reschedule_delay = "0.5s"
  17
  18 @clsinit
  19 class LinuxInterface(ResourceManager):
  20     _rtype = "LinuxInterface"
  21
  22     @classmethod
  23     def _register_attributes(cls):
  24         ip4 = Attribute("ip4", "IPv4 Address",
  25                 flags = Flags.ExecReadOnly)
  26
  27         ip6 = Attribute("ip6", "IPv6 Address",
  28                 flags = Flags.ExecReadOnly)
  29
  30         mac = Attribute("mac", "MAC Address",
  31                 flags = Flags.ExecReadOnly)
  32
  33         mask4 = Attribute("mask4", "IPv4 network mask",
  34                 flags = Flags.ExecReadOnly)
  35
  36         mask6 = Attribute("mask6", "IPv6 network mask",
  37                 type = Types.Integer,
  38                 flags = Flags.ExecReadOnly)
  39
  40         mtu = Attribute("mtu", "Maximum transmition unit for device",
  41             type = Types.Integer)
  42
  43         devname = Attribute("deviceName",
  44                 "Name of the network interface (e.g. eth0, wlan0, etc)",
  45                 flags = Flags.ExecReadOnly)
  46
  47         up = Attribute("up", "Link up", type = Types.Bool)
  48
  49         tear_down = Attribute("tearDown", "Bash script to be executed before " + \
  50                 "releasing the resource",
  51                 flags = Flags.ExecReadOnly)
  52
  53         cls._register_attribute(ip4)
  54         cls._register_attribute(ip6)
  55         cls._register_attribute(mac)
  56         cls._register_attribute(mask4)
  57         cls._register_attribute(mask6)
  58         cls._register_attribute(mtu)
  59         cls._register_attribute(devname)
  60         cls._register_attribute(up)
  61         cls._register_attribute(tear_down)
  62
  63     def __init__(self, ec, guid):
  64         super(LinuxInterface, self).__init__(ec, guid)
  65         self._configured = False
  66
  67         self._logger = logging.getLogger("LinuxInterface")
  68
  69         self.add_set_hooks()
  70
  71     def log_message(self, msg):
  72         return " guid %d - host %s - %s " % (self.guid,
  73                 self.node.get("hostname"), msg)
  74
  75     @property
  76     def node(self):
  77         node = self.get_connected(LinuxNode.rtype())
  78         if node: return node[0]
  79         return None
  80
  81     @property
  82     def channel(self):
  83         chan = self.get_connected(LinuxChannel.rtype())
  84         if chan: return chan[0]
  85         return None
  86
  87     def discover(self, filters = None):
  88         devname = self.get("deviceName")
  89         ip4 = self.get("ip4")
  90         ip6 = self.get("ip4")
  91         mac = self.get("mac")
  92         mask4 = self.get("mask4")
  93         mask6 = self.get("mask6")
  94         mtu = self.get("mtu")
  95
  96         # Get current interfaces information
  97         (out, err), proc = self.node.execute("ifconfig", sudo = True)
  98
  99         if err and proc.poll():
 100             msg = " Error retrieving interface information "
 101             self.error(msg, out, err)
 102             raise RuntimeError, "%s - %s - %s" % (msg, out, err)
 103
 104         # Check if an interface is found matching the RM attributes
 105         ifaces = out.split("\n\n")
 106
 107         for i in ifaces:
 108             m = re.findall("(\w+)\s+Link\s+encap:\w+(\s+HWaddr\s+(([0-9a-fA-F]{2}:?){6}))?(\s+inet\s+addr:((\d+\.?){4}).+Mask:(\d+\.\d+\.\d+\.\d+))?(.+inet6\s+addr:\s+([0-9a-fA-F:.]+)/(\d+))?(.+(UP))?(.+MTU:(\d+))?", i, re.DOTALL)
 109
 110             m = m[0]
 111             dn = m[0]
 112             mc = m[2]
 113             i4 = m[5]
 114             msk4 = m[7]
 115             i6 = m[9]
 116             msk6 = m[10]
 117             up = True if m[12] else False
 118             mu = m[14]
 119
 120             self.debug("Found interface %(devname)s with MAC %(mac)s,"
 121                     "IPv4 %(ipv4)s %(mask4)s IPv6 %(ipv6)s/%(mask6)s %(up)s %(mtu)s" % ({
 122                 'devname': dn,
 123                 'mac': mc,
 124                 'ipv4': i4,
 125                 'mask4': msk4,
 126                 'ipv6': i6,
 127                 'mask6': msk6,
 128                 'up': up,
 129                 'mtu': mu
 130                 }) )
 131
 132             # If the user didn't provide information we take the first
 133             # interface that is UP
 134             if not devname and not ip4 and not ip6 and up:
 135                 self._configured = True
 136                 self.load_configuration(dn, mc, i4, msk4, i6, msk6, mu, up)
 137                 break
 138
 139             # If the user provided ipv4 or ipv6 matching that of an interface
 140             # load the interface info
 141             if (ip4 and ip4 == i4) or (ip6 and ip6 == i6):
 142                 self._configured = True
 143                 self.load_configuration(dn, mc, i4, msk4, i6, msk6, mu, up)
 144                 break
 145
 146             # If the user provided the device name we load the associated info
 147             if devname and devname == dn:
 148                 if ((ip4 and ip4 == i4) and (ipv6 and ip6 == i6)) or \
 149                         not (ip4 or ip6):
 150                     self._configured = True
 151
 152                 # If the user gave a different ip than the existing, asume ip
 153                 # needs to be changed
 154                 i4 = ip4 or i4
 155                 i6 = ip6 or i6
 156                 mu = mtu or mu
 157
 158                 self.load_configuration(dn, mc, i4, msk4, i6, msk6, mu, up)
 159                 break
 160
 161         if not self.get("deviceName"):
 162             msg = "Unable to resolve interface "
 163             self.error(msg)
 164             raise RuntimeError, msg
 165
 166         super(LinuxInterface, self).discover(filters = filters)
 167
 168     def provision(self, filters = None):
 169         devname = self.get("deviceName")
 170         ip4 = self.get("ip4")
 171         ip6 = self.get("ip4")
 172         mac = self.get("mac")
 173         mask4 = self.get("mask4")
 174         mask6 = self.get("mask6")
 175         mtu = self.get("mtu")
 176
 177         # Must configure interface if configuration is required
 178         if not self._configured:
 179             cmd = "ifconfig %s" % devname
 180
 181             if ip4 and mask4:
 182                 cmd += " %(ip4)s netmask %(mask4)s broadcast %(bcast)s up" % ({
 183                     'ip4': ip4,
 184                     'mask4': mask4,
 185                     'bcast': bcast})
 186             if mtu:
 187                 cmd += " mtu %d " % mtu
 188
 189             (out, err), proc = self.node.execute(cmd, sudo = True)
 190
 191             if err and proc.poll():
 192                 msg = "Error configuring interface with command '%s'" % cmd
 193                 self.error(msg, out, err)
 194                 raise RuntimeError, "%s - %s - %s" % (msg, out, err)
 195
 196             if ip6 and mask6:
 197                 cmd = "ifconfig %(devname)s inet6 add %(ip6)s/%(mask6)d" % ({
 198                         'devname': devname,
 199                         'ip6': ip6,
 200                         'mask6': mask6})
 201
 202             (out, err), proc = self.node.execute(cmd, sudo = True)
 203
 204             if err and proc.poll():
 205                 msg = "Error seting ipv6 for interface using command '%s' " % cmd
 206                 self.error(msg, out, err)
 207                 raise RuntimeError, "%s - %s - %s" % (msg, out, err)
 208
 209         super(LinuxInterface, self).provision(filters = filters)
 210
 211     def deploy(self):
 212         # Wait until node is provisioned
 213         node = self.node
 214         chan = self.channel
 215
 216         if not node or node.state < ResourceState.PROVISIONED:
 217             self.ec.schedule(reschedule_delay, self.deploy)
 218         elif not chan or chan.state < ResourceState.READY:
 219             self.ec.schedule(reschedule_delay, self.deploy)
 220         else:
 221             # Verify if the interface exists in node. If not, configue
 222             # if yes, load existing configuration
 223             try:
 224                 self.discover()
 225                 self.provision()
 226             except:
 227                 self._state = ResourceState.FAILED
 228                 raise
 229
 230             super(LinuxInterface, self).deploy()
 231
 232     def release(self):
 233         tear_down = self.get("tearDown")
 234         if tear_down:
 235             self.execute(tear_down)
 236
 237         super(LinuxInterface, self).release()
 238
 239     def valid_connection(self, guid):
 240         # TODO: Validate!
 241         return True
 242
 243     def load_configuration(self, devname, mac, ip4, mask4, ip6, mask6, mtu, up):
 244         self.set("deviceName", devname)
 245         self.set("mac", mac)
 246         self.set("ip4", ip4)
 247         self.set("mask4", mask4)
 248         self.set("ip6", ip6)
 249         self.set("mask6", mask6)
 250
 251         # set the following without validating or triggering hooks
 252         attr = self._attrs["up"]
 253         attr._value = up
 254         attr = self._attrs["mtu"]
 255
 256     def add_set_hooks(self):
 257         attrup = self._attrs["up"]
 258         attrup.set_hook = self.set_hook_up
 259
 260         attrmtu = self._attrs["mtu"]
 261         attrmtu.set_hook = self.set_hook_mtu
 262
 263     def set_hook_up(self, oldval, newval):
 264         if oldval == newval:
 265             return oldval
 266
 267         # configure interface up
 268         if newval == True:
 269             cmd = "ifup %s" % self.get("deviceName")
 270         elif newval == False:
 271             cmd = "ifdown %s" % self.get("deviceName")
 272
 273         (out, err), proc = self.node.execute(cmd, sudo = True)
 274
 275         if err and proc.poll():
 276             msg = "Error setting interface up/down using command '%s' " % cmd
 277             self.error(msg, err, out)
 278             return oldval
 279
 280         return newval
 281
 282     def set_hook_mtu(self, oldval, newval):
 283         if oldval == newval:
 284             return oldval
 285
 286         cmd = "ifconfig %s mtu %d" % (self.get("deviceName"), newval)
 287
 288         (out, err), proc = self.node.execute(cmd, sudo = True)
 289
 290         if err and proc.poll():
 291             msg = "Error setting interface MTU using command '%s' " % cmd
 292             self.error(msg, err, out)
 293             return  oldval
 294
 295         return newval
 296