plc_config.py

   1 #!/usr/bin/python
   2 #
   3 # Merge PlanetLab Central (PLC) configuration files into a variety of
   4 # output formats. These files represent the global configuration for a
   5 # PLC installation.
   6 #
   7 # Mark Huang <mlhuang@cs.princeton.edu>
   8 # Copyright (C) 2006 The Trustees of Princeton University
   9 #
  10
  11 import codecs
  12 import os
  13 import re
  14 import sys
  15 import textwrap
  16 import time
  17 import traceback
  18 import types
  19 import xml.dom.minidom
  20 from xml.parsers.expat import ExpatError
  21 from StringIO import StringIO
  22 from optparse import OptionParser
  23
  24 class ConfigurationException(Exception): pass
  25
  26 class PLCConfiguration:
  27     """
  28     Configuration file store. Optionally instantiate with a file path
  29     or object:
  30
  31     plc = PLCConfiguration()
  32     plc = PLCConfiguration(fileobj)
  33     plc = PLCConfiguration("/etc/planetlab/plc_config.xml")
  34
  35     You may load() additional files later, which will be merged into
  36     the current configuration:
  37
  38     plc.load("/etc/planetlab/local.xml")
  39
  40     You may also save() the configuration. If a file path or object is
  41     not specified, the configuration will be written to the file path
  42     or object that was first loaded.
  43
  44     plc.save()
  45     plc.save("/etc/planetlab/plc_config.xml")
  46     """
  47
  48     def __init__(self, file = None):
  49         impl = xml.dom.minidom.getDOMImplementation()
  50         self._dom = impl.createDocument(None, "configuration", None)
  51         self._variables = {}
  52         self._packages = {}
  53         self._files = []
  54
  55         if file is not None:
  56             self.load(file)
  57
  58
  59     def _get_text(self, node):
  60         """
  61         Get the text of a text node.
  62         """
  63
  64         if node.firstChild and \
  65            node.firstChild.nodeType == node.TEXT_NODE:
  66             if node.firstChild.data is None:
  67                 # Interpret simple presence of node as "", not NULL
  68                 return ""
  69             else:
  70                 return node.firstChild.data
  71
  72         return None
  73
  74
  75     def _get_text_of_child(self, parent, name):
  76         """
  77         Get the text of a (direct) child text node.
  78         """
  79
  80         for node in parent.childNodes:
  81             if node.nodeType == node.ELEMENT_NODE and \
  82                node.tagName == name:
  83                 return self._get_text(node)
  84
  85         return None
  86
  87
  88     def _set_text(self, node, data):
  89         """
  90         Set the text of a text node.
  91         """
  92
  93         if node.firstChild and \
  94            node.firstChild.nodeType == node.TEXT_NODE:
  95             if data is None:
  96                 node.removeChild(node.firstChild)
  97             else:
  98                 node.firstChild.data = data
  99         elif data is not None:
 100             text = TrimText()
 101             text.data = data
 102             node.appendChild(text)
 103
 104
 105     def _set_text_of_child(self, parent, name, data):
 106         """
 107         Set the text of a (direct) child text node.
 108         """
 109
 110         for node in parent.childNodes:
 111             if node.nodeType == node.ELEMENT_NODE and \
 112                node.tagName == name:
 113                 self._set_text(node, data)
 114                 return
 115
 116         child = TrimTextElement(name)
 117         self._set_text(child, data)
 118         parent.appendChild(child)
 119
 120
 121     def _category_element_to_dict(self, category_element):
 122         """
 123         Turn a <category> element into a dictionary of its attributes
 124         and child text nodes.
 125         """
 126
 127         category = {}
 128         category['id'] = category_element.getAttribute('id').lower()
 129         for node in category_element.childNodes:
 130             if node.nodeType == node.ELEMENT_NODE and \
 131                node.tagName in ['name', 'description']:
 132                 category[node.tagName] = self._get_text_of_child(category_element, node.tagName)
 133         category['element'] = category_element
 134
 135         return category
 136
 137
 138     def _variable_element_to_dict(self, variable_element):
 139         """
 140         Turn a <variable> element into a dictionary of its attributes
 141         and child text nodes.
 142         """
 143
 144         variable = {}
 145         variable['id'] = variable_element.getAttribute('id').lower()
 146         if variable_element.hasAttribute('type'):
 147             variable['type'] = variable_element.getAttribute('type')
 148         for node in variable_element.childNodes:
 149             if node.nodeType == node.ELEMENT_NODE and \
 150                node.tagName in ['name', 'value', 'description']:
 151                 variable[node.tagName] = self._get_text_of_child(variable_element, node.tagName)
 152         variable['element'] = variable_element
 153
 154         return variable
 155
 156
 157     def _group_element_to_dict(self, group_element):
 158         """
 159         Turn a <group> element into a dictionary of its attributes
 160         and child text nodes.
 161         """
 162
 163         group = {}
 164         for node in group_element.childNodes:
 165             if node.nodeType == node.ELEMENT_NODE and \
 166                node.tagName in ['id', 'name', 'default', 'description', 'uservisible']:
 167                 group[node.tagName] = self._get_text_of_child(group_element, node.tagName)
 168         group['element'] = group_element
 169
 170         return group
 171
 172
 173     def _packagereq_element_to_dict(self, packagereq_element):
 174         """
 175         Turns a <packagereq> element into a dictionary of its attributes
 176         and child text nodes.
 177         """
 178
 179         package = {}
 180         if packagereq_element.hasAttribute('type'):
 181             package['type'] = packagereq_element.getAttribute('type')
 182         package['name'] = self._get_text(packagereq_element)
 183         package['element'] = packagereq_element
 184
 185         return package
 186
 187
 188     def load(self, file = "/etc/planetlab/plc_config.xml"):
 189         """
 190         Merge file into configuration store.
 191         """
 192
 193         try:
 194             dom = xml.dom.minidom.parse(file)
 195         except ExpatError, e:
 196             raise ConfigurationException, e
 197
 198         if type(file) in types.StringTypes:
 199             self._files.append(os.path.abspath(file))
 200
 201         # Parse <variables> section
 202         for variables_element in dom.getElementsByTagName('variables'):
 203             for category_element in variables_element.getElementsByTagName('category'):
 204                 category = self._category_element_to_dict(category_element)
 205                 self.set(category, None)
 206
 207                 for variablelist_element in category_element.getElementsByTagName('variablelist'):
 208                     for variable_element in variablelist_element.getElementsByTagName('variable'):
 209                         variable = self._variable_element_to_dict(variable_element)
 210                         self.set(category, variable)
 211
 212         # Parse <comps> section
 213         for comps_element in dom.getElementsByTagName('comps'):
 214             for group_element in comps_element.getElementsByTagName('group'):
 215                 group = self._group_element_to_dict(group_element)
 216                 self.add_package(group, None)
 217
 218                 for packagereq_element in group_element.getElementsByTagName('packagereq'):
 219                     package = self._packagereq_element_to_dict(packagereq_element)
 220                     self.add_package(group, package)
 221
 222
 223     def save(self, file = None):
 224         """
 225         Write configuration store to file.
 226         """
 227
 228         if file is None:
 229             if self._files:
 230                 file = self._files[0]
 231             else:
 232                 file = "/etc/planetlab/plc_config.xml"
 233
 234         if type(file) in types.StringTypes:
 235             fileobj = open(file, 'w')
 236         else:
 237             fileobj = file
 238
 239         fileobj.seek(0)
 240         fileobj.write(self.output_xml())
 241         fileobj.truncate()
 242
 243         fileobj.close()
 244
 245     def verify(self, default, read, verify_variables={}):
 246         """ Confirm that the existing configuration is consistent
 247             according to the checks below.
 248
 249             It looks for filled-in values in the order of, local object (self),
 250             followed by cread (read values), and finally default values.
 251
 252         Arguments:
 253
 254             default configuration
 255             site configuration
 256             list of category/variable tuples to validate in these configurations
 257
 258         Returns:
 259
 260             dict of values for the category/variables passed in
 261             If an exception is found, ConfigurationException is raised.
 262
 263         """
 264
 265         validated_variables = {}
 266         for category_id, variable_id in verify_variables.iteritems():
 267             category_id = category_id.lower()
 268             variable_id = variable_id.lower()
 269             variable_value = None
 270             sources = (self, read, default)
 271             for source in sources:
 272                 (category_value, variable_value) = source.get(category_id,variable_id)
 273                 if variable_value <> None:
 274                     entry = validated_variables.get(category_id,[])
 275                     entry.append(variable_value['value'])
 276                     validated_variables["%s_%s"%(category_id.upper(),variable_id.upper())]=entry
 277                     break
 278             if variable_value == None:
 279                 raise ConfigurationException("Cannot find %s_%s)" % \
 280                                              (category_id.upper(),
 281                                               variable_id.upper()))
 282         return validated_variables
 283
 284     def get(self, category_id, variable_id):
 285         """
 286         Get the specified variable in the specified category.
 287
 288         Arguments:
 289
 290         category_id = unique category identifier (e.g., 'plc_www')
 291         variable_id = unique variable identifier (e.g., 'port')
 292
 293         Returns:
 294
 295         variable = { 'id': "variable_identifier",
 296                      'type': "variable_type",
 297                      'value': "variable_value",
 298                      'name': "Variable name",
 299                      'description': "Variable description" }
 300         """
 301
 302         if self._variables.has_key(category_id.lower()):
 303             (category, variables) = self._variables[category_id]
 304             if variables.has_key(variable_id.lower()):
 305                 variable = variables[variable_id]
 306             else:
 307                 variable = None
 308         else:
 309             category = None
 310             variable = None
 311
 312         return (category, variable)
 313
 314
 315     def delete(self, category_id, variable_id):
 316         """
 317         Delete the specified variable from the specified category. If
 318         variable_id is None, deletes all variables from the specified
 319         category as well as the category itself.
 320
 321         Arguments:
 322
 323         category_id = unique category identifier (e.g., 'plc_www')
 324         variable_id = unique variable identifier (e.g., 'port')
 325         """
 326
 327         if self._variables.has_key(category_id.lower()):
 328             (category, variables) = self._variables[category_id]
 329             if variable_id is None:
 330                 category['element'].parentNode.removeChild(category['element'])
 331                 del self._variables[category_id]
 332             elif variables.has_key(variable_id.lower()):
 333                 variable = variables[variable_id]
 334                 variable['element'].parentNode.removeChild(variable['element'])
 335                 del variables[variable_id]
 336
 337
 338     def set(self, category, variable):
 339         """
 340         Add and/or update the specified variable. The 'id' fields are
 341         mandatory. If a field is not specified and the category and/or
 342         variable already exists, the field will not be updated. If
 343         'variable' is None, only adds and/or updates the specified
 344         category.
 345
 346         Arguments:
 347
 348         category = { 'id': "category_identifier",
 349                      'name': "Category name",
 350                      'description': "Category description" }
 351
 352         variable = { 'id': "variable_identifier",
 353                      'type': "variable_type",
 354                      'value': "variable_value",
 355                      'name': "Variable name",
 356                      'description': "Variable description" }
 357         """
 358
 359         if not category.has_key('id') or type(category['id']) not in types.StringTypes:
 360             return
 361
 362         category_id = category['id'].lower()
 363
 364         if self._variables.has_key(category_id):
 365             # Existing category
 366             (old_category, variables) = self._variables[category_id]
 367
 368             # Merge category attributes
 369             for tag in ['name', 'description']:
 370                 if category.has_key(tag):
 371                     old_category[tag] = category[tag]
 372                     self._set_text_of_child(old_category['element'], tag, category[tag])
 373
 374             category_element = old_category['element']
 375         else:
 376             # Merge into DOM
 377             category_element = self._dom.createElement('category')
 378             category_element.setAttribute('id', category_id)
 379             for tag in ['name', 'description']:
 380                 if category.has_key(tag):
 381                     self._set_text_of_child(category_element, tag, category[tag])
 382
 383             if self._dom.documentElement.getElementsByTagName('variables'):
 384                 variables_element = self._dom.documentElement.getElementsByTagName('variables')[0]
 385             else:
 386                 variables_element = self._dom.createElement('variables')
 387                 self._dom.documentElement.appendChild(variables_element)
 388             variables_element.appendChild(category_element)
 389
 390             # Cache it
 391             category['element'] = category_element
 392             variables = {}
 393             self._variables[category_id] = (category, variables)
 394
 395         if variable is None or not variable.has_key('id') or type(variable['id']) not in types.StringTypes:
 396             return
 397
 398         variable_id = variable['id'].lower()
 399
 400         if variables.has_key(variable_id):
 401             # Existing variable
 402             old_variable = variables[variable_id]
 403
 404             # Merge variable attributes
 405             for attribute in ['type']:
 406                 if variable.has_key(attribute):
 407                     old_variable[attribute] = variable[attribute]
 408                     old_variable['element'].setAttribute(attribute, variable[attribute])
 409             for tag in ['name', 'value', 'description']:
 410                 if variable.has_key(tag):
 411                     old_variable[tag] = variable[tag]
 412                     self._set_text_of_child(old_variable['element'], tag, variable[tag])
 413         else:
 414             # Merge into DOM
 415             variable_element = self._dom.createElement('variable')
 416             variable_element.setAttribute('id', variable_id)
 417             for attribute in ['type']:
 418                 if variable.has_key(attribute):
 419                     variable_element.setAttribute(attribute, variable[attribute])
 420             for tag in ['name', 'value', 'description']:
 421                 if variable.has_key(tag):
 422                     self._set_text_of_child(variable_element, tag, variable[tag])
 423
 424             if category_element.getElementsByTagName('variablelist'):
 425                 variablelist_element = category_element.getElementsByTagName('variablelist')[0]
 426             else:
 427                 variablelist_element = self._dom.createElement('variablelist')
 428                 category_element.appendChild(variablelist_element)
 429             variablelist_element.appendChild(variable_element)
 430
 431             # Cache it
 432             variable['element'] = variable_element
 433             variables[variable_id] = variable
 434
 435
 436     def locate_varname (self, varname):
 437         """
 438         Locates category and variable from a variable's (shell) name
 439
 440         Returns:
 441         (variable, category) when found
 442         (None, None) otherwise
 443         """
 444
 445         for (category_id, (category, variables)) in self._variables.iteritems():
 446             for variable in variables.values():
 447                 (id, name, value, comments) = self._sanitize_variable(category_id, variable)
 448                 if (id == varname):
 449                     return (category,variable)
 450         return (None,None)
 451
 452     def get_package(self, group_id, package_name):
 453         """
 454         Get the specified package in the specified package group.
 455
 456         Arguments:
 457
 458         group_id - unique group id (e.g., 'plc')
 459         package_name - unique package name (e.g., 'postgresql')
 460
 461         Returns:
 462
 463         package = { 'name': "package_name",
 464                     'type': "mandatory|optional" }
 465         """
 466
 467         if self._packages.has_key(group_id.lower()):
 468             (group, packages) = self._packages[group_id]
 469             if packages.has_key(package_name):
 470                 package = packages[package_name]
 471             else:
 472                 package = None
 473         else:
 474             group = None
 475             package = None
 476
 477         return (group, package)
 478
 479
 480     def delete_package(self, group_id, package_name):
 481         """
 482         Deletes the specified variable from the specified category. If
 483         variable_id is None, deletes all variables from the specified
 484         category as well as the category itself.
 485
 486         Arguments:
 487
 488         group_id - unique group id (e.g., 'plc')
 489         package_name - unique package name (e.g., 'postgresql')
 490         """
 491
 492         if self._packages.has_key(group_id):
 493             (group, packages) = self._packages[group_id]
 494             if package_name is None:
 495                 group['element'].parentNode.removeChild(group['element'])
 496                 del self._packages[group_id]
 497             elif packages.has_key(package_name.lower()):
 498                 package = packages[package_name]
 499                 package['element'].parentNode.removeChild(package['element'])
 500                 del packages[package_name]
 501
 502
 503     def add_package(self, group, package):
 504         """
 505         Add and/or update the specified package. The 'id' and 'name'
 506         fields are mandatory. If a field is not specified and the
 507         package or group already exists, the field will not be
 508         updated. If package is None, only adds/or updates the
 509         specified group.
 510
 511         Arguments:
 512
 513         group = { 'id': "group_identifier",
 514                   'name': "Group name",
 515                   'default': "true|false",
 516                   'description': "Group description",
 517                   'uservisible': "true|false" }
 518
 519         package = { 'name': "package_name",
 520                     'type': "mandatory|optional" }
 521         """
 522
 523         if not group.has_key('id'):
 524             return
 525
 526         group_id = group['id']
 527
 528         if self._packages.has_key(group_id):
 529             # Existing group
 530             (old_group, packages) = self._packages[group_id]
 531
 532             # Merge group attributes
 533             for tag in ['id', 'name', 'default', 'description', 'uservisible']:
 534                 if group.has_key(tag):
 535                     old_group[tag] = group[tag]
 536                     self._set_text_of_child(old_group['element'], tag, group[tag])
 537
 538             group_element = old_group['element']
 539         else:
 540             # Merge into DOM
 541             group_element = self._dom.createElement('group')
 542             for tag in ['id', 'name', 'default', 'description', 'uservisible']:
 543                 if group.has_key(tag):
 544                     self._set_text_of_child(group_element, tag, group[tag])
 545
 546             if self._dom.documentElement.getElementsByTagName('comps'):
 547                 comps_element = self._dom.documentElement.getElementsByTagName('comps')[0]
 548             else:
 549                 comps_element = self._dom.createElement('comps')
 550                 self._dom.documentElement.appendChild(comps_element)
 551             comps_element.appendChild(group_element)
 552
 553             # Cache it
 554             group['element'] = group_element
 555             packages = {}
 556             self._packages[group_id] = (group, packages)
 557
 558         if package is None or not package.has_key('name'):
 559             return
 560
 561         package_name = package['name']
 562         if packages.has_key(package_name):
 563             # Existing package
 564             old_package = packages[package_name]
 565
 566             # Merge variable attributes
 567             for attribute in ['type']:
 568                 if package.has_key(attribute):
 569                     old_package[attribute] = package[attribute]
 570                     old_package['element'].setAttribute(attribute, package[attribute])
 571         else:
 572             # Merge into DOM
 573             packagereq_element = TrimTextElement('packagereq')
 574             self._set_text(packagereq_element, package_name)
 575             for attribute in ['type']:
 576                 if package.has_key(attribute):
 577                     packagereq_element.setAttribute(attribute, package[attribute])
 578
 579             if group_element.getElementsByTagName('packagelist'):
 580                 packagelist_element = group_element.getElementsByTagName('packagelist')[0]
 581             else:
 582                 packagelist_element = self._dom.createElement('packagelist')
 583                 group_element.appendChild(packagelist_element)
 584             packagelist_element.appendChild(packagereq_element)
 585
 586             # Cache it
 587             package['element'] = packagereq_element
 588             packages[package_name] = package
 589
 590
 591     def variables(self):
 592         """
 593         Return all variables.
 594
 595         Returns:
 596
 597         variables = { 'category_id': (category, variablelist) }
 598
 599         category = { 'id': "category_identifier",
 600                      'name': "Category name",
 601                      'description': "Category description" }
 602
 603         variablelist = { 'variable_id': variable }
 604
 605         variable = { 'id': "variable_identifier",
 606                      'type': "variable_type",
 607                      'value': "variable_value",
 608                      'name': "Variable name",
 609                      'description': "Variable description" }
 610         """
 611
 612         return self._variables
 613
 614
 615     def packages(self):
 616         """
 617         Return all packages.
 618
 619         Returns:
 620
 621         packages = { 'group_id': (group, packagelist) }
 622
 623         group = { 'id': "group_identifier",
 624                   'name': "Group name",
 625                   'default': "true|false",
 626                   'description': "Group description",
 627                   'uservisible': "true|false" }
 628
 629         packagelist = { 'package_name': package }
 630
 631         package = { 'name': "package_name",
 632                     'type': "mandatory|optional" }
 633         """
 634
 635         return self._packages
 636
 637
 638     def _sanitize_variable(self, category_id, variable):
 639         assert variable.has_key('id')
 640         # Prepend variable name with category label
 641         id = category_id + "_" + variable['id']
 642         # And uppercase it
 643         id = id.upper()
 644
 645         if variable.has_key('type'):
 646             type = variable['type']
 647         else:
 648             type = None
 649
 650         if variable.has_key('name'):
 651             name = variable['name']
 652         else:
 653             name = None
 654
 655         if variable.has_key('value') and variable['value'] is not None:
 656             value = variable['value']
 657             if type == "int" or type == "double":
 658                 # bash, Python, and PHP do not require that numbers be quoted
 659                 pass
 660             elif type == "boolean":
 661                 # bash, Python, and PHP can all agree on 0 and 1
 662                 if value == "true":
 663                     value = "1"
 664                 else:
 665                     value = "0"
 666             else:
 667                 # bash, Python, and PHP all support strong single quoting
 668                 value = "'" + value.replace("'", "\\'") + "'"
 669         else:
 670             value = None
 671
 672         if variable.has_key('description') and variable['description'] is not None:
 673             description = variable['description']
 674             # Collapse consecutive whitespace
 675             description = re.sub(r'\s+', ' ', description)
 676             # Wrap comments at 70 columns
 677             wrapper = textwrap.TextWrapper()
 678             comments = wrapper.wrap(description)
 679         else:
 680             comments = None
 681
 682         return (id, name, value, comments)
 683
 684
 685     def _header(self):
 686         header = """
 687 DO NOT EDIT. This file was automatically generated at
 688 %s from:
 689
 690 %s
 691 """ % (time.asctime(), os.linesep.join(self._files))
 692
 693         # Get rid of the surrounding newlines
 694         return header.strip().split(os.linesep)
 695
 696
 697     def output_shell(self, show_comments = True, encoding = "utf-8"):
 698         """
 699         Return variables as a shell script.
 700         """
 701
 702         buf = codecs.lookup(encoding)[3](StringIO())
 703         buf.writelines(["# " + line + os.linesep for line in self._header()])
 704
 705         for (category_id, (category, variables)) in self._variables.iteritems():
 706             for variable in variables.values():
 707                 (id, name, value, comments) = self._sanitize_variable(category_id, variable)
 708                 if show_comments:
 709                     buf.write(os.linesep)
 710                     if name is not None:
 711                         buf.write("# " + name + os.linesep)
 712                     if comments is not None:
 713                         buf.writelines(["# " + line + os.linesep for line in comments])
 714                 # bash does not have the concept of NULL
 715                 if value is not None:
 716                     buf.write(id + "=" + value + os.linesep)
 717
 718         return buf.getvalue()
 719
 720
 721     def output_php(self, encoding = "utf-8"):
 722         """
 723         Return variables as a PHP script.
 724         """
 725
 726         buf = codecs.lookup(encoding)[3](StringIO())
 727         buf.write("<?php" + os.linesep)
 728         buf.writelines(["// " + line + os.linesep for line in self._header()])
 729
 730         for (category_id, (category, variables)) in self._variables.iteritems():
 731             for variable in variables.values():
 732                 (id, name, value, comments) = self._sanitize_variable(category_id, variable)
 733                 buf.write(os.linesep)
 734                 if name is not None:
 735                     buf.write("// " + name + os.linesep)
 736                 if comments is not None:
 737                     buf.writelines(["// " + line + os.linesep for line in comments])
 738                 if value is None:
 739                     value = 'NULL'
 740                 buf.write("define('%s', %s);" % (id, value) + os.linesep)
 741
 742         buf.write("?>" + os.linesep)
 743
 744         return buf.getvalue()
 745
 746
 747     def output_xml(self, encoding = "utf-8"):
 748         """
 749         Return variables in original XML format.
 750         """
 751
 752         buf = codecs.lookup(encoding)[3](StringIO())
 753         self._dom.writexml(buf, addindent = "  ", indent = "", newl = "\n", encoding = encoding)
 754
 755         return buf.getvalue()
 756
 757
 758     def output_variables(self, encoding = "utf-8"):
 759         """
 760         Return list of all variable names.
 761         """
 762
 763         buf = codecs.lookup(encoding)[3](StringIO())
 764
 765         for (category_id, (category, variables)) in self._variables.iteritems():
 766             for variable in variables.values():
 767                 (id, name, value, comments) = self._sanitize_variable(category_id, variable)
 768                 buf.write(id + os.linesep)
 769
 770         return buf.getvalue()
 771
 772
 773     def output_packages(self, encoding = "utf-8"):
 774         """
 775         Return list of all packages.
 776         """
 777
 778         buf = codecs.lookup(encoding)[3](StringIO())
 779
 780         for (group, packages) in self._packages.values():
 781             buf.write(os.linesep.join(packages.keys()))
 782
 783         if buf.tell():
 784             buf.write(os.linesep)
 785
 786         return buf.getvalue()
 787
 788
 789     def output_groups(self, encoding = "utf-8"):
 790         """
 791         Return list of all package group names.
 792         """
 793
 794         buf = codecs.lookup(encoding)[3](StringIO())
 795
 796         for (group, packages) in self._packages.values():
 797             buf.write(group['name'] + os.linesep)
 798
 799         return buf.getvalue()
 800
 801
 802     def output_comps(self, encoding = "utf-8"):
 803         """
 804         Return <comps> section of configuration.
 805         """
 806
 807         if self._dom is None or \
 808            not self._dom.getElementsByTagName("comps"):
 809             return
 810         comps = self._dom.getElementsByTagName("comps")[0]
 811
 812         impl = xml.dom.minidom.getDOMImplementation()
 813         doc = impl.createDocument(None, "comps", None)
 814
 815         buf = codecs.lookup(encoding)[3](StringIO())
 816
 817         # Pop it off the DOM temporarily
 818         parent = comps.parentNode
 819         parent.removeChild(comps)
 820
 821         doc.replaceChild(comps, doc.documentElement)
 822         doc.writexml(buf, encoding = encoding)
 823
 824         # Put it back
 825         parent.appendChild(comps)
 826
 827         return buf.getvalue()
 828
 829     def validate_type(self, variable_type, value):
 830
 831         # ideally we should use the "validate_*" methods in PLCAPI or
 832         # even declare some checks along with the default
 833         # configuration (using RELAX NG?) but this shall work for now.
 834         def ip_validator(val):
 835             import socket
 836             try:
 837                 socket.inet_aton(val)
 838                 return True
 839             except: return False
 840
 841         def email_validator(val):
 842             return re.match('\A[a-zA-Z0-9._%+\-]+@[a-zA-Z0-9._\-]+\.[a-zA-Z]+\Z', val)
 843
 844         def boolean_validator (val):
 845             return val in ['true', 'false']
 846
 847         validators = {
 848             'email' : email_validator,
 849             'ip': ip_validator,
 850             'boolean': boolean_validator,
 851             }
 852
 853         # validate it if not a know type.
 854         validator = validators.get(variable_type, lambda x: True)
 855         return validator(value)
 856
 857
 858
 859 # xml.dom.minidom.Text.writexml adds surrounding whitespace to textual
 860 # data when pretty-printing. Override this behavior.
 861 class TrimText(xml.dom.minidom.Text):
 862     def writexml(self, writer, indent="", addindent="", newl=""):
 863         xml.dom.minidom.Text.writexml(self, writer, "", "", "")
 864
 865
 866 class TrimTextElement(xml.dom.minidom.Element):
 867     def writexml(self, writer, indent="", addindent="", newl=""):
 868         writer.write(indent)
 869         xml.dom.minidom.Element.writexml(self, writer, "", "", "")
 870         writer.write(newl)
 871
 872
 873 ####################
 874 # GLOBAL VARIABLES
 875 #
 876 g_configuration=None
 877 usual_variables=None
 878 config_dir=None
 879 service=None
 880
 881 def noop_validator(validated_variables):
 882     pass
 883
 884
 885 # historically we could also configure the devel pkg....
 886 def init_configuration ():
 887     global g_configuration
 888     global usual_variables, config_dir, service
 889
 890     usual_variables=g_configuration["usual_variables"]
 891     config_dir=g_configuration["config_dir"]
 892     service=g_configuration["service"]
 893
 894     global def_default_config, def_site_config, def_consolidated_config
 895     def_default_config= "%s/default_config.xml" % config_dir
 896     def_site_config = "%s/configs/site.xml" % config_dir
 897     def_consolidated_config = "%s/%s_config.xml" % (config_dir, service)
 898
 899     global mainloop_usage
 900     mainloop_usage= """Available commands:
 901  Uppercase versions give variables comments, when available
 902  u/U\t\t\tEdit usual variables
 903  w\t\t\tWrite
 904  r\t\t\tRestart %(service)s service
 905  R\t\t\tReload %(service)s service (rebuild config files for sh, python....)
 906  q\t\t\tQuit (without saving)
 907  h/?\t\t\tThis help
 908 ---
 909  l/L [<cat>|<var>]\tShow Locally modified variables/values
 910  s/S [<cat>|<var>]\tShow variables/values (all, in category, single)
 911  e/E [<cat>|<var>]\tEdit variables (all, in category, single)
 912 ---
 913  c\t\t\tList categories
 914  v/V [<cat>|<var>]\tList Variables (all, in category, single)
 915 ---
 916 Typical usage involves: u, [l,] w, r, q
 917 """ % globals()
 918
 919 def usage ():
 920     command_usage="%prog [options] [default-xml [site-xml [consolidated-xml]]]"
 921     init_configuration ()
 922     command_usage +="""
 923 \t default-xml defaults to %s
 924 \t site-xml defaults to %s
 925 \t consolidated-xml defaults to %s""" % (def_default_config,def_site_config, def_consolidated_config)
 926     return command_usage
 927
 928 ####################
 929 variable_usage= """Edit Commands :
 930 #\tShow variable comments
 931 .\tStops prompting, return to mainloop
 932 /\tCleans any site-defined value, reverts to default
 933 =\tShows default value
 934 >\tSkips to next category
 935 ?\tThis help
 936 """
 937
 938 ####################
 939 def get_value (config,  category_id, variable_id):
 940     (category, variable) = config.get (category_id, variable_id)
 941     return variable['value']
 942
 943 def get_type (config, category_id, variable_id):
 944     (category, variable) = config.get (category_id, variable_id)
 945     return variable['type']
 946
 947 def get_current_value (cread, cwrite, category_id, variable_id):
 948     # the value stored in cwrite, if present, is the one we want
 949     try:
 950         result=get_value (cwrite,category_id,variable_id)
 951     except:
 952         result=get_value (cread,category_id,variable_id)
 953     return result
 954
 955 # refrain from using plc_config's _sanitize
 956 def get_varname (config,  category_id, variable_id):
 957     (category, variable) = config.get (category_id, variable_id)
 958     return (category_id+"_"+variable['id']).upper()
 959
 960 # could not avoid using _sanitize here..
 961 def get_name_comments (config, cid, vid):
 962     try:
 963         (category, variable) = config.get (cid, vid)
 964         (id, name, value, comments) = config._sanitize_variable (cid,variable)
 965         return (name,comments)
 966     except:
 967         return (None,[])
 968
 969 def print_name_comments (config, cid, vid):
 970     (name,comments)=get_name_comments(config,cid,vid)
 971     if name:
 972         print "### %s" % name
 973     if comments:
 974         for line in comments:
 975             print "# %s" % line
 976     else:
 977         print "!!! No comment associated to %s_%s" % (cid,vid)
 978
 979 ####################
 980 def list_categories (config):
 981     result=[]
 982     for (category_id, (category, variables)) in config.variables().iteritems():
 983         result += [category_id]
 984     return result
 985
 986 def print_categories (config):
 987     print "Known categories"
 988     for cid in list_categories(config):
 989         print "%s" % (cid.upper())
 990
 991 ####################
 992 def list_category (config, cid):
 993     result=[]
 994     for (category_id, (category, variables)) in config.variables().iteritems():
 995         if (cid == category_id):
 996             for variable in variables.values():
 997                 result += ["%s_%s" %(cid,variable['id'])]
 998     return result
 999
1000 def print_category (config, cid, show_comments=True):
1001     cid=cid.lower()
1002     CID=cid.upper()
1003     vids=list_category(config,cid)
1004     if (len(vids) == 0):
1005         print "%s : no such category"%CID
1006     else:
1007         print "Category %s contains" %(CID)
1008         for vid in vids:
1009             print vid.upper()
1010
1011 ####################
1012 def consolidate (default_config, site_config, consolidated_config):
1013     global service
1014     try:
1015         conso = PLCConfiguration (default_config)
1016         conso.load (site_config)
1017         conso.save (consolidated_config)
1018     except Exception, inst:
1019         print "Could not consolidate, %s" % (str(inst))
1020         return
1021     print ("Merged\n\t%s\nand\t%s\ninto\t%s"%(default_config,site_config,
1022                                               consolidated_config))
1023
1024 def reload_service ():
1025     global service
1026     os.system("set -x ; systemctl reload %s" % service)
1027
1028 ####################
1029 def restart_service ():
1030     global service
1031     print ("==================== Stopping %s" % service)
1032     os.system("systemctl stop %s" % service)
1033     print ("==================== Starting %s" % service)
1034     os.system("systemctl start %s" % service)
1035
1036 ####################
1037 def prompt_variable (cdef, cread, cwrite, category, variable,
1038                      show_comments, support_next=False):
1039
1040     assert category.has_key('id')
1041     assert variable.has_key('id')
1042
1043     category_id = category ['id']
1044     variable_id = variable['id']
1045
1046     while True:
1047         default_value = get_value(cdef,category_id,variable_id)
1048         variable_type = get_type(cdef,category_id,variable_id)
1049         current_value = get_current_value(cread,cwrite,category_id, variable_id)
1050         varname = get_varname (cread,category_id, variable_id)
1051
1052         if show_comments :
1053             print_name_comments (cdef, category_id, variable_id)
1054         prompt = "== %s : [%s] " % (varname,current_value)
1055         try:
1056             answer = raw_input(prompt).strip()
1057         except EOFError :
1058             raise Exception ('BailOut')
1059         except KeyboardInterrupt:
1060             print "\n"
1061             raise Exception ('BailOut')
1062
1063         # no change
1064         if (answer == "") or (answer == current_value):
1065             return None
1066         elif (answer == "."):
1067             raise Exception ('BailOut')
1068         elif (answer == "#"):
1069             print_name_comments(cread,category_id,variable_id)
1070         elif (answer == "?"):
1071             print variable_usage.strip()
1072         elif (answer == "="):
1073             print ("%s defaults to %s" %(varname,default_value))
1074         # revert to default : remove from cwrite (i.e. site-config)
1075         elif (answer == "/"):
1076             cwrite.delete(category_id,variable_id)
1077             print ("%s reverted to %s" %(varname,default_value))
1078             return
1079         elif (answer == ">"):
1080             if support_next:
1081                 raise Exception ('NextCategory')
1082             else:
1083                 print "No support for next category"
1084         else:
1085             if cdef.validate_type(variable_type, answer):
1086                 variable['value'] = answer
1087                 cwrite.set(category,variable)
1088                 return
1089             else:
1090                 print "Not a valid value"
1091
1092 def prompt_variables_all (cdef, cread, cwrite, show_comments):
1093     try:
1094         for (category_id, (category, variables)) in cread.variables().iteritems():
1095             print ("========== Category = %s" % category_id.upper())
1096             for variable in variables.values():
1097                 try:
1098                     newvar = prompt_variable (cdef, cread, cwrite, category, variable,
1099                                               show_comments, True)
1100                 except Exception, inst:
1101                     if (str(inst) == 'NextCategory'): break
1102                     else: raise
1103
1104     except Exception, inst:
1105         if (str(inst) == 'BailOut'): return
1106         else: raise
1107
1108 def prompt_variables_category (cdef, cread, cwrite, cid, show_comments):
1109     cid=cid.lower()
1110     CID=cid.upper()
1111     try:
1112         print ("========== Category = %s" % CID)
1113         for vid in list_category(cdef,cid):
1114             (category,variable) = cdef.locate_varname(vid.upper())
1115             newvar = prompt_variable (cdef, cread, cwrite, category, variable,
1116                                       show_comments, False)
1117     except Exception, inst:
1118         if (str(inst) == 'BailOut'): return
1119         else: raise
1120
1121 ####################
1122 def show_variable (cdef, cread, cwrite,
1123                    category, variable,show_value,show_comments):
1124     assert category.has_key('id')
1125     assert variable.has_key('id')
1126
1127     category_id = category ['id']
1128     variable_id = variable['id']
1129
1130     default_value = get_value(cdef,category_id,variable_id)
1131     current_value = get_current_value(cread,cwrite,category_id,variable_id)
1132     varname = get_varname (cread,category_id, variable_id)
1133     if show_comments :
1134         print_name_comments (cdef, category_id, variable_id)
1135     if show_value:
1136         print "%s = %s" % (varname,current_value)
1137     else:
1138         print "%s" % (varname)
1139
1140 def show_variables_all (cdef, cread, cwrite, show_value, show_comments):
1141     for (category_id, (category, variables)) in cread.variables().iteritems():
1142         print ("========== Category = %s" % category_id.upper())
1143         for variable in variables.values():
1144             show_variable (cdef, cread, cwrite,
1145                            category, variable,show_value,show_comments)
1146
1147 def show_variables_category (cdef, cread, cwrite, cid, show_value,show_comments):
1148     cid=cid.lower()
1149     CID=cid.upper()
1150     print ("========== Category = %s" % CID)
1151     for vid in list_category(cdef,cid):
1152         (category,variable) = cdef.locate_varname(vid.upper())
1153         show_variable (cdef, cread, cwrite, category, variable,
1154                        show_value,show_comments)
1155
1156 ####################
1157 re_mainloop_0arg="^(?P<command>[uUwrRqlLsSeEcvVhH\?])[ \t]*$"
1158 re_mainloop_1arg="^(?P<command>[sSeEvV])[ \t]+(?P<arg>\w+)$"
1159 matcher_mainloop_0arg=re.compile(re_mainloop_0arg)
1160 matcher_mainloop_1arg=re.compile(re_mainloop_1arg)
1161
1162 def mainloop (cdef, cread, cwrite, default_config, site_config, consolidated_config):
1163     global service
1164     while True:
1165         try:
1166             answer = raw_input("Enter command (u for usual changes, w to save, ? for help) ").strip()
1167         except EOFError:
1168             answer =""
1169         except KeyboardInterrupt:
1170             print "\nBye"
1171             sys.exit()
1172
1173         if (answer == "") or (answer in "?hH"):
1174             print mainloop_usage
1175             continue
1176         groups_parse = matcher_mainloop_0arg.match(answer)
1177         command=None
1178         if (groups_parse):
1179             command = groups_parse.group('command')
1180             arg=None
1181         else:
1182             groups_parse = matcher_mainloop_1arg.match(answer)
1183             if (groups_parse):
1184                 command = groups_parse.group('command')
1185                 arg=groups_parse.group('arg')
1186         if not command:
1187             print ("Unknown command >%s< -- use h for help" % answer)
1188             continue
1189
1190         show_comments=command.isupper()
1191
1192         mode='ALL'
1193         if arg:
1194             mode=None
1195             arg=arg.lower()
1196             variables=list_category (cdef,arg)
1197             if len(variables):
1198                 # category_id as the category name
1199                 # variables as the list of variable names
1200                 mode='CATEGORY'
1201                 category_id=arg
1202             arg=arg.upper()
1203             (category,variable)=cdef.locate_varname(arg)
1204             if variable:
1205                 # category/variable as output by locate_varname
1206                 mode='VARIABLE'
1207             if not mode:
1208                 print "%s: no such category or variable" % arg
1209                 continue
1210
1211         if command in "qQ":
1212             # todo check confirmation
1213             return
1214         elif command == "w":
1215             try:
1216                 # Confirm that various constraints are met before saving file.
1217                 validate_variables = g_configuration.get('validate_variables',{})
1218                 validated_variables = cwrite.verify(cdef, cread, validate_variables)
1219                 validator = g_configuration.get('validator',noop_validator)
1220                 validator(validated_variables)
1221                 cwrite.save(site_config)
1222             except ConfigurationException, e:
1223                 print "Save failed due to a configuration exception: %s" % e
1224                 break;
1225             except:
1226                 print traceback.print_exc()
1227                 print ("Could not save -- fix write access on %s" % site_config)
1228                 break
1229             print ("Wrote %s" % site_config)
1230             consolidate(default_config, site_config, consolidated_config)
1231             print ("You might want to type 'r' (restart %s), 'R' (reload %s) or 'q' (quit)" % \
1232                    (service, service))
1233         elif command in "uU":
1234             global usual_variables
1235             try:
1236                 for varname in usual_variables:
1237                     (category,variable) = cdef.locate_varname(varname)
1238                     if not (category is None and variable is None):
1239                         prompt_variable(cdef, cread, cwrite, category, variable, False)
1240             except Exception, inst:
1241                 if (str(inst) != 'BailOut'):
1242                     raise
1243         elif command == "r":
1244             restart_service()
1245         elif command == "R":
1246             reload_service()
1247         elif command == "c":
1248             print_categories(cread)
1249         elif command in "eE":
1250             if mode == 'ALL':
1251                 prompt_variables_all(cdef, cread, cwrite,show_comments)
1252             elif mode == 'CATEGORY':
1253                 prompt_variables_category(cdef,cread,cwrite,category_id,show_comments)
1254             elif mode == 'VARIABLE':
1255                 try:
1256                     prompt_variable (cdef,cread,cwrite,category,variable,
1257                                      show_comments,False)
1258                 except Exception, inst:
1259                     if str(inst) != 'BailOut':
1260                         raise
1261         elif command in "vVsSlL":
1262             show_value=(command in "sSlL")
1263             (c1,c2,c3) = (cdef, cread, cwrite)
1264             if command in "lL":
1265                 (c1,c2,c3) = (cwrite,cwrite,cwrite)
1266             if mode == 'ALL':
1267                 show_variables_all(c1,c2,c3,show_value,show_comments)
1268             elif mode == 'CATEGORY':
1269                 show_variables_category(c1,c2,c3,category_id,show_value,show_comments)
1270             elif mode == 'VARIABLE':
1271                 show_variable (c1,c2,c3,category,variable,show_value,show_comments)
1272         else:
1273             print ("Unknown command >%s< -- use h for help" % answer)
1274
1275 ####################
1276 # creates directory for file if not yet existing
1277 def check_dir (config_file):
1278     dirname = os.path.dirname (config_file)
1279     if (not os.path.exists (dirname)):
1280         try:
1281             os.makedirs(dirname,0755)
1282         except OSError, e:
1283             print "Cannot create dir %s due to %s - exiting" % (dirname,e)
1284             sys.exit(1)
1285
1286         if (not os.path.exists (dirname)):
1287             print "Cannot create dir %s - exiting" % dirname
1288             sys.exit(1)
1289         else:
1290             print "Created directory %s" % dirname
1291
1292 ####################
1293 def optParserSetup(configuration):
1294     parser = OptionParser(usage=usage())
1295     parser.set_defaults(config_dir=configuration['config_dir'],
1296                         service=configuration['service'],
1297                         usual_variables=configuration['usual_variables'])
1298     parser.add_option("","--configdir",dest="config_dir",help="specify configuration directory")
1299     parser.add_option("","--service",dest="service",help="specify /etc/init.d style service name")
1300     parser.add_option("","--usual_variable",dest="usual_variables",action="append", help="add a usual variable")
1301     return parser
1302
1303 def main(command,argv,configuration):
1304     global g_configuration
1305     g_configuration=configuration
1306
1307     parser = optParserSetup(configuration)
1308     (config,args) = parser.parse_args()
1309     if len(args)>3:
1310         parser.error("too many arguments")
1311
1312     configuration['service']=config.service
1313     configuration['usual_variables']=config.usual_variables
1314     configuration['config_dir']=config.config_dir
1315     # add in new usual_variables defined on the command line
1316     for usual_variable in config.usual_variables:
1317         if usual_variable not in configuration['usual_variables']:
1318             configuration['usual_variables'].append(usual_variable)
1319
1320     # intialize configuration
1321     init_configuration()
1322
1323     (default_config,site_config,consolidated_config) = (def_default_config, def_site_config, def_consolidated_config)
1324     if len(args) >= 1:
1325         default_config=args[0]
1326     if len(args) >= 2:
1327         site_config=args[1]
1328     if len(args) == 3:
1329         consolidated_config=args[2]
1330
1331     for c in (default_config,site_config,consolidated_config):
1332         check_dir (c)
1333
1334     try:
1335         # the default settings only - read only
1336         cdef = PLCConfiguration(default_config)
1337
1338         # in effect : default settings + local settings - read only
1339         cread = PLCConfiguration(default_config)
1340
1341     except ConfigurationException, e:
1342         print ("Error %s in default config file %s" %(e,default_config))
1343         return 1
1344     except:
1345         print traceback.print_exc()
1346         print ("default config files %s not found, is myplc installed ?" % default_config)
1347         return 1
1348
1349
1350     # local settings only, will be modified & saved
1351     cwrite=PLCConfiguration()
1352
1353     try:
1354         cread.load(site_config)
1355         cwrite.load(site_config)
1356     except:
1357         cwrite = PLCConfiguration()
1358
1359     mainloop (cdef, cread, cwrite, default_config, site_config, consolidated_config)
1360     return 0
1361
1362 if __name__ == '__main__':
1363     import sys
1364     if len(sys.argv) > 1 and sys.argv[1] in ['build', 'install', 'uninstall']:
1365         from distutils.core import setup
1366         setup(py_modules=["plc_config"])