def makeXML(cls, name, memory, vcpu, *devices):
        
        if cls.domain_type is None:
            raise libvirt.libvirtError("%r can't be instanciated - no domain type" \
                                % cls)
            
        
        cfg = DomainConfig(name, memory, vcpu, devices)
        
        root = XMLBuilder('domain', type=cls.domain_type)

        cls.commonFields(root, cfg)
                    
        with root.os:
            cls.generateOS(root, cfg)
        
        root.clock(sync='localtime')
        
        cls.powerFeatures(root, cfg)
        
        with root.devices:
            cls.emulator(root, cfg)
            
            for dev in devices: 
                dev.toxml(root)
            
            cls.commonDevices(root, cfg)

        return root

def pipeline_to_xml(p):
    """ Convert a Pipeline to XML

    :type p: Pipeline
    :param p:
    :return:
    """
    root = XMLBuilder(Constants.WORKFLOW_TEMPLATE_ROOT, id=p.idx)
    with getattr(root, Constants.ENTRY_POINTS):
        for eid, bid in p.entry_bindings:
            _d = {"id": eid, "in": bid}
            getattr(root, Constants.ENTRY_POINT)(**_d)
    with getattr(root, Constants.BINDINGS):
        for bout, bin_ in p.bindings:
            _d = {"out": bout, "in": bin_}
            getattr(root, Constants.BINDING)(**_d)

    # Engine level Options
    # for completeness write this element
    getattr(root, "options")

    # Task Options
    with getattr(root, "task-options"):
        for key, value in p.task_options.iteritems():
            _d = {"id": key}
            with getattr(root, 'option')(**_d):
                root.value(str(value))

    return root

 def _generate_xml(self, exception,message = ""):
     _,_,trace = sys.exc_info()
     
     xml = XMLBuilder()
     
     tb_dict = {}
     tb = traceback.extract_tb(trace)
     
     with xml.notice(version = 2.0):
         xml << ('api-key', self.environment.api_key)
         with xml.notifier:
             xml << ('name', self.environment.name)
             xml << ('version', self.environment.version)
             xml << ('url', self.environment.url)
         with xml('server-environment'):
             xml << ('environment-name', self.environment.environment_name)
         with xml.error:
             xml << ('class', exception.__class__.__name__)
             if message == "":
                 xml << ('message', str(exception))
             else:
                 xml << ('message', str(exception) + '\n\n' + message)
             with xml.backtrace:
                 for trace in tb:
                     tb_dict['filename'] = trace[0]
                     tb_dict['line_number'] = trace[1]
                     tb_dict['function_name'] = trace[2]
                     xml << ('line', {
                         'file':tb_dict.get('filename', 'unknown'),
                         'number':tb_dict.get('line_number', 'unknown'),
                         'method':tb_dict.get('function_name', 'unknown')
                     })
             
     return str(xml)

    def to_xml(self):
        """Return an XML instance of the suite"""

        x = XMLBuilder('testsuite', name=self.name, tests=str(self.ntests), errors=str(self.nerrors), failures=str(self.nfailure), skip=str(self.nskipped))

        for test_case in self.tests:
            classname = test_case.classname
            # sanitize for XML
            text = "" if test_case.text is None else test_case.text
            etype = "" if test_case.etype is None else test_case.etype

            with x.testcase(classname=classname, name=test_case.name,
                            result=test_case.result, etype=etype,
                            text=text):

                if test_case.result == 'failures':
                    x.error(type=test_case.etype, message=test_case.message)
                elif test_case.result == 'failure':
                    x.failure(type=test_case.etype, message=test_case.message)
                elif test_case.result == 'skipped':
                    x.skipped(type=test_case.etype, message=test_case.message)
                elif test_case.result == 'error':
                    x.error(type=test_case.etype, message=test_case.message)
                else:
                    # Successful testcase
                    pass
        return x

def checkstyle_xml(diags_set):

    def converted_severity(fauxpas_severity):
        # checkstyle severities: ignore, info, warning, error
        if (9 <= fauxpas_severity):
            return 'error'
        elif (5 <= fauxpas_severity):
            return 'warning'
        return 'info'

    x = XMLBuilder('checkstyle')
    diags_by_file = diags_set.grouped_diagnostics(by_property='file')
    for filepath, diags in diags_by_file.items():
        with x.file(name=filepath or diags_set.pbxproj_path):
            for diag in diags:
                message = diag.info
                if 0 < len(message):
                    message += ' '
                message += '(%s - %s)' % (diag.ruleName, diag.ruleDescription)
                x.error(severity=converted_severity(diag.severity),
                        source=diag.ruleShortName,
                        message=message,
                        line=str(diag.extent.start.line),
                        column=str(diag.extent.start.utf16Column)
                        )
    return str(x)

 def testWith(self):
     xml = XMLBuilder()
     with xml.root(lenght = 12):
         pass
     self.assertEqual(str(xml),'<root lenght="12" />')
     
     xml = XMLBuilder()
     with xml.root():
         xml << "text1" << "text2" << ('some_node',)
     self.assertEqual(str(xml),"<root>text1text2<some_node /></root>")

 def build_snapshot_xml(self, name=None, description=None):
     """
     :rtype : String
     :type name: String
     :type description: String
     """
     xml_builder = XMLBuilder('domainsnapshot')
     if not (name is None):
         xml_builder.name(name)
     if not (description is None):
         xml_builder.description(description)
     return str(xml_builder)

def tree_to_xml(root):
    xml = XMLBuilder('map', version='0.9.0')
 
    def rec_tree(tree, xnode):
        if tree == {}:
            return
        xnode['folded'] = 'true'
        for key, subtree in tree.iteritems():
            rec_tree(subtree, xnode.node(text=key))
    xroot = xml.node(text='Categories')
    rec_tree(root, xroot)
    xroot['folded'] = 'false'
    return str(xml)

 def testFormat(self):
     x = XMLBuilder('utf-8',format = True)
     with x.root():
         x << ('array',)
         with x.array(len = 10):
             with x.el(val = 0):
                 pass
             with x.el('xyz',val = 1):
                 pass
             x << ("el","abc",{'val':2}) << ('el',dict(val=3))
             x << ('el',dict(val=4)) << ('el',dict(val='5'))
             with x('sup-el',val = 23):
                 x << "test  "
     self.assertEqual(str(x),result1)

def schema_options_to_xml(option_type_name, schema_options_d):
    """Option type name is the task-option or option"""

    x = XMLBuilder(Constants.WORKFLOW_TEMPLATE_PRESET_ROOT)

    # Need to do this getattr to get around how the API works
    with getattr(x, option_type_name):
        for option_id, schema in schema_options_d.iteritems():
            default_value = schema["properties"][option_id]["default"]
            if default_value is not None:
                with x.option(id=option_id):
                    default_value = schema["properties"][option_id]["default"]
                    x.value(str(default_value))

    return x

    def toxml(self, hrn = None):
        xml = XMLBuilder(format = True, tab_step = "  ")
        with xml.RSpec(type="VINI"):
            if hrn:
                element = xml.network(name="Public_VINI", slice=hrn)
            else:
                element = xml.network(name="Public_VINI")
                
            with element:
                for site in self.getSites():
                    site.toxml(xml, hrn, self.nodes)
                for link in self.sitelinks:
                    link.toxml(xml)

        header = '<?xml version="1.0"?>\n'
        return header + str(xml)

    def toxml(self):
        xml = XMLBuilder(format = True, tab_step = "  ")
        with xml.RSpec(type=self.type):
            if self.slice:
                element = xml.network(name=self.api.hrn, slice=self.slice.hrn)
            else:
                element = xml.network(name=self.api.hrn)

            with element:
                if self.slice:
                    self.slice.toxml(xml)
                for site in self.getSites():
                    site.toxml(xml)
                for link in self.sitelinks:
                    link.toxml(xml)

        header = '<?xml version="1.0"?>\n'
        return header + str(xml)

    def toxml(self):
        """
        Produce XML directly from the topology specification.
        """
        xml = XMLBuilder(format = True, tab_step = "  ")
        with xml.RSpec(type=self.type):
            if self.slice:
                element = xml.network(name=self.api.hrn, slice=self.slice.hrn)
            else:
                element = xml.network(name=self.api.hrn)
                
            with element:
                if self.slice:
                    self.slice.toxml(xml)
                for site in self.getSites():
                    site.toxml(xml)

        header = '<?xml version="1.0"?>\n'
        return header + str(xml)

def export_to_xml(people, questions_to_export, user_id, can_view_email):
    response = HttpResponse(content_type = "application/xml")
    response['Content-Disposition'] = 'attachment; filename="sc4g-people.xml"'
    xml = XMLBuilder('volunteers')
    for person in people:
        with xml.volunteer:
            xml.firstName(person.user.first_name)
            xml.lastName(person.user.last_name)
            if (can_view_email):
                xml.email(person.user.email)
            with xml.form_responses:
                for key, value in get_card_fields_with_icons_together(person, user_id).items():
                    xml.form_response(value, question=key)

    response.content = str(xml)
    return response

    def create_snapshot(self, domain, snapshot_name, \
                        snapshot_description):
        """Create VM snapshot
           connection: object with a connection to the Hypervisor
           domain: VM name
           snapshot_name
           snapshot_description
        """
        try:
            libvirt_domain = self.libvirt_connection.lookupByName(domain)
            xml_base = XMLBuilder('domainsnapshot')
            xml_base.name(snapshot_name)
            xml_base.description(snapshot_description)
            xml = str(xml_base)
            libvirt_domain.snapshotCreateXML(xml)
        except:
            print 'Unable to create snapshot'
            sys.exit(1)

        print 'Snapshot has been created successfully.'

 def _generate_xml(self, exception):
     _,_,trace = sys.exc_info()
     
     xml = XMLBuilder()
     with xml.notice(version = 2.0):
         xml << ('api-key', self.environment.api_key)
         with xml.notifier:
             xml << ('name', self.environment.name)
             xml << ('version', self.environment.version)
             xml << ('url', self.environment.url)
         with xml('server-environment'):
             xml << ('environment-name', self.environment.environment_name)
         with xml.error:
             xml << ('class', exception.__class__.__name__)
             xml << ('message', str(exception))
             with xml.backtrace:
                 [xml << ('line', {'file':filename, 'number':line_number, 'method':function_name}) \
                 for filename, line_number, function_name, _ in traceback.extract_tb(trace)]
             
     return str(xml)

 def _generate_xml(self, exception, additional_information=None):
     _,_,trace = sys.exc_info()
     
     xml = XMLBuilder()
     
     tb_dict = {}
     tb = traceback.extract_tb(trace)
     
     if tb:
         tb = tb[0]
         tb_dict['filename'] = tb[0]
         tb_dict['line_number'] = tb[1]
         tb_dict['function_name'] = tb[2]
     
     message = str(exception)
     if additional_information:
         message = 'error: %s, additional info: %s' % (message, additional_information)
     
     with xml.notice(version = 2.0):
         xml << ('api-key', self.api_key)
         with xml.notifier:
             xml << ('name', self.name)
             xml << ('version', self.version)
             xml << ('url', self.url)
         with xml('server-environment'):
             xml << ('environment-name', self.environment_name)
         with xml.error:
             xml << ('class', exception.__class__.__name__)
             xml << ('message', message)
             with xml.backtrace:
                 xml << ('line', {
                     'file':tb_dict.get('filename', 'unknown'),
                     'number':tb_dict.get('line_number', 'unknown'),
                     'method':tb_dict.get('function_name', 'unknown')
                 })
             
     return str(xml)

    def _generate_xml(self, exception=None, request=None):
        _, _, trace = sys.exc_info()

        xml = XMLBuilder()

        tb_dict = {}
        tb = traceback.extract_tb(trace)

        if tb:
            tb = tb[0]
            tb_dict["filename"] = tb[0]
            tb_dict["line_number"] = tb[1]
            tb_dict["function_name"] = tb[2]

        site = Site.objects.get_current()
        with xml.notice(version=2.0):
            xml << ("api-key", self.settings["API_KEY"])
            with xml.notifier:
                xml << ("name", site.name)
                xml << ("version", "0.0.1")
                xml << ("url", site.domain)
            if request:
                with xml.request:
                    if request.is_secure():
                        scheme = "https"
                    else:
                        scheme = "http"
                    url = "%s://%s%s" % (scheme, request.get_host(), request.get_full_path())
                    xml << ("url", url)

                    cb, _, _ = resolve(request.path)
                    xml << ("component", cb.__module__)
                    xml << ("action", cb.__name__)

                    if len(request.POST):
                        with xml.params:
                            for key, val in request.POST.items():
                                xml << ("var", str(val), {"key": key})

                    session = request.session.items()
                    if len(session):
                        with xml.session:
                            for key, val in session.items():
                                xml << ("var", str(val), {"key": key})

                    with xml("cgi-data"):
                        for key, val in request.META.items():
                            xml << ("var", str(val), {"key": key})

            with xml("server-environment"):
                xml << ("environment-name", self.settings["ENVIRONMENT"])

            if exception:
                with xml.error:
                    xml << ("class", exception.__class__.__name__)
                    xml << ("message", str(exception))
                    with xml.backtrace:
                        xml << (
                            "line",
                            {
                                "file": tb_dict.get("filename", "unknown"),
                                "number": tb_dict.get("line_number", "unknown"),
                                "method": tb_dict.get("function_name", "unknown"),
                            },
                        )

        return str(xml)

 def build_volume_xml(self, volume):
     """
     :type volume: Volume
         :rtype : String
     """
     volume_xml = XMLBuilder('volume')
     volume_xml.name(
         self._get_name(
             volume.environment and volume.environment.name or '',
             volume.name))
     volume_xml.capacity(str(volume.capacity))
     with volume_xml.target:
         volume_xml.format(type=volume.format)
     if volume.backing_store is not None:
         with volume_xml.backingStore:
             volume_xml.path(self.driver.volume_path(volume.backing_store))
             volume_xml.format(type=volume.backing_store.format)
     return str(volume_xml)

    def build_network_xml(self, network):
        """
        :type network: Network
            :rtype : String
        """
        network_xml = XMLBuilder('network')
        network_xml.name(self._get_name(
            network.environment and network.environment.name or '',
            network.name))
        if not (network.forward is None):
            network_xml.forward(mode=network.forward)
        if not (network.ip_network is None):
            ip_network = IPNetwork(network.ip_network)
            with network_xml.ip(address=str(ip_network[1]), prefix=str(ip_network.prefixlen)):
                if network.has_pxe_server:
                    network_xml.tftp(root=network.tftp_root_dir)
                if network.has_dhcp_server:
                    with network_xml.dhcp:
                        network_xml.range(start=str(network.ip_pool_start),
                                          end=str(network.ip_pool_end))
                        for interface in network.interfaces:
                            for address in interface.addresses:
                                if IPAddress(address.ip_address) in ip_network:
                                    network_xml.host(
                                        mac=str(interface.mac_address),
                                        ip=str(address.ip_address),
                                        name=interface.node.name
                                    )
                        if network.has_pxe_server:
                            network_xml.bootp(file="pxelinux.0")

        return str(network_xml)