sfa/util/rspecHelper.py

   1 #! /usr/bin/env python
   2
   3 import sys
   4
   5 from copy import deepcopy
   6 from lxml import etree
   7 from StringIO import StringIO
   8 from optparse import OptionParser
   9
  10 from sfa.util.faults import *
  11 from sfa.util.sfalogging import sfa_logger
  12
  13 def merge_rspecs(rspecs):
  14     """
  15     Merge merge a list of RSpecs into 1 RSpec, and return the result.
  16     rspecs must be a valid RSpec string or list of RSpec strings.
  17     """
  18     if not rspecs or not isinstance(rspecs, list):
  19         return rspecs
  20
  21     # ugly hack to avoid sending the same info twice, when the call graph has dags
  22     known_networks={}
  23     def register_network (network):
  24         try:
  25             known_networks[network.get('name')]=True
  26         except:
  27             sfa_logger().error("merge_rspecs: cannot register network with no name in rspec")
  28             pass
  29     def is_registered_network (network):
  30         try:
  31             return network.get('name') in known_networks
  32         except:
  33             sfa_logger().error("merge_rspecs: cannot retrieve network with no name in rspec")
  34             return False
  35
  36     # the resulting tree
  37     rspec = None
  38     for input_rspec in rspecs:
  39         try:
  40             tree = etree.parse(StringIO(input_rspec))
  41         except etree.XMLSyntaxError:
  42             # consider failing silently here
  43             sfa_logger().log_exc("merge_rspecs, parse error")
  44             message = str(sys.exc_info()[1]) + ' with ' + input_rspec
  45             raise InvalidRSpec(message)
  46
  47         root = tree.getroot()
  48         if not root.get("type") in ["SFA"]:
  49             sfa_logger().error("merge_rspecs: unexpected type for rspec root, %s"%root.get('type'))
  50             continue
  51         if rspec == None:
  52             # we scan the first input, register all networks
  53             # in addition we remove duplicates - needed until everyone runs 1.0-10
  54             rspec = root
  55             for network in root.iterfind("./network"):
  56                 if not is_registered_network(network):
  57                     register_network(network)
  58                 else:
  59                     # duplicate in the first input - trash it
  60                     root.remove(network)
  61         else:
  62             for network in root.iterfind("./network"):
  63                 if not is_registered_network(network):
  64                     rspec.append(deepcopy(network))
  65                     register_network(network)
  66             for request in root.iterfind("./request"):
  67                 rspec.append(deepcopy(request))
  68     return etree.tostring(rspec, xml_declaration=True, pretty_print=True)
  69
  70 class RSpec:
  71     def __init__(self, xml):
  72         parser = etree.XMLParser(remove_blank_text=True)
  73         tree = etree.parse(StringIO(xml), parser)
  74         self.rspec = tree.getroot()
  75
  76         # If there is only one network in the rspec, make it the default
  77         self.network = None
  78         networks = self.get_network_list()
  79         if len(networks) == 1:
  80             self.network = networks[0]
  81
  82     # Thierry : need this to locate hostname even if several networks
  83     def get_node_element(self, hostname, network=None):
  84         if network == None and self.network:
  85             network = self.network
  86         if network != None:
  87             names = self.rspec.iterfind("./network[@name='%s']/site/node/hostname" % network)
  88         else:
  89             names = self.rspec.iterfind("./network/site/node/hostname")
  90         for name in names:
  91             if name.text == hostname:
  92                 return name.getparent()
  93         return None
  94
  95     # Thierry : need this to return all nodes in all networks
  96     def get_node_list(self, network=None):
  97         if network == None and self.network:
  98             network = self.network
  99         if network != None:
 100             return self.rspec.xpath("./network[@name='%s']/site/node/hostname/text()" % network)
 101         else:
 102             return self.rspec.xpath("./network/site/node/hostname/text()")
 103
 104     def get_network_list(self):
 105         return self.rspec.xpath("./network[@name]/@name")
 106
 107     def get_sliver_list(self, network=None):
 108         if network == None:
 109             network = self.network
 110         result = self.rspec.xpath("./network[@name='%s']/site/node[sliver]/hostname/text()" % network)
 111         return result
 112
 113     def get_available_node_list(self, network=None):
 114         if network == None:
 115             network = self.network
 116         result = self.rspec.xpath("./network[@name='%s']/site/node[not(sliver)]/hostname/text()" % network)
 117         return result
 118
 119     def add_sliver(self, hostname, network=None):
 120         if network == None:
 121             network = self.network
 122         node = self.get_node_element(hostname, network)
 123         etree.SubElement(node, "sliver")
 124
 125     def remove_sliver(self, hostname, network=None):
 126         if network == None:
 127             network = self.network
 128         node = self.get_node_element(hostname, network)
 129         node.remove(node.find("sliver"))
 130
 131     def attributes_list(self, elem):
 132         opts = []
 133         if elem is not None:
 134             for e in elem:
 135                 opts.append((e.tag, e.text))
 136         return opts
 137
 138     def get_default_sliver_attributes(self, network=None):
 139         if network == None:
 140             network = self.network
 141         defaults = self.rspec.find("./network[@name='%s']/sliver_defaults" % network)
 142         return self.attributes_list(defaults)
 143
 144     def get_sliver_attributes(self, hostname, network=None):
 145         if network == None:
 146             network = self.network
 147         node = self.get_node_element(hostname, network)
 148         sliver = node.find("sliver")
 149         return self.attributes_list(sliver)
 150
 151     def add_attribute(self, elem, name, value):
 152         opt = etree.SubElement(elem, name)
 153         opt.text = value
 154
 155     def add_default_sliver_attribute(self, name, value, network=None):
 156         if network == None:
 157             network = self.network
 158         defaults = self.rspec.find("./network[@name='%s']/sliver_defaults" % network)
 159         if defaults is None:
 160             defaults = etree.Element("sliver_defaults")
 161             network = self.rspec.find("./network[@name='%s']" % network)
 162             network.insert(0, defaults)
 163         self.add_attribute(defaults, name, value)
 164
 165     def add_sliver_attribute(self, hostname, name, value, network=None):
 166         if network == None:
 167             network = self.network
 168         node = self.get_node_element(hostname, network)
 169         sliver = node.find("sliver")
 170         self.add_attribute(sliver, name, value)
 171
 172     def remove_attribute(self, elem, name, value):
 173         if elem is not None:
 174             opts = elem.iterfind(name)
 175             if opts is not None:
 176                 for opt in opts:
 177                     if opt.text == value:
 178                         elem.remove(opt)
 179
 180     def remove_default_sliver_attribute(self, name, value, network=None):
 181         if network == None:
 182             network = self.network
 183         defaults = self.rspec.find("./network[@name='%s']/sliver_defaults" % network)
 184         self.remove_attribute(defaults, name, value)
 185
 186     def remove_sliver_attribute(self, hostname, name, value, network=None):
 187         if network == None:
 188             network = self.network
 189         node = self.get_node_element(hostname, network)
 190         sliver = node.find("sliver")
 191         self.remove_attribute(sliver, name, value)
 192
 193     def get_site_nodes(self, siteid, network=None):
 194         if network == None:
 195             network = self.network
 196         query = './network[@name="%s"]/site[@id="%s"]/node/hostname/text()' % (network, siteid)
 197         result = self.rspec.xpath(query)
 198         return result
 199
 200     def get_link_list(self, network=None):
 201         if network == None:
 202             network = self.network
 203         linklist = []
 204         links = self.rspec.iterfind("./network[@name='%s']/link" % network)
 205         for link in links:
 206             (end1, end2) = link.get("endpoints").split()
 207             name = link.find("description")
 208             linklist.append((name.text,
 209                              self.get_site_nodes(end1, network),
 210                              self.get_site_nodes(end2, network)))
 211         return linklist
 212
 213     def get_vlink_list(self, network=None):
 214         if network == None:
 215             network = self.network
 216         vlinklist = []
 217         vlinks = self.rspec.iterfind("./network[@name='%s']//vlink" % network)
 218         for vlink in vlinks:
 219             endpoints = vlink.get("endpoints")
 220             (end1, end2) = endpoints.split()
 221             query = './network[@name="%s"]//node[@id="%s"]/hostname/text()' % network
 222             node1 = self.rspec.xpath(query % end1)[0]
 223             node2 = self.rspec.xpath(query % end2)[0]
 224             desc = "%s <--> %s" % (node1, node2)
 225             kbps = vlink.find("kbps")
 226             vlinklist.append((endpoints, desc, kbps.text))
 227         return vlinklist
 228
 229     def query_links(self, fromnode, tonode, network=None):
 230         if network == None:
 231             network = self.network
 232         fromsite = fromnode.getparent()
 233         tosite = tonode.getparent()
 234         fromid = fromsite.get("id")
 235         toid = tosite.get("id")
 236
 237         query = "./network[@name='%s']/link[@endpoints = '%s %s']" % (network, fromid, toid)
 238         results = self.rspec.xpath(query)
 239         if results == None:
 240             query = "./network[@name='%s']/link[@endpoints = '%s %s']" % (network, toid, fromid)
 241             results = self.rspec.xpath(query)
 242         return results
 243
 244     def query_vlinks(self, endpoints, network=None):
 245         if network == None:
 246             network = self.network
 247         query = "./network[@name='%s']//vlink[@endpoints = '%s']" % (network, endpoints)
 248         results = self.rspec.xpath(query)
 249         return results
 250
 251
 252     def add_vlink(self, fromhost, tohost, kbps, network=None):
 253         if network == None:
 254             network = self.network
 255         fromnode = self.get_node_element(fromhost, network)
 256         tonode = self.get_node_element(tohost, network)
 257         links = self.query_links(fromnode, tonode, network)
 258
 259         for link in links:
 260             vlink = etree.SubElement(link, "vlink")
 261             fromid = fromnode.get("id")
 262             toid = tonode.get("id")
 263             vlink.set("endpoints", "%s %s" % (fromid, toid))
 264             self.add_attribute(vlink, "kbps", kbps)
 265
 266
 267     def remove_vlink(self, endpoints, network=None):
 268         if network == None:
 269             network = self.network
 270         vlinks = self.query_vlinks(endpoints, network)
 271         for vlink in vlinks:
 272             vlink.getparent().remove(vlink)
 273
 274     def toxml(self):
 275         return etree.tostring(self.rspec, pretty_print=True,
 276                               xml_declaration=True)
 277
 278     def __str__(self):
 279         return self.toxml()
 280
 281     def save(self, filename):
 282         f = open(filename, "w")
 283         f.write(self.toxml())
 284         f.close()
 285
 286
 287 class Commands:
 288     def __init__(self, usage, description, epilog=None):
 289         self.parser = OptionParser(usage=usage, description=description,
 290                                    epilog=epilog)
 291         self.parser.add_option("-i", "", dest="infile", metavar="FILE",
 292                                help="read RSpec from FILE (default is stdin)")
 293         self.parser.add_option("-o", "", dest="outfile", metavar="FILE",
 294                                help="write output to FILE (default is stdout)")
 295         self.nodefile = False
 296         self.attributes = {}
 297
 298     def add_nodefile_option(self):
 299         self.nodefile = True
 300         self.parser.add_option("-n", "", dest="nodefile",
 301                                metavar="FILE",
 302                                help="read node list from FILE"),
 303
 304     def add_show_attributes_option(self):
 305         self.parser.add_option("-s", "--show-attributes", action="store_true",
 306                                dest="showatt", default=False,
 307                                help="show sliver attributes")
 308
 309     def add_attribute_options(self):
 310         self.parser.add_option("", "--capabilities", action="append",
 311                                metavar="<cap1,cap2,...>",
 312                                help="Vserver bcapabilities")
 313         self.parser.add_option("", "--codemux", action="append",
 314                                metavar="<host,local-port>",
 315                                help="Demux HTTP between slices using " +
 316                                "localhost ports")
 317         self.parser.add_option("", "--cpu-pct", action="append",
 318                                metavar="<num>",
 319                                help="Reserved CPU percent (e.g., 25)")
 320         self.parser.add_option("", "--cpu-share", action="append",
 321                                metavar="<num>",
 322                                help="Number of CPU shares (e.g., 5)")
 323         self.parser.add_option("", "--delegations",
 324                                metavar="<slice1,slice2,...>", action="append",
 325                                help="List of slices with delegation authority")
 326         self.parser.add_option("", "--disk-max",
 327                                metavar="<num>", action="append",
 328                                help="Disk quota (1k disk blocks)")
 329         self.parser.add_option("", "--initscript",
 330                                metavar="<name>", action="append",
 331                                help="Slice initialization script (e.g., stork)")
 332         self.parser.add_option("", "--ip-addresses", action="append",
 333                                metavar="<IP addr>",
 334                                help="Add an IP address to a sliver")
 335         self.parser.add_option("", "--net-i2-max-kbyte",
 336                                metavar="<KBytes>", action="append",
 337                                help="Maximum daily network Tx limit " +
 338                                "to I2 hosts.")
 339         self.parser.add_option("", "--net-i2-max-rate",
 340                                metavar="<Kbps>", action="append",
 341                                help="Maximum bandwidth over I2 routes")
 342         self.parser.add_option("", "--net-i2-min-rate",
 343                                metavar="<Kbps>", action="append",
 344                                help="Minimum bandwidth over I2 routes")
 345         self.parser.add_option("", "--net-i2-share",
 346                                metavar="<num>", action="append",
 347                                help="Number of bandwidth shares over I2 routes")
 348         self.parser.add_option("", "--net-i2-thresh-kbyte",
 349                                metavar="<KBytes>", action="append",
 350                                help="Limit sent to I2 hosts before warning, " +
 351                                "throttling")
 352         self.parser.add_option("", "--net-max-kbyte",
 353                                metavar="<KBytes>", action="append",
 354                                help="Maximum daily network Tx limit " +
 355                                "to non-I2 hosts.")
 356         self.parser.add_option("", "--net-max-rate",
 357                                metavar="<Kbps>", action="append",
 358                                help="Maximum bandwidth over non-I2 routes")
 359         self.parser.add_option("", "--net-min-rate",
 360                                metavar="<Kbps>", action="append",
 361                                help="Minimum bandwidth over non-I2 routes")
 362         self.parser.add_option("", "--net-share",
 363                                metavar="<num>", action="append",
 364                                help="Number of bandwidth shares over non-I2 " +
 365                                "routes")
 366         self.parser.add_option("", "--net-thresh-kbyte",
 367                                metavar="<KBytes>", action="append",
 368                                help="Limit sent to non-I2 hosts before " +
 369                                "warning, throttling")
 370         self.parser.add_option("", "--vsys",
 371                                metavar="<name>", action="append",
 372                                help="Vsys script (e.g., fd_fusemount)")
 373         self.parser.add_option("", "--vsys-vnet",
 374                                metavar="<IP network>", action="append",
 375                                help="Allocate a virtual private network")
 376
 377     def get_attribute_dict(self):
 378         attrlist = ['capabilities','codemux','cpu_pct','cpu_share',
 379                     'delegations','disk_max','initscript','ip_addresses',
 380                     'net_i2_max_kbyte','net_i2_max_rate','net_i2_min_rate',
 381                     'net_i2_share','net_i2_thresh_kbyte',
 382                     'net_max_kbyte','net_max_rate','net_min_rate',
 383                     'net_share','net_thresh_kbyte',
 384                     'vsys','vsys_vnet']
 385         attrdict = {}
 386         for attr in attrlist:
 387             value = getattr(self.opts, attr, None)
 388             if value is not None:
 389                 attrdict[attr] = value
 390         return attrdict
 391
 392     def prep(self):
 393         (self.opts, self.args) = self.parser.parse_args()
 394
 395         if self.opts.infile:
 396             sys.stdin = open(self.opts.infile, "r")
 397         xml = sys.stdin.read()
 398         self.rspec = RSpec(xml)
 399
 400         if self.nodefile:
 401             if self.opts.nodefile:
 402                 f = open(self.opts.nodefile, "r")
 403                 self.nodes = f.read().split()
 404                 f.close()
 405             else:
 406                 self.nodes = self.args
 407
 408         if self.opts.outfile:
 409             sys.stdout = open(self.opts.outfile, "w")
 410
 411
 412
 413
 414
 415
 416