sfa/util/rspecHelper.py

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