diff options
| author |   Stuart Mackie <wsmackie@juniper.net> | 2016-01-29 16:00:57 -0800 |
|---|---|---|
| committer | Stuart Mackie <wsmackie@juniper.net> | 2016-01-29 16:00:57 -0800 |
| commit | 82f1a7eb5535b30a95b1e71ff18c315d40d1e6f0 (patch) | |
| tree | f930c90f75846ec8d8e33cf27325ff8fafc85d5c /Testcases/vnc_api/gen/resource_xsd.py | |
| parent | 5c04f2e22eb6b5e7a671bc02ba53a438eb66e90d (diff) | |
OpenContrail test suitestable/colorado
Change-Id: I61168093a2a05d47377ef47c8638ae1554b1a999
Signed-off-by: Stuart Mackie <wsmackie@juniper.net>
Diffstat (limited to 'Testcases/vnc_api/gen/resource_xsd.py')
| -rw-r--r-- | Testcases/vnc_api/gen/resource_xsd.py | 18494 |
1 files changed, 18494 insertions, 0 deletions
diff --git a/Testcases/vnc_api/gen/resource_xsd.py b/Testcases/vnc_api/gen/resource_xsd.py new file mode 100644 index 0000000..e8453d4 --- /dev/null +++ b/Testcases/vnc_api/gen/resource_xsd.py @@ -0,0 +1,18494 @@ +""" +This module defines the classes for types defined in :doc:`vnc_cfg.xsd` +""" +import json +from generatedssuper import * +class MacAddressesType(GeneratedsSuper): + """ + MacAddressesType class definition from :doc:`vnc_cfg.xsd` + """ + subclass = None + superclass = None + def __init__(self, mac_address=None, **kwargs): + if (mac_address is None) or (mac_address == []): + self.mac_address = [] + else: + self.mac_address = mac_address + def factory(*args_, **kwargs_): + if MacAddressesType.subclass: + return MacAddressesType.subclass(*args_, **kwargs_) + else: + return MacAddressesType(*args_, **kwargs_) + factory = staticmethod(factory) + def get_mac_address(self): return self.mac_address + def set_mac_address(self, mac_address): self.mac_address = mac_address + def add_mac_address(self, value): self.mac_address.append(value) + def insert_mac_address(self, index, value): self.mac_address[index] = value + def delete_mac_address(self, value): self.mac_address.remove(value) + def __eq__(self, other): + if isinstance(other, self.__class__): + return (self.mac_address == other.mac_address) + return NotImplemented + def __ne__(self, other): + if isinstance(other, self.__class__): + return not self.__eq__(other) + return NotImplemented + + @classmethod + def populate (cls, *a, **kwa): + obj = cls (*a, **kwa) + obj.set_mac_address ([obj.populate_string ("mac_address")]) + return obj + def export(self, outfile, level=1, namespace_='', name_='MacAddressesType', namespacedef_='', pretty_print=True): + if pretty_print: + eol_ = '\n' + else: + eol_ = '' + showIndent(outfile, level, pretty_print) + outfile.write('<%s%s%s' % (namespace_, name_, namespacedef_ and ' ' + namespacedef_ or '', )) + already_processed = [] + self.exportAttributes(outfile, level, already_processed, namespace_, name_='MacAddressesType') + if self.hasContent_(): + outfile.write('>%s' % (eol_, )) + self.exportChildren(outfile, level + 1, namespace_, name_, pretty_print=pretty_print) + showIndent(outfile, level, pretty_print) + outfile.write('</%s%s>%s' % (namespace_, name_, eol_)) + else: + outfile.write('/>%s' % (eol_, )) + def exportAttributes(self, outfile, level, already_processed, namespace_='', name_='MacAddressesType'): + pass + def exportChildren(self, outfile, level, namespace_='', name_='MacAddressesType', fromsubclass_=False, pretty_print=True): + if pretty_print: + eol_ = '\n' + else: + eol_ = '' + for mac_address_ in self.mac_address: + showIndent(outfile, level, pretty_print) + outfile.write('<%smac-address>%s</%smac-address>%s' % (namespace_, self.gds_format_string(quote_xml(mac_address_).encode(ExternalEncoding), input_name='mac-address'), namespace_, eol_)) + def hasContent_(self): + if ( + self.mac_address + ): + return True + else: + return False + def exportLiteral(self, outfile, level, name_='MacAddressesType'): + level += 1 + self.exportLiteralAttributes(outfile, level, [], name_) + if self.hasContent_(): + self.exportLiteralChildren(outfile, level, name_) + def exportLiteralAttributes(self, outfile, level, already_processed, name_): + pass + def exportLiteralChildren(self, outfile, level, name_): + showIndent(outfile, level) + outfile.write('mac_address=[\n') + level += 1 + for mac_address_ in self.mac_address: + showIndent(outfile, level) + outfile.write('%s,\n' % quote_python(mac_address_).encode(ExternalEncoding)) + level -= 1 + showIndent(outfile, level) + outfile.write('],\n') + def exportDict(self, name_='MacAddressesType'): + obj_json = json.dumps(self, default=lambda o: dict((k, v) for k, v in o.__dict__.iteritems())) + obj_dict = json.loads(obj_json) + return {name_: obj_dict} + def build(self, node): + self.buildAttributes(node, node.attrib, []) + for child in node: + nodeName_ = Tag_pattern_.match(child.tag).groups()[-1] + self.buildChildren(child, node, nodeName_) + def buildAttributes(self, node, attrs, already_processed): + pass + def buildChildren(self, child_, node, nodeName_, fromsubclass_=False): + if nodeName_ == 'mac-address': + mac_address_ = child_.text + mac_address_ = self.gds_validate_string(mac_address_, node, 'mac_address') + self.mac_address.append(mac_address_) +# end class MacAddressesType + + +class IpAddressesType(GeneratedsSuper): + """ + IpAddressesType class definition from :doc:`vnc_cfg.xsd` + """ + subclass = None + superclass = None + def __init__(self, ip_address=None, **kwargs): + if (ip_address is None) or (ip_address == []): + self.ip_address = [] + else: + self.ip_address = ip_address + def factory(*args_, **kwargs_): + if IpAddressesType.subclass: + return IpAddressesType.subclass(*args_, **kwargs_) + else: + return IpAddressesType(*args_, **kwargs_) + factory = staticmethod(factory) + def get_ip_address(self): return self.ip_address + def set_ip_address(self, ip_address): self.ip_address = ip_address + def add_ip_address(self, value): self.ip_address.append(value) + def insert_ip_address(self, index, value): self.ip_address[index] = value + def delete_ip_address(self, value): self.ip_address.remove(value) + def validate_IpAddressType(self, value): + # Validate type IpAddressType, a restriction on xsd:string. + pass + def __eq__(self, other): + if isinstance(other, self.__class__): + return (self.ip_address == other.ip_address) + return NotImplemented + def __ne__(self, other): + if isinstance(other, self.__class__): + return not self.__eq__(other) + return NotImplemented + + @classmethod + def populate (cls, *a, **kwa): + obj = cls (*a, **kwa) + obj.set_ip_address ([obj.populate_string ("ip_address")]) + return obj + def export(self, outfile, level=1, namespace_='', name_='IpAddressesType', namespacedef_='', pretty_print=True): + if pretty_print: + eol_ = '\n' + else: + eol_ = '' + showIndent(outfile, level, pretty_print) + outfile.write('<%s%s%s' % (namespace_, name_, namespacedef_ and ' ' + namespacedef_ or '', )) + already_processed = [] + self.exportAttributes(outfile, level, already_processed, namespace_, name_='IpAddressesType') + if self.hasContent_(): + outfile.write('>%s' % (eol_, )) + self.exportChildren(outfile, level + 1, namespace_, name_, pretty_print=pretty_print) + showIndent(outfile, level, pretty_print) + outfile.write('</%s%s>%s' % (namespace_, name_, eol_)) + else: + outfile.write('/>%s' % (eol_, )) + def exportAttributes(self, outfile, level, already_processed, namespace_='', name_='IpAddressesType'): + pass + def exportChildren(self, outfile, level, namespace_='', name_='IpAddressesType', fromsubclass_=False, pretty_print=True): + if pretty_print: + eol_ = '\n' + else: + eol_ = '' + for ip_address_ in self.ip_address: + showIndent(outfile, level, pretty_print) + outfile.write('<%sip-address>%s</%sip-address>%s' % (namespace_, self.gds_format_string(quote_xml(ip_address_).encode(ExternalEncoding), input_name='ip-address'), namespace_, eol_)) + def hasContent_(self): + if ( + self.ip_address + ): + return True + else: + return False + def exportLiteral(self, outfile, level, name_='IpAddressesType'): + level += 1 + self.exportLiteralAttributes(outfile, level, [], name_) + if self.hasContent_(): + self.exportLiteralChildren(outfile, level, name_) + def exportLiteralAttributes(self, outfile, level, already_processed, name_): + pass + def exportLiteralChildren(self, outfile, level, name_): + showIndent(outfile, level) + outfile.write('ip_address=[\n') + level += 1 + for ip_address_ in self.ip_address: + showIndent(outfile, level) + outfile.write('%s,\n' % quote_python(ip_address_).encode(ExternalEncoding)) + level -= 1 + showIndent(outfile, level) + outfile.write('],\n') + def exportDict(self, name_='IpAddressesType'): + obj_json = json.dumps(self, default=lambda o: dict((k, v) for k, v in o.__dict__.iteritems())) + obj_dict = json.loads(obj_json) + return {name_: obj_dict} + def build(self, node): + self.buildAttributes(node, node.attrib, []) + for child in node: + nodeName_ = Tag_pattern_.match(child.tag).groups()[-1] + self.buildChildren(child, node, nodeName_) + def buildAttributes(self, node, attrs, already_processed): + pass + def buildChildren(self, child_, node, nodeName_, fromsubclass_=False): + if nodeName_ == 'ip-address': + ip_address_ = child_.text + ip_address_ = self.gds_validate_string(ip_address_, node, 'ip_address') + self.ip_address.append(ip_address_) + self.validate_IpAddressType(self.ip_address) # validate type IpAddressType +# end class IpAddressesType + + +class AllocationPoolType(GeneratedsSuper): + """ + AllocationPoolType class definition from :doc:`vnc_cfg.xsd` + """ + subclass = None + superclass = None + def __init__(self, start=None, end=None, **kwargs): + self.start = start + self.end = end + def factory(*args_, **kwargs_): + if AllocationPoolType.subclass: + return AllocationPoolType.subclass(*args_, **kwargs_) + else: + return AllocationPoolType(*args_, **kwargs_) + factory = staticmethod(factory) + def get_start(self): return self.start + def set_start(self, start): self.start = start + def get_end(self): return self.end + def set_end(self, end): self.end = end + def __eq__(self, other): + if isinstance(other, self.__class__): + return (self.start == other.start and + self.end == other.end) + return NotImplemented + def __ne__(self, other): + if isinstance(other, self.__class__): + return not self.__eq__(other) + return NotImplemented + + @classmethod + def populate (cls, *a, **kwa): + obj = cls (*a, **kwa) + obj.set_start (obj.populate_string ("start")) + obj.set_end (obj.populate_string ("end")) + return obj + def export(self, outfile, level=1, namespace_='', name_='AllocationPoolType', namespacedef_='', pretty_print=True): + if pretty_print: + eol_ = '\n' + else: + eol_ = '' + showIndent(outfile, level, pretty_print) + outfile.write('<%s%s%s' % (namespace_, name_, namespacedef_ and ' ' + namespacedef_ or '', )) + already_processed = [] + self.exportAttributes(outfile, level, already_processed, namespace_, name_='AllocationPoolType') + if self.hasContent_(): + outfile.write('>%s' % (eol_, )) + self.exportChildren(outfile, level + 1, namespace_, name_, pretty_print=pretty_print) + showIndent(outfile, level, pretty_print) + outfile.write('</%s%s>%s' % (namespace_, name_, eol_)) + else: + outfile.write('/>%s' % (eol_, )) + def exportAttributes(self, outfile, level, already_processed, namespace_='', name_='AllocationPoolType'): + pass + def exportChildren(self, outfile, level, namespace_='', name_='AllocationPoolType', fromsubclass_=False, pretty_print=True): + if pretty_print: + eol_ = '\n' + else: + eol_ = '' + if self.start is not None: + showIndent(outfile, level, pretty_print) + outfile.write('<%sstart>%s</%sstart>%s' % (namespace_, self.gds_format_string(quote_xml(self.start).encode(ExternalEncoding), input_name='start'), namespace_, eol_)) + if self.end is not None: + showIndent(outfile, level, pretty_print) + outfile.write('<%send>%s</%send>%s' % (namespace_, self.gds_format_string(quote_xml(self.end).encode(ExternalEncoding), input_name='end'), namespace_, eol_)) + def hasContent_(self): + if ( + self.start is not None or + self.end is not None + ): + return True + else: + return False + def exportLiteral(self, outfile, level, name_='AllocationPoolType'): + level += 1 + self.exportLiteralAttributes(outfile, level, [], name_) + if self.hasContent_(): + self.exportLiteralChildren(outfile, level, name_) + def exportLiteralAttributes(self, outfile, level, already_processed, name_): + pass + def exportLiteralChildren(self, outfile, level, name_): + if self.start is not None: + showIndent(outfile, level) + outfile.write('start=%s,\n' % quote_python(self.start).encode(ExternalEncoding)) + if self.end is not None: + showIndent(outfile, level) + outfile.write('end=%s,\n' % quote_python(self.end).encode(ExternalEncoding)) + def exportDict(self, name_='AllocationPoolType'): + obj_json = json.dumps(self, default=lambda o: dict((k, v) for k, v in o.__dict__.iteritems())) + obj_dict = json.loads(obj_json) + return {name_: obj_dict} + def build(self, node): + self.buildAttributes(node, node.attrib, []) + for child in node: + nodeName_ = Tag_pattern_.match(child.tag).groups()[-1] + self.buildChildren(child, node, nodeName_) + def buildAttributes(self, node, attrs, already_processed): + pass + def buildChildren(self, child_, node, nodeName_, fromsubclass_=False): + if nodeName_ == 'start': + start_ = child_.text + start_ = self.gds_validate_string(start_, node, 'start') + self.start = start_ + elif nodeName_ == 'end': + end_ = child_.text + end_ = self.gds_validate_string(end_, node, 'end') + self.end = end_ +# end class AllocationPoolType + + +class SubnetType(GeneratedsSuper): + """ + SubnetType class definition from :doc:`vnc_cfg.xsd` + """ + subclass = None + superclass = None + def __init__(self, ip_prefix=None, ip_prefix_len=None, **kwargs): + self.ip_prefix = ip_prefix + self.ip_prefix_len = ip_prefix_len + def factory(*args_, **kwargs_): + if SubnetType.subclass: + return SubnetType.subclass(*args_, **kwargs_) + else: + return SubnetType(*args_, **kwargs_) + factory = staticmethod(factory) + def get_ip_prefix(self): return self.ip_prefix + def set_ip_prefix(self, ip_prefix): self.ip_prefix = ip_prefix + def get_ip_prefix_len(self): return self.ip_prefix_len + def set_ip_prefix_len(self, ip_prefix_len): self.ip_prefix_len = ip_prefix_len + def __eq__(self, other): + if isinstance(other, self.__class__): + return (self.ip_prefix == other.ip_prefix and + self.ip_prefix_len == other.ip_prefix_len) + return NotImplemented + def __ne__(self, other): + if isinstance(other, self.__class__): + return not self.__eq__(other) + return NotImplemented + + @classmethod + def populate (cls, *a, **kwa): + obj = cls (*a, **kwa) + obj.set_ip_prefix (obj.populate_string ("ip_prefix")) + obj.set_ip_prefix_len (obj.populate_integer ("ip_prefix_len")) + return obj + def export(self, outfile, level=1, namespace_='', name_='SubnetType', namespacedef_='', pretty_print=True): + if pretty_print: + eol_ = '\n' + else: + eol_ = '' + showIndent(outfile, level, pretty_print) + outfile.write('<%s%s%s' % (namespace_, name_, namespacedef_ and ' ' + namespacedef_ or '', )) + already_processed = [] + self.exportAttributes(outfile, level, already_processed, namespace_, name_='SubnetType') + if self.hasContent_(): + outfile.write('>%s' % (eol_, )) + self.exportChildren(outfile, level + 1, namespace_, name_, pretty_print=pretty_print) + showIndent(outfile, level, pretty_print) + outfile.write('</%s%s>%s' % (namespace_, name_, eol_)) + else: + outfile.write('/>%s' % (eol_, )) + def exportAttributes(self, outfile, level, already_processed, namespace_='', name_='SubnetType'): + pass + def exportChildren(self, outfile, level, namespace_='', name_='SubnetType', fromsubclass_=False, pretty_print=True): + if pretty_print: + eol_ = '\n' + else: + eol_ = '' + if self.ip_prefix is not None: + showIndent(outfile, level, pretty_print) + outfile.write('<%sip-prefix>%s</%sip-prefix>%s' % (namespace_, self.gds_format_string(quote_xml(self.ip_prefix).encode(ExternalEncoding), input_name='ip-prefix'), namespace_, eol_)) + if self.ip_prefix_len is not None: + showIndent(outfile, level, pretty_print) + outfile.write('<%sip-prefix-len>%s</%sip-prefix-len>%s' % (namespace_, self.gds_format_integer(self.ip_prefix_len, input_name='ip-prefix-len'), namespace_, eol_)) + def hasContent_(self): + if ( + self.ip_prefix is not None or + self.ip_prefix_len is not None + ): + return True + else: + return False + def exportLiteral(self, outfile, level, name_='SubnetType'): + level += 1 + self.exportLiteralAttributes(outfile, level, [], name_) + if self.hasContent_(): + self.exportLiteralChildren(outfile, level, name_) + def exportLiteralAttributes(self, outfile, level, already_processed, name_): + pass + def exportLiteralChildren(self, outfile, level, name_): + if self.ip_prefix is not None: + showIndent(outfile, level) + outfile.write('ip_prefix=%s,\n' % quote_python(self.ip_prefix).encode(ExternalEncoding)) + if self.ip_prefix_len is not None: + showIndent(outfile, level) + outfile.write('ip_prefix_len=%d,\n' % self.ip_prefix_len) + def exportDict(self, name_='SubnetType'): + obj_json = json.dumps(self, default=lambda o: dict((k, v) for k, v in o.__dict__.iteritems())) + obj_dict = json.loads(obj_json) + return {name_: obj_dict} + def build(self, node): + self.buildAttributes(node, node.attrib, []) + for child in node: + nodeName_ = Tag_pattern_.match(child.tag).groups()[-1] + self.buildChildren(child, node, nodeName_) + def buildAttributes(self, node, attrs, already_processed): + pass + def buildChildren(self, child_, node, nodeName_, fromsubclass_=False): + if nodeName_ == 'ip-prefix': + ip_prefix_ = child_.text + ip_prefix_ = self.gds_validate_string(ip_prefix_, node, 'ip_prefix') + self.ip_prefix = ip_prefix_ + elif nodeName_ == 'ip-prefix-len': + sval_ = child_.text + try: + ival_ = int(sval_) + except (TypeError, ValueError), exp: + raise_parse_error(child_, 'requires integer: %s' % exp) + ival_ = self.gds_validate_integer(ival_, node, 'ip_prefix_len') + self.ip_prefix_len = ival_ +# end class SubnetType + + +class AllowedAddressPair(GeneratedsSuper): + """ + AllowedAddressPair class definition from :doc:`vnc_cfg.xsd` + """ + subclass = None + superclass = None + def __init__(self, ip=None, mac=None, address_mode=None, **kwargs): + if isinstance(ip, dict): + obj = SubnetType(**ip) + self.ip = obj + else: + self.ip = ip + self.mac = mac + self.address_mode = address_mode + def factory(*args_, **kwargs_): + if AllowedAddressPair.subclass: + return AllowedAddressPair.subclass(*args_, **kwargs_) + else: + return AllowedAddressPair(*args_, **kwargs_) + factory = staticmethod(factory) + def get_ip(self): return self.ip + def set_ip(self, ip): self.ip = ip + def get_mac(self): return self.mac + def set_mac(self, mac): self.mac = mac + def get_address_mode(self): return self.address_mode + def set_address_mode(self, address_mode): self.address_mode = address_mode + def validate_AddressMode(self, value): + # Validate type AddressMode, a restriction on xsd:string. + error = False + if isinstance(value, list): + error = set(value) - set([u'active-active', u'active-standby']) + else: + error = value not in [u'active-active', u'active-standby'] + if error: + raise ValueError("AddressMode must be one of [u'active-active', u'active-standby']") + def __eq__(self, other): + if isinstance(other, self.__class__): + return (self.ip == other.ip and + self.mac == other.mac and + self.address_mode == other.address_mode) + return NotImplemented + def __ne__(self, other): + if isinstance(other, self.__class__): + return not self.__eq__(other) + return NotImplemented + + @classmethod + def populate (cls, *a, **kwa): + obj = cls (*a, **kwa) + obj.set_ip (SubnetType.populate ()) + obj.set_mac (obj.populate_string ("mac")) + obj.set_address_mode (obj.populate_string ("address_mode")) + return obj + def export(self, outfile, level=1, namespace_='', name_='AllowedAddressPair', namespacedef_='', pretty_print=True): + if pretty_print: + eol_ = '\n' + else: + eol_ = '' + showIndent(outfile, level, pretty_print) + outfile.write('<%s%s%s' % (namespace_, name_, namespacedef_ and ' ' + namespacedef_ or '', )) + already_processed = [] + self.exportAttributes(outfile, level, already_processed, namespace_, name_='AllowedAddressPair') + if self.hasContent_(): + outfile.write('>%s' % (eol_, )) + self.exportChildren(outfile, level + 1, namespace_, name_, pretty_print=pretty_print) + showIndent(outfile, level, pretty_print) + outfile.write('</%s%s>%s' % (namespace_, name_, eol_)) + else: + outfile.write('/>%s' % (eol_, )) + def exportAttributes(self, outfile, level, already_processed, namespace_='', name_='AllowedAddressPair'): + pass + def exportChildren(self, outfile, level, namespace_='', name_='AllowedAddressPair', fromsubclass_=False, pretty_print=True): + if pretty_print: + eol_ = '\n' + else: + eol_ = '' + if self.ip is not None: + self.ip.export(outfile, level, namespace_, name_='ip', pretty_print=pretty_print) + if self.mac is not None: + showIndent(outfile, level, pretty_print) + outfile.write('<%smac>%s</%smac>%s' % (namespace_, self.gds_format_string(quote_xml(self.mac).encode(ExternalEncoding), input_name='mac'), namespace_, eol_)) + if self.address_mode is not None: + showIndent(outfile, level, pretty_print) + outfile.write('<%saddress-mode>%s</%saddress-mode>%s' % (namespace_, self.gds_format_string(quote_xml(self.address_mode).encode(ExternalEncoding), input_name='address-mode'), namespace_, eol_)) + def hasContent_(self): + if ( + self.ip is not None or + self.mac is not None or + self.address_mode is not None + ): + return True + else: + return False + def exportLiteral(self, outfile, level, name_='AllowedAddressPair'): + level += 1 + self.exportLiteralAttributes(outfile, level, [], name_) + if self.hasContent_(): + self.exportLiteralChildren(outfile, level, name_) + def exportLiteralAttributes(self, outfile, level, already_processed, name_): + pass + def exportLiteralChildren(self, outfile, level, name_): + if self.ip is not None: + showIndent(outfile, level) + outfile.write('ip=model_.SubnetType(\n') + self.ip.exportLiteral(outfile, level, name_='ip') + showIndent(outfile, level) + outfile.write('),\n') + if self.mac is not None: + showIndent(outfile, level) + outfile.write('mac=%s,\n' % quote_python(self.mac).encode(ExternalEncoding)) + if self.address_mode is not None: + showIndent(outfile, level) + outfile.write('address_mode=%s,\n' % quote_python(self.address_mode).encode(ExternalEncoding)) + def exportDict(self, name_='AllowedAddressPair'): + obj_json = json.dumps(self, default=lambda o: dict((k, v) for k, v in o.__dict__.iteritems())) + obj_dict = json.loads(obj_json) + return {name_: obj_dict} + def build(self, node): + self.buildAttributes(node, node.attrib, []) + for child in node: + nodeName_ = Tag_pattern_.match(child.tag).groups()[-1] + self.buildChildren(child, node, nodeName_) + def buildAttributes(self, node, attrs, already_processed): + pass + def buildChildren(self, child_, node, nodeName_, fromsubclass_=False): + if nodeName_ == 'ip': + obj_ = SubnetType.factory() + obj_.build(child_) + self.set_ip(obj_) + elif nodeName_ == 'mac': + mac_ = child_.text + mac_ = self.gds_validate_string(mac_, node, 'mac') + self.mac = mac_ + elif nodeName_ == 'address-mode': + address_mode_ = child_.text + address_mode_ = self.gds_validate_string(address_mode_, node, 'address_mode') + self.address_mode = address_mode_ + self.validate_AddressMode(self.address_mode) # validate type AddressMode +# end class AllowedAddressPair + + +class AllowedAddressPairs(GeneratedsSuper): + """ + AllowedAddressPairs class definition from :doc:`vnc_cfg.xsd` + """ + subclass = None + superclass = None + def __init__(self, allowed_address_pair=None, **kwargs): + if (allowed_address_pair is None) or (allowed_address_pair == []): + self.allowed_address_pair = [] + else: + if isinstance(allowed_address_pair[0], dict): + objs = [AllowedAddressPair(**elem) for elem in allowed_address_pair] + self.allowed_address_pair = objs + else: + self.allowed_address_pair = allowed_address_pair + def factory(*args_, **kwargs_): + if AllowedAddressPairs.subclass: + return AllowedAddressPairs.subclass(*args_, **kwargs_) + else: + return AllowedAddressPairs(*args_, **kwargs_) + factory = staticmethod(factory) + def get_allowed_address_pair(self): return self.allowed_address_pair + def set_allowed_address_pair(self, allowed_address_pair): self.allowed_address_pair = allowed_address_pair + def add_allowed_address_pair(self, value): self.allowed_address_pair.append(value) + def insert_allowed_address_pair(self, index, value): self.allowed_address_pair[index] = value + def delete_allowed_address_pair(self, value): self.allowed_address_pair.remove(value) + def __eq__(self, other): + if isinstance(other, self.__class__): + return (self.allowed_address_pair == other.allowed_address_pair) + return NotImplemented + def __ne__(self, other): + if isinstance(other, self.__class__): + return not self.__eq__(other) + return NotImplemented + + @classmethod + def populate (cls, *a, **kwa): + obj = cls (*a, **kwa) + obj.set_allowed_address_pair ([AllowedAddressPair.populate ()]) + return obj + def export(self, outfile, level=1, namespace_='', name_='AllowedAddressPairs', namespacedef_='', pretty_print=True): + if pretty_print: + eol_ = '\n' + else: + eol_ = '' + showIndent(outfile, level, pretty_print) + outfile.write('<%s%s%s' % (namespace_, name_, namespacedef_ and ' ' + namespacedef_ or '', )) + already_processed = [] + self.exportAttributes(outfile, level, already_processed, namespace_, name_='AllowedAddressPairs') + if self.hasContent_(): + outfile.write('>%s' % (eol_, )) + self.exportChildren(outfile, level + 1, namespace_, name_, pretty_print=pretty_print) + showIndent(outfile, level, pretty_print) + outfile.write('</%s%s>%s' % (namespace_, name_, eol_)) + else: + outfile.write('/>%s' % (eol_, )) + def exportAttributes(self, outfile, level, already_processed, namespace_='', name_='AllowedAddressPairs'): + pass + def exportChildren(self, outfile, level, namespace_='', name_='AllowedAddressPairs', fromsubclass_=False, pretty_print=True): + if pretty_print: + eol_ = '\n' + else: + eol_ = '' + for allowed_address_pair_ in self.allowed_address_pair: + if isinstance(allowed_address_pair_, dict): + allowed_address_pair_ = AllowedAddressPair(**allowed_address_pair_) + allowed_address_pair_.export(outfile, level, namespace_, name_='allowed-address-pair', pretty_print=pretty_print) + def hasContent_(self): + if ( + self.allowed_address_pair + ): + return True + else: + return False + def exportLiteral(self, outfile, level, name_='AllowedAddressPairs'): + level += 1 + self.exportLiteralAttributes(outfile, level, [], name_) + if self.hasContent_(): + self.exportLiteralChildren(outfile, level, name_) + def exportLiteralAttributes(self, outfile, level, already_processed, name_): + pass + def exportLiteralChildren(self, outfile, level, name_): + showIndent(outfile, level) + outfile.write('allowed_address_pair=[\n') + level += 1 + for allowed_address_pair_ in self.allowed_address_pair: + showIndent(outfile, level) + outfile.write('model_.AllowedAddressPair(\n') + allowed_address_pair_.exportLiteral(outfile, level, name_='AllowedAddressPair') + showIndent(outfile, level) + outfile.write('),\n') + level -= 1 + showIndent(outfile, level) + outfile.write('],\n') + def exportDict(self, name_='AllowedAddressPairs'): + obj_json = json.dumps(self, default=lambda o: dict((k, v) for k, v in o.__dict__.iteritems())) + obj_dict = json.loads(obj_json) + return {name_: obj_dict} + def build(self, node): + self.buildAttributes(node, node.attrib, []) + for child in node: + nodeName_ = Tag_pattern_.match(child.tag).groups()[-1] + self.buildChildren(child, node, nodeName_) + def buildAttributes(self, node, attrs, already_processed): + pass + def buildChildren(self, child_, node, nodeName_, fromsubclass_=False): + if nodeName_ == 'allowed-address-pair': + obj_ = AllowedAddressPair.factory() + obj_.build(child_) + self.allowed_address_pair.append(obj_) +# end class AllowedAddressPairs + + +class UuidType(GeneratedsSuper): + """ + UuidType class definition from :doc:`vnc_cfg.xsd` + """ + subclass = None + superclass = None + def __init__(self, uuid_mslong=None, uuid_lslong=None, **kwargs): + self.uuid_mslong = uuid_mslong + self.uuid_lslong = uuid_lslong + def factory(*args_, **kwargs_): + if UuidType.subclass: + return UuidType.subclass(*args_, **kwargs_) + else: + return UuidType(*args_, **kwargs_) + factory = staticmethod(factory) + def get_uuid_mslong(self): return self.uuid_mslong + def set_uuid_mslong(self, uuid_mslong): self.uuid_mslong = uuid_mslong + def get_uuid_lslong(self): return self.uuid_lslong + def set_uuid_lslong(self, uuid_lslong): self.uuid_lslong = uuid_lslong + def __eq__(self, other): + if isinstance(other, self.__class__): + return (self.uuid_mslong == other.uuid_mslong and + self.uuid_lslong == other.uuid_lslong) + return NotImplemented + def __ne__(self, other): + if isinstance(other, self.__class__): + return not self.__eq__(other) + return NotImplemented + + @classmethod + def populate (cls, *a, **kwa): + obj = cls (*a, **kwa) + obj.set_uuid_mslong (obj.populate_unsignedLong ("uuid_mslong")) + obj.set_uuid_lslong (obj.populate_unsignedLong ("uuid_lslong")) + return obj + def export(self, outfile, level=1, namespace_='', name_='UuidType', namespacedef_='', pretty_print=True): + if pretty_print: + eol_ = '\n' + else: + eol_ = '' + showIndent(outfile, level, pretty_print) + outfile.write('<%s%s%s' % (namespace_, name_, namespacedef_ and ' ' + namespacedef_ or '', )) + already_processed = [] + self.exportAttributes(outfile, level, already_processed, namespace_, name_='UuidType') + if self.hasContent_(): + outfile.write('>%s' % (eol_, )) + self.exportChildren(outfile, level + 1, namespace_, name_, pretty_print=pretty_print) + showIndent(outfile, level, pretty_print) + outfile.write('</%s%s>%s' % (namespace_, name_, eol_)) + else: + outfile.write('/>%s' % (eol_, )) + def exportAttributes(self, outfile, level, already_processed, namespace_='', name_='UuidType'): + pass + def exportChildren(self, outfile, level, namespace_='', name_='UuidType', fromsubclass_=False, pretty_print=True): + if pretty_print: + eol_ = '\n' + else: + eol_ = '' + if self.uuid_mslong is not None: + showIndent(outfile, level, pretty_print) + outfile.write('<%suuid-mslong>%s</%suuid-mslong>%s' % (namespace_, self.gds_format_integer(self.uuid_mslong, input_name='uuid-mslong'), namespace_, eol_)) + if self.uuid_lslong is not None: + showIndent(outfile, level, pretty_print) + outfile.write('<%suuid-lslong>%s</%suuid-lslong>%s' % (namespace_, self.gds_format_integer(self.uuid_lslong, input_name='uuid-lslong'), namespace_, eol_)) + def hasContent_(self): + if ( + self.uuid_mslong is not None or + self.uuid_lslong is not None + ): + return True + else: + return False + def exportLiteral(self, outfile, level, name_='UuidType'): + level += 1 + self.exportLiteralAttributes(outfile, level, [], name_) + if self.hasContent_(): + self.exportLiteralChildren(outfile, level, name_) + def exportLiteralAttributes(self, outfile, level, already_processed, name_): + pass + def exportLiteralChildren(self, outfile, level, name_): + if self.uuid_mslong is not None: + showIndent(outfile, level) + outfile.write('uuid_mslong=%d,\n' % self.uuid_mslong) + if self.uuid_lslong is not None: + showIndent(outfile, level) + outfile.write('uuid_lslong=%d,\n' % self.uuid_lslong) + def exportDict(self, name_='UuidType'): + obj_json = json.dumps(self, default=lambda o: dict((k, v) for k, v in o.__dict__.iteritems())) + obj_dict = json.loads(obj_json) + return {name_: obj_dict} + def build(self, node): + self.buildAttributes(node, node.attrib, []) + for child in node: + nodeName_ = Tag_pattern_.match(child.tag).groups()[-1] + self.buildChildren(child, node, nodeName_) + def buildAttributes(self, node, attrs, already_processed): + pass + def buildChildren(self, child_, node, nodeName_, fromsubclass_=False): + if nodeName_ == 'uuid-mslong': + sval_ = child_.text + try: + ival_ = int(sval_) + except (TypeError, ValueError), exp: + raise_parse_error(child_, 'requires integer: %s' % exp) + ival_ = self.gds_validate_integer(ival_, node, 'uuid_mslong') + self.uuid_mslong = ival_ + elif nodeName_ == 'uuid-lslong': + sval_ = child_.text + try: + ival_ = int(sval_) + except (TypeError, ValueError), exp: + raise_parse_error(child_, 'requires integer: %s' % exp) + ival_ = self.gds_validate_integer(ival_, node, 'uuid_lslong') + self.uuid_lslong = ival_ +# end class UuidType + + +class SequenceType(GeneratedsSuper): + """ + SequenceType class definition from :doc:`vnc_cfg.xsd` + """ + subclass = None + superclass = None + def __init__(self, major=None, minor=None, **kwargs): + self.major = major + self.minor = minor + def factory(*args_, **kwargs_): + if SequenceType.subclass: + return SequenceType.subclass(*args_, **kwargs_) + else: + return SequenceType(*args_, **kwargs_) + factory = staticmethod(factory) + def get_major(self): return self.major + def set_major(self, major): self.major = major + def get_minor(self): return self.minor + def set_minor(self, minor): self.minor = minor + def __eq__(self, other): + if isinstance(other, self.__class__): + return (self.major == other.major and + self.minor == other.minor) + return NotImplemented + def __ne__(self, other): + if isinstance(other, self.__class__): + return not self.__eq__(other) + return NotImplemented + + @classmethod + def populate (cls, *a, **kwa): + obj = cls (*a, **kwa) + obj.set_major (obj.populate_integer ("major")) + obj.set_minor (obj.populate_integer ("minor")) + return obj + def export(self, outfile, level=1, namespace_='', name_='SequenceType', namespacedef_='', pretty_print=True): + if pretty_print: + eol_ = '\n' + else: + eol_ = '' + showIndent(outfile, level, pretty_print) + outfile.write('<%s%s%s' % (namespace_, name_, namespacedef_ and ' ' + namespacedef_ or '', )) + already_processed = [] + self.exportAttributes(outfile, level, already_processed, namespace_, name_='SequenceType') + if self.hasContent_(): + outfile.write('>%s' % (eol_, )) + self.exportChildren(outfile, level + 1, namespace_, name_, pretty_print=pretty_print) + showIndent(outfile, level, pretty_print) + outfile.write('</%s%s>%s' % (namespace_, name_, eol_)) + else: + outfile.write('/>%s' % (eol_, )) + def exportAttributes(self, outfile, level, already_processed, namespace_='', name_='SequenceType'): + pass + def exportChildren(self, outfile, level, namespace_='', name_='SequenceType', fromsubclass_=False, pretty_print=True): + if pretty_print: + eol_ = '\n' + else: + eol_ = '' + if self.major is not None: + showIndent(outfile, level, pretty_print) + outfile.write('<%smajor>%s</%smajor>%s' % (namespace_, self.gds_format_integer(self.major, input_name='major'), namespace_, eol_)) + if self.minor is not None: + showIndent(outfile, level, pretty_print) + outfile.write('<%sminor>%s</%sminor>%s' % (namespace_, self.gds_format_integer(self.minor, input_name='minor'), namespace_, eol_)) + def hasContent_(self): + if ( + self.major is not None or + self.minor is not None + ): + return True + else: + return False + def exportLiteral(self, outfile, level, name_='SequenceType'): + level += 1 + self.exportLiteralAttributes(outfile, level, [], name_) + if self.hasContent_(): + self.exportLiteralChildren(outfile, level, name_) + def exportLiteralAttributes(self, outfile, level, already_processed, name_): + pass + def exportLiteralChildren(self, outfile, level, name_): + if self.major is not None: + showIndent(outfile, level) + outfile.write('major=%d,\n' % self.major) + if self.minor is not None: + showIndent(outfile, level) + outfile.write('minor=%d,\n' % self.minor) + def exportDict(self, name_='SequenceType'): + obj_json = json.dumps(self, default=lambda o: dict((k, v) for k, v in o.__dict__.iteritems())) + obj_dict = json.loads(obj_json) + return {name_: obj_dict} + def build(self, node): + self.buildAttributes(node, node.attrib, []) + for child in node: + nodeName_ = Tag_pattern_.match(child.tag).groups()[-1] + self.buildChildren(child, node, nodeName_) + def buildAttributes(self, node, attrs, already_processed): + pass + def buildChildren(self, child_, node, nodeName_, fromsubclass_=False): + if nodeName_ == 'major': + sval_ = child_.text + try: + ival_ = int(sval_) + except (TypeError, ValueError), exp: + raise_parse_error(child_, 'requires integer: %s' % exp) + ival_ = self.gds_validate_integer(ival_, node, 'major') + self.major = ival_ + elif nodeName_ == 'minor': + sval_ = child_.text + try: + ival_ = int(sval_) + except (TypeError, ValueError), exp: + raise_parse_error(child_, 'requires integer: %s' % exp) + ival_ = self.gds_validate_integer(ival_, node, 'minor') + self.minor = ival_ +# end class SequenceType + + +class TimerType(GeneratedsSuper): + """ + TimerType class definition from :doc:`vnc_cfg.xsd` + """ + subclass = None + superclass = None + def __init__(self, start_time=None, on_interval=None, off_interval=None, end_time=None, **kwargs): + self.start_time = start_time + self.on_interval = on_interval + self.off_interval = off_interval + self.end_time = end_time + def factory(*args_, **kwargs_): + if TimerType.subclass: + return TimerType.subclass(*args_, **kwargs_) + else: + return TimerType(*args_, **kwargs_) + factory = staticmethod(factory) + def get_start_time(self): return self.start_time + def set_start_time(self, start_time): self.start_time = start_time + def get_on_interval(self): return self.on_interval + def set_on_interval(self, on_interval): self.on_interval = on_interval + def get_off_interval(self): return self.off_interval + def set_off_interval(self, off_interval): self.off_interval = off_interval + def get_end_time(self): return self.end_time + def set_end_time(self, end_time): self.end_time = end_time + def __eq__(self, other): + if isinstance(other, self.__class__): + return (self.start_time == other.start_time and + self.on_interval == other.on_interval and + self.off_interval == other.off_interval and + self.end_time == other.end_time) + return NotImplemented + def __ne__(self, other): + if isinstance(other, self.__class__): + return not self.__eq__(other) + return NotImplemented + + @classmethod + def populate (cls, *a, **kwa): + obj = cls (*a, **kwa) + obj.set_start_time (obj.populate_dateTime ("start_time")) + obj.set_on_interval (obj.populate_time ("on_interval")) + obj.set_off_interval (obj.populate_time ("off_interval")) + obj.set_end_time (obj.populate_dateTime ("end_time")) + return obj + def export(self, outfile, level=1, namespace_='', name_='TimerType', namespacedef_='', pretty_print=True): + if pretty_print: + eol_ = '\n' + else: + eol_ = '' + showIndent(outfile, level, pretty_print) + outfile.write('<%s%s%s' % (namespace_, name_, namespacedef_ and ' ' + namespacedef_ or '', )) + already_processed = [] + self.exportAttributes(outfile, level, already_processed, namespace_, name_='TimerType') + if self.hasContent_(): + outfile.write('>%s' % (eol_, )) + self.exportChildren(outfile, level + 1, namespace_, name_, pretty_print=pretty_print) + showIndent(outfile, level, pretty_print) + outfile.write('</%s%s>%s' % (namespace_, name_, eol_)) + else: + outfile.write('/>%s' % (eol_, )) + def exportAttributes(self, outfile, level, already_processed, namespace_='', name_='TimerType'): + pass + def exportChildren(self, outfile, level, namespace_='', name_='TimerType', fromsubclass_=False, pretty_print=True): + if pretty_print: + eol_ = '\n' + else: + eol_ = '' + if self.start_time is not None: + showIndent(outfile, level, pretty_print) + outfile.write('<%sstart-time>%s</%sstart-time>%s' % (namespace_, self.gds_format_string(quote_xml(self.start_time).encode(ExternalEncoding), input_name='start-time'), namespace_, eol_)) + if self.on_interval is not None: + showIndent(outfile, level, pretty_print) + outfile.write('<%son-interval>%s</%son-interval>%s' % (namespace_, self.gds_format_string(quote_xml(self.on_interval).encode(ExternalEncoding), input_name='on-interval'), namespace_, eol_)) + if self.off_interval is not None: + showIndent(outfile, level, pretty_print) + outfile.write('<%soff-interval>%s</%soff-interval>%s' % (namespace_, self.gds_format_string(quote_xml(self.off_interval).encode(ExternalEncoding), input_name='off-interval'), namespace_, eol_)) + if self.end_time is not None: + showIndent(outfile, level, pretty_print) + outfile.write('<%send-time>%s</%send-time>%s' % (namespace_, self.gds_format_string(quote_xml(self.end_time).encode(ExternalEncoding), input_name='end-time'), namespace_, eol_)) + def hasContent_(self): + if ( + self.start_time is not None or + self.on_interval is not None or + self.off_interval is not None or + self.end_time is not None + ): + return True + else: + return False + def exportLiteral(self, outfile, level, name_='TimerType'): + level += 1 + self.exportLiteralAttributes(outfile, level, [], name_) + if self.hasContent_(): + self.exportLiteralChildren(outfile, level, name_) + def exportLiteralAttributes(self, outfile, level, already_processed, name_): + pass + def exportLiteralChildren(self, outfile, level, name_): + if self.start_time is not None: + showIndent(outfile, level) + outfile.write('start_time=%s,\n' % quote_python(self.start_time).encode(ExternalEncoding)) + if self.on_interval is not None: + showIndent(outfile, level) + outfile.write('on_interval=%s,\n' % quote_python(self.on_interval).encode(ExternalEncoding)) + if self.off_interval is not None: + showIndent(outfile, level) + outfile.write('off_interval=%s,\n' % quote_python(self.off_interval).encode(ExternalEncoding)) + if self.end_time is not None: + showIndent(outfile, level) + outfile.write('end_time=%s,\n' % quote_python(self.end_time).encode(ExternalEncoding)) + def exportDict(self, name_='TimerType'): + obj_json = json.dumps(self, default=lambda o: dict((k, v) for k, v in o.__dict__.iteritems())) + obj_dict = json.loads(obj_json) + return {name_: obj_dict} + def build(self, node): + self.buildAttributes(node, node.attrib, []) + for child in node: + nodeName_ = Tag_pattern_.match(child.tag).groups()[-1] + self.buildChildren(child, node, nodeName_) + def buildAttributes(self, node, attrs, already_processed): + pass + def buildChildren(self, child_, node, nodeName_, fromsubclass_=False): + if nodeName_ == 'start-time': + start_time_ = child_.text + start_time_ = self.gds_validate_string(start_time_, node, 'start_time') + self.start_time = start_time_ + elif nodeName_ == 'on-interval': + on_interval_ = child_.text + on_interval_ = self.gds_validate_string(on_interval_, node, 'on_interval') + self.on_interval = on_interval_ + elif nodeName_ == 'off-interval': + off_interval_ = child_.text + off_interval_ = self.gds_validate_string(off_interval_, node, 'off_interval') + self.off_interval = off_interval_ + elif nodeName_ == 'end-time': + end_time_ = child_.text + end_time_ = self.gds_validate_string(end_time_, node, 'end_time') + self.end_time = end_time_ +# end class TimerType + + +class VirtualNetworkPolicyType(GeneratedsSuper): + """ + VirtualNetworkPolicyType class definition from :doc:`vnc_cfg.xsd` + """ + subclass = None + superclass = None + def __init__(self, sequence=None, timer=None, **kwargs): + if isinstance(sequence, dict): + obj = SequenceType(**sequence) + self.sequence = obj + else: + self.sequence = sequence + if isinstance(timer, dict): + obj = TimerType(**timer) + self.timer = obj + else: + self.timer = timer + def factory(*args_, **kwargs_): + if VirtualNetworkPolicyType.subclass: + return VirtualNetworkPolicyType.subclass(*args_, **kwargs_) + else: + return VirtualNetworkPolicyType(*args_, **kwargs_) + factory = staticmethod(factory) + def get_sequence(self): return self.sequence + def set_sequence(self, sequence): self.sequence = sequence + def get_timer(self): return self.timer + def set_timer(self, timer): self.timer = timer + def __eq__(self, other): + if isinstance(other, self.__class__): + return (self.sequence == other.sequence and + self.timer == other.timer) + return NotImplemented + def __ne__(self, other): + if isinstance(other, self.__class__): + return not self.__eq__(other) + return NotImplemented + + @classmethod + def populate (cls, *a, **kwa): + obj = cls (*a, **kwa) + obj.set_sequence (SequenceType.populate ()) + obj.set_timer (TimerType.populate ()) + return obj + def export(self, outfile, level=1, namespace_='', name_='VirtualNetworkPolicyType', namespacedef_='', pretty_print=True): + if pretty_print: + eol_ = '\n' + else: + eol_ = '' + showIndent(outfile, level, pretty_print) + outfile.write('<%s%s%s' % (namespace_, name_, namespacedef_ and ' ' + namespacedef_ or '', )) + already_processed = [] + self.exportAttributes(outfile, level, already_processed, namespace_, name_='VirtualNetworkPolicyType') + if self.hasContent_(): + outfile.write('>%s' % (eol_, )) + self.exportChildren(outfile, level + 1, namespace_, name_, pretty_print=pretty_print) + showIndent(outfile, level, pretty_print) + outfile.write('</%s%s>%s' % (namespace_, name_, eol_)) + else: + outfile.write('/>%s' % (eol_, )) + def exportAttributes(self, outfile, level, already_processed, namespace_='', name_='VirtualNetworkPolicyType'): + pass + def exportChildren(self, outfile, level, namespace_='', name_='VirtualNetworkPolicyType', fromsubclass_=False, pretty_print=True): + if pretty_print: + eol_ = '\n' + else: + eol_ = '' + if self.sequence is not None: + self.sequence.export(outfile, level, namespace_, name_='sequence', pretty_print=pretty_print) + if self.timer is not None: + self.timer.export(outfile, level, namespace_, name_='timer', pretty_print=pretty_print) + def hasContent_(self): + if ( + self.sequence is not None or + self.timer is not None + ): + return True + else: + return False + def exportLiteral(self, outfile, level, name_='VirtualNetworkPolicyType'): + level += 1 + self.exportLiteralAttributes(outfile, level, [], name_) + if self.hasContent_(): + self.exportLiteralChildren(outfile, level, name_) + def exportLiteralAttributes(self, outfile, level, already_processed, name_): + pass + def exportLiteralChildren(self, outfile, level, name_): + if self.sequence is not None: + showIndent(outfile, level) + outfile.write('sequence=model_.SequenceType(\n') + self.sequence.exportLiteral(outfile, level, name_='sequence') + showIndent(outfile, level) + outfile.write('),\n') + if self.timer is not None: + showIndent(outfile, level) + outfile.write('timer=model_.TimerType(\n') + self.timer.exportLiteral(outfile, level, name_='timer') + showIndent(outfile, level) + outfile.write('),\n') + def exportDict(self, name_='VirtualNetworkPolicyType'): + obj_json = json.dumps(self, default=lambda o: dict((k, v) for k, v in o.__dict__.iteritems())) + obj_dict = json.loads(obj_json) + return {name_: obj_dict} + def build(self, node): + self.buildAttributes(node, node.attrib, []) + for child in node: + nodeName_ = Tag_pattern_.match(child.tag).groups()[-1] + self.buildChildren(child, node, nodeName_) + def buildAttributes(self, node, attrs, already_processed): + pass + def buildChildren(self, child_, node, nodeName_, fromsubclass_=False): + if nodeName_ == 'sequence': + obj_ = SequenceType.factory() + obj_.build(child_) + self.set_sequence(obj_) + elif nodeName_ == 'timer': + obj_ = TimerType.factory() + obj_.build(child_) + self.set_timer(obj_) +# end class VirtualNetworkPolicyType + + +class AddressType(GeneratedsSuper): + """ + AddressType class definition from :doc:`vnc_cfg.xsd` + """ + subclass = None + superclass = None + def __init__(self, subnet=None, virtual_network=None, security_group=None, network_policy=None, **kwargs): + if isinstance(subnet, dict): + obj = SubnetType(**subnet) + self.subnet = obj + else: + self.subnet = subnet + self.virtual_network = virtual_network + self.security_group = security_group + self.network_policy = network_policy + def factory(*args_, **kwargs_): + if AddressType.subclass: + return AddressType.subclass(*args_, **kwargs_) + else: + return AddressType(*args_, **kwargs_) + factory = staticmethod(factory) + def get_subnet(self): return self.subnet + def set_subnet(self, subnet): self.subnet = subnet + def get_virtual_network(self): return self.virtual_network + def set_virtual_network(self, virtual_network): self.virtual_network = virtual_network + def get_security_group(self): return self.security_group + def set_security_group(self, security_group): self.security_group = security_group + def get_network_policy(self): return self.network_policy + def set_network_policy(self, network_policy): self.network_policy = network_policy + def __eq__(self, other): + if isinstance(other, self.__class__): + return (self.subnet == other.subnet and + self.virtual_network == other.virtual_network and + self.security_group == other.security_group and + self.network_policy == other.network_policy) + return NotImplemented + def __ne__(self, other): + if isinstance(other, self.__class__): + return not self.__eq__(other) + return NotImplemented + + @classmethod + def populate (cls, *a, **kwa): + obj = cls (*a, **kwa) + obj.set_subnet (SubnetType.populate ()) + obj.set_virtual_network (obj.populate_string ("virtual_network")) + obj.set_security_group (obj.populate_string ("security_group")) + obj.set_network_policy (obj.populate_string ("network_policy")) + return obj + def export(self, outfile, level=1, namespace_='', name_='AddressType', namespacedef_='', pretty_print=True): + if pretty_print: + eol_ = '\n' + else: + eol_ = '' + showIndent(outfile, level, pretty_print) + outfile.write('<%s%s%s' % (namespace_, name_, namespacedef_ and ' ' + namespacedef_ or '', )) + already_processed = [] + self.exportAttributes(outfile, level, already_processed, namespace_, name_='AddressType') + if self.hasContent_(): + outfile.write('>%s' % (eol_, )) + self.exportChildren(outfile, level + 1, namespace_, name_, pretty_print=pretty_print) + showIndent(outfile, level, pretty_print) + outfile.write('</%s%s>%s' % (namespace_, name_, eol_)) + else: + outfile.write('/>%s' % (eol_, )) + def exportAttributes(self, outfile, level, already_processed, namespace_='', name_='AddressType'): + pass + def exportChildren(self, outfile, level, namespace_='', name_='AddressType', fromsubclass_=False, pretty_print=True): + if pretty_print: + eol_ = '\n' + else: + eol_ = '' + if self.subnet is not None: + self.subnet.export(outfile, level, namespace_, name_='subnet', pretty_print=pretty_print) + if self.virtual_network is not None: + showIndent(outfile, level, pretty_print) + outfile.write('<%svirtual-network>%s</%svirtual-network>%s' % (namespace_, self.gds_format_string(quote_xml(self.virtual_network).encode(ExternalEncoding), input_name='virtual-network'), namespace_, eol_)) + if self.security_group is not None: + showIndent(outfile, level, pretty_print) + outfile.write('<%ssecurity-group>%s</%ssecurity-group>%s' % (namespace_, self.gds_format_string(quote_xml(self.security_group).encode(ExternalEncoding), input_name='security-group'), namespace_, eol_)) + if self.network_policy is not None: + showIndent(outfile, level, pretty_print) + outfile.write('<%snetwork-policy>%s</%snetwork-policy>%s' % (namespace_, self.gds_format_string(quote_xml(self.network_policy).encode(ExternalEncoding), input_name='network-policy'), namespace_, eol_)) + def hasContent_(self): + if ( + self.subnet is not None or + self.virtual_network is not None or + self.security_group is not None or + self.network_policy is not None + ): + return True + else: + return False + def exportLiteral(self, outfile, level, name_='AddressType'): + level += 1 + self.exportLiteralAttributes(outfile, level, [], name_) + if self.hasContent_(): + self.exportLiteralChildren(outfile, level, name_) + def exportLiteralAttributes(self, outfile, level, already_processed, name_): + pass + def exportLiteralChildren(self, outfile, level, name_): + if self.subnet is not None: + showIndent(outfile, level) + outfile.write('subnet=model_.SubnetType(\n') + self.subnet.exportLiteral(outfile, level, name_='subnet') + showIndent(outfile, level) + outfile.write('),\n') + if self.virtual_network is not None: + showIndent(outfile, level) + outfile.write('virtual_network=%s,\n' % quote_python(self.virtual_network).encode(ExternalEncoding)) + if self.security_group is not None: + showIndent(outfile, level) + outfile.write('security_group=%s,\n' % quote_python(self.security_group).encode(ExternalEncoding)) + if self.network_policy is not None: + showIndent(outfile, level) + outfile.write('network_policy=%s,\n' % quote_python(self.network_policy).encode(ExternalEncoding)) + def exportDict(self, name_='AddressType'): + obj_json = json.dumps(self, default=lambda o: dict((k, v) for k, v in o.__dict__.iteritems())) + obj_dict = json.loads(obj_json) + return {name_: obj_dict} + def build(self, node): + self.buildAttributes(node, node.attrib, []) + for child in node: + nodeName_ = Tag_pattern_.match(child.tag).groups()[-1] + self.buildChildren(child, node, nodeName_) + def buildAttributes(self, node, attrs, already_processed): + pass + def buildChildren(self, child_, node, nodeName_, fromsubclass_=False): + if nodeName_ == 'subnet': + obj_ = SubnetType.factory() + obj_.build(child_) + self.set_subnet(obj_) + elif nodeName_ == 'virtual-network': + virtual_network_ = child_.text + virtual_network_ = self.gds_validate_string(virtual_network_, node, 'virtual_network') + self.virtual_network = virtual_network_ + elif nodeName_ == 'security-group': + security_group_ = child_.text + security_group_ = self.gds_validate_string(security_group_, node, 'security_group') + self.security_group = security_group_ + elif nodeName_ == 'network-policy': + network_policy_ = child_.text + network_policy_ = self.gds_validate_string(network_policy_, node, 'network_policy') + self.network_policy = network_policy_ +# end class AddressType + + +class PortType(GeneratedsSuper): + """ + PortType class definition from :doc:`vnc_cfg.xsd` + """ + subclass = None + superclass = None + def __init__(self, start_port=None, end_port=None, **kwargs): + self.start_port = start_port + self.end_port = end_port + def factory(*args_, **kwargs_): + if PortType.subclass: + return PortType.subclass(*args_, **kwargs_) + else: + return PortType(*args_, **kwargs_) + factory = staticmethod(factory) + def get_start_port(self): return self.start_port + def set_start_port(self, start_port): self.start_port = start_port + def validate_L4PortType(self, value): + # Validate type L4PortType, a restriction on xsd:integer. + error = False + if isinstance(value, list): + v_int = map(int, value) + v1, v2 = min(v_int), max(v_int) + else: + v1, v2 = int(value), int(value) + error = (-1 > v1) + error |= (v2 > 65535) + if error: + raise ValueError("L4PortType must be in the range -1-65535") + def get_end_port(self): return self.end_port + def set_end_port(self, end_port): self.end_port = end_port + def __eq__(self, other): + if isinstance(other, self.__class__): + return (self.start_port == other.start_port and + self.end_port == other.end_port) + return NotImplemented + def __ne__(self, other): + if isinstance(other, self.__class__): + return not self.__eq__(other) + return NotImplemented + + @classmethod + def populate (cls, *a, **kwa): + obj = cls (*a, **kwa) + obj.set_start_port (obj.populate_integer ("start_port")) + obj.set_end_port (obj.populate_integer ("end_port")) + return obj + def export(self, outfile, level=1, namespace_='', name_='PortType', namespacedef_='', pretty_print=True): + if pretty_print: + eol_ = '\n' + else: + eol_ = '' + showIndent(outfile, level, pretty_print) + outfile.write('<%s%s%s' % (namespace_, name_, namespacedef_ and ' ' + namespacedef_ or '', )) + already_processed = [] + self.exportAttributes(outfile, level, already_processed, namespace_, name_='PortType') + if self.hasContent_(): + outfile.write('>%s' % (eol_, )) + self.exportChildren(outfile, level + 1, namespace_, name_, pretty_print=pretty_print) + showIndent(outfile, level, pretty_print) + outfile.write('</%s%s>%s' % (namespace_, name_, eol_)) + else: + outfile.write('/>%s' % (eol_, )) + def exportAttributes(self, outfile, level, already_processed, namespace_='', name_='PortType'): + pass + def exportChildren(self, outfile, level, namespace_='', name_='PortType', fromsubclass_=False, pretty_print=True): + if pretty_print: + eol_ = '\n' + else: + eol_ = '' + if self.start_port is not None: + showIndent(outfile, level, pretty_print) + outfile.write('<%sstart-port>%s</%sstart-port>%s' % (namespace_, self.gds_format_integer(self.start_port, input_name='start-port'), namespace_, eol_)) + if self.end_port is not None: + showIndent(outfile, level, pretty_print) + outfile.write('<%send-port>%s</%send-port>%s' % (namespace_, self.gds_format_integer(self.end_port, input_name='end-port'), namespace_, eol_)) + def hasContent_(self): + if ( + self.start_port is not None or + self.end_port is not None + ): + return True + else: + return False + def exportLiteral(self, outfile, level, name_='PortType'): + level += 1 + self.exportLiteralAttributes(outfile, level, [], name_) + if self.hasContent_(): + self.exportLiteralChildren(outfile, level, name_) + def exportLiteralAttributes(self, outfile, level, already_processed, name_): + pass + def exportLiteralChildren(self, outfile, level, name_): + if self.start_port is not None: + showIndent(outfile, level) + outfile.write('start_port=%d,\n' % self.start_port) + if self.end_port is not None: + showIndent(outfile, level) + outfile.write('end_port=%d,\n' % self.end_port) + def exportDict(self, name_='PortType'): + obj_json = json.dumps(self, default=lambda o: dict((k, v) for k, v in o.__dict__.iteritems())) + obj_dict = json.loads(obj_json) + return {name_: obj_dict} + def build(self, node): + self.buildAttributes(node, node.attrib, []) + for child in node: + nodeName_ = Tag_pattern_.match(child.tag).groups()[-1] + self.buildChildren(child, node, nodeName_) + def buildAttributes(self, node, attrs, already_processed): + pass + def buildChildren(self, child_, node, nodeName_, fromsubclass_=False): + if nodeName_ == 'start-port': + sval_ = child_.text + try: + ival_ = int(sval_) + except (TypeError, ValueError), exp: + raise_parse_error(child_, 'requires integer: %s' % exp) + ival_ = self.gds_validate_integer(ival_, node, 'start_port') + self.start_port = ival_ + self.validate_L4PortType(self.start_port) # validate type L4PortType + elif nodeName_ == 'end-port': + sval_ = child_.text + try: + ival_ = int(sval_) + except (TypeError, ValueError), exp: + raise_parse_error(child_, 'requires integer: %s' % exp) + ival_ = self.gds_validate_integer(ival_, node, 'end_port') + self.end_port = ival_ + self.validate_L4PortType(self.end_port) # validate type L4PortType +# end class PortType + + +class MatchConditionType(GeneratedsSuper): + """ + MatchConditionType class definition from :doc:`vnc_cfg.xsd` + """ + subclass = None + superclass = None + def __init__(self, protocol=None, src_address=None, src_port=None, dst_address=None, dst_port=None, ethertype=None, **kwargs): + self.protocol = protocol + if isinstance(src_address, dict): + obj = AddressType(**src_address) + self.src_address = obj + else: + self.src_address = src_address + if isinstance(src_port, dict): + obj = PortType(**src_port) + self.src_port = obj + else: + self.src_port = src_port + if isinstance(dst_address, dict): + obj = AddressType(**dst_address) + self.dst_address = obj + else: + self.dst_address = dst_address + if isinstance(dst_port, dict): + obj = PortType(**dst_port) + self.dst_port = obj + else: + self.dst_port = dst_port + self.ethertype = ethertype + def factory(*args_, **kwargs_): + if MatchConditionType.subclass: + return MatchConditionType.subclass(*args_, **kwargs_) + else: + return MatchConditionType(*args_, **kwargs_) + factory = staticmethod(factory) + def get_protocol(self): return self.protocol + def set_protocol(self, protocol): self.protocol = protocol + def get_src_address(self): return self.src_address + def set_src_address(self, src_address): self.src_address = src_address + def get_src_port(self): return self.src_port + def set_src_port(self, src_port): self.src_port = src_port + def get_dst_address(self): return self.dst_address + def set_dst_address(self, dst_address): self.dst_address = dst_address + def get_dst_port(self): return self.dst_port + def set_dst_port(self, dst_port): self.dst_port = dst_port + def get_ethertype(self): return self.ethertype + def set_ethertype(self, ethertype): self.ethertype = ethertype + def validate_EtherType(self, value): + # Validate type EtherType, a restriction on xsd:string. + error = False + if isinstance(value, list): + error = set(value) - set([u'IPv4', u'IPv6']) + else: + error = value not in [u'IPv4', u'IPv6'] + if error: + raise ValueError("EtherType must be one of [u'IPv4', u'IPv6']") + def __eq__(self, other): + if isinstance(other, self.__class__): + return (self.protocol == other.protocol and + self.src_address == other.src_address and + self.src_port == other.src_port and + self.dst_address == other.dst_address and + self.dst_port == other.dst_port and + self.ethertype == other.ethertype) + return NotImplemented + def __ne__(self, other): + if isinstance(other, self.__class__): + return not self.__eq__(other) + return NotImplemented + + @classmethod + def populate (cls, *a, **kwa): + obj = cls (*a, **kwa) + obj.set_protocol (obj.populate_string ("protocol")) + obj.set_src_address (AddressType.populate ()) + obj.set_src_port (PortType.populate ()) + obj.set_dst_address (AddressType.populate ()) + obj.set_dst_port (PortType.populate ()) + obj.set_ethertype (obj.populate_string ("ethertype")) + return obj + def export(self, outfile, level=1, namespace_='', name_='MatchConditionType', namespacedef_='', pretty_print=True): + if pretty_print: + eol_ = '\n' + else: + eol_ = '' + showIndent(outfile, level, pretty_print) + outfile.write('<%s%s%s' % (namespace_, name_, namespacedef_ and ' ' + namespacedef_ or '', )) + already_processed = [] + self.exportAttributes(outfile, level, already_processed, namespace_, name_='MatchConditionType') + if self.hasContent_(): + outfile.write('>%s' % (eol_, )) + self.exportChildren(outfile, level + 1, namespace_, name_, pretty_print=pretty_print) + showIndent(outfile, level, pretty_print) + outfile.write('</%s%s>%s' % (namespace_, name_, eol_)) + else: + outfile.write('/>%s' % (eol_, )) + def exportAttributes(self, outfile, level, already_processed, namespace_='', name_='MatchConditionType'): + pass + def exportChildren(self, outfile, level, namespace_='', name_='MatchConditionType', fromsubclass_=False, pretty_print=True): + if pretty_print: + eol_ = '\n' + else: + eol_ = '' + if self.protocol is not None: + showIndent(outfile, level, pretty_print) + outfile.write('<%sprotocol>%s</%sprotocol>%s' % (namespace_, self.gds_format_string(quote_xml(self.protocol).encode(ExternalEncoding), input_name='protocol'), namespace_, eol_)) + if self.src_address is not None: + self.src_address.export(outfile, level, namespace_, name_='src-address', pretty_print=pretty_print) + if self.src_port is not None: + self.src_port.export(outfile, level, namespace_, name_='src-port', pretty_print=pretty_print) + if self.dst_address is not None: + self.dst_address.export(outfile, level, namespace_, name_='dst-address', pretty_print=pretty_print) + if self.dst_port is not None: + self.dst_port.export(outfile, level, namespace_, name_='dst-port', pretty_print=pretty_print) + if self.ethertype is not None: + showIndent(outfile, level, pretty_print) + outfile.write('<%sethertype>%s</%sethertype>%s' % (namespace_, self.gds_format_string(quote_xml(self.ethertype).encode(ExternalEncoding), input_name='ethertype'), namespace_, eol_)) + def hasContent_(self): + if ( + self.protocol is not None or + self.src_address is not None or + self.src_port is not None or + self.dst_address is not None or + self.dst_port is not None or + self.ethertype is not None + ): + return True + else: + return False + def exportLiteral(self, outfile, level, name_='MatchConditionType'): + level += 1 + self.exportLiteralAttributes(outfile, level, [], name_) + if self.hasContent_(): + self.exportLiteralChildren(outfile, level, name_) + def exportLiteralAttributes(self, outfile, level, already_processed, name_): + pass + def exportLiteralChildren(self, outfile, level, name_): + if self.protocol is not None: + showIndent(outfile, level) + outfile.write('protocol=%s,\n' % quote_python(self.protocol).encode(ExternalEncoding)) + if self.src_address is not None: + showIndent(outfile, level) + outfile.write('src_address=model_.AddressType(\n') + self.src_address.exportLiteral(outfile, level, name_='src_address') + showIndent(outfile, level) + outfile.write('),\n') + if self.src_port is not None: + showIndent(outfile, level) + outfile.write('src_port=model_.PortType(\n') + self.src_port.exportLiteral(outfile, level, name_='src_port') + showIndent(outfile, level) + outfile.write('),\n') + if self.dst_address is not None: + showIndent(outfile, level) + outfile.write('dst_address=model_.AddressType(\n') + self.dst_address.exportLiteral(outfile, level, name_='dst_address') + showIndent(outfile, level) + outfile.write('),\n') + if self.dst_port is not None: + showIndent(outfile, level) + outfile.write('dst_port=model_.PortType(\n') + self.dst_port.exportLiteral(outfile, level, name_='dst_port') + showIndent(outfile, level) + outfile.write('),\n') + if self.ethertype is not None: + showIndent(outfile, level) + outfile.write('ethertype=%s,\n' % quote_python(self.ethertype).encode(ExternalEncoding)) + def exportDict(self, name_='MatchConditionType'): + obj_json = json.dumps(self, default=lambda o: dict((k, v) for k, v in o.__dict__.iteritems())) + obj_dict = json.loads(obj_json) + return {name_: obj_dict} + def build(self, node): + self.buildAttributes(node, node.attrib, []) + for child in node: + nodeName_ = Tag_pattern_.match(child.tag).groups()[-1] + self.buildChildren(child, node, nodeName_) + def buildAttributes(self, node, attrs, already_processed): + pass + def buildChildren(self, child_, node, nodeName_, fromsubclass_=False): + if nodeName_ == 'protocol': + protocol_ = child_.text + protocol_ = self.gds_validate_string(protocol_, node, 'protocol') + self.protocol = protocol_ + elif nodeName_ == 'src-address': + obj_ = AddressType.factory() + obj_.build(child_) + self.set_src_address(obj_) + elif nodeName_ == 'src-port': + obj_ = PortType.factory() + obj_.build(child_) + self.set_src_port(obj_) + elif nodeName_ == 'dst-address': + obj_ = AddressType.factory() + obj_.build(child_) + self.set_dst_address(obj_) + elif nodeName_ == 'dst-port': + obj_ = PortType.factory() + obj_.build(child_) + self.set_dst_port(obj_) + elif nodeName_ == 'ethertype': + ethertype_ = child_.text + ethertype_ = self.gds_validate_string(ethertype_, node, 'ethertype') + self.ethertype = ethertype_ + self.validate_EtherType(self.ethertype) # validate type EtherType +# end class MatchConditionType + + +class MirrorActionType(GeneratedsSuper): + """ + MirrorActionType class definition from :doc:`vnc_cfg.xsd` + """ + subclass = None + superclass = None + def __init__(self, analyzer_name=None, encapsulation=None, analyzer_ip_address=None, routing_instance=None, udp_port=None, **kwargs): + self.analyzer_name = analyzer_name + self.encapsulation = encapsulation + self.analyzer_ip_address = analyzer_ip_address + self.routing_instance = routing_instance + self.udp_port = udp_port + def factory(*args_, **kwargs_): + if MirrorActionType.subclass: + return MirrorActionType.subclass(*args_, **kwargs_) + else: + return MirrorActionType(*args_, **kwargs_) + factory = staticmethod(factory) + def get_analyzer_name(self): return self.analyzer_name + def set_analyzer_name(self, analyzer_name): self.analyzer_name = analyzer_name + def get_encapsulation(self): return self.encapsulation + def set_encapsulation(self, encapsulation): self.encapsulation = encapsulation + def get_analyzer_ip_address(self): return self.analyzer_ip_address + def set_analyzer_ip_address(self, analyzer_ip_address): self.analyzer_ip_address = analyzer_ip_address + def validate_IpAddress(self, value): + # Validate type IpAddress, a restriction on xsd:string. + pass + def get_routing_instance(self): return self.routing_instance + def set_routing_instance(self, routing_instance): self.routing_instance = routing_instance + def get_udp_port(self): return self.udp_port + def set_udp_port(self, udp_port): self.udp_port = udp_port + def __eq__(self, other): + if isinstance(other, self.__class__): + return (self.analyzer_name == other.analyzer_name and + self.encapsulation == other.encapsulation and + self.analyzer_ip_address == other.analyzer_ip_address and + self.routing_instance == other.routing_instance and + self.udp_port == other.udp_port) + return NotImplemented + def __ne__(self, other): + if isinstance(other, self.__class__): + return not self.__eq__(other) + return NotImplemented + + @classmethod + def populate (cls, *a, **kwa): + obj = cls (*a, **kwa) + obj.set_analyzer_name (obj.populate_string ("analyzer_name")) + obj.set_encapsulation (obj.populate_string ("encapsulation")) + obj.set_analyzer_ip_address (obj.populate_string ("analyzer_ip_address")) + obj.set_routing_instance (obj.populate_string ("routing_instance")) + obj.set_udp_port (obj.populate_integer ("udp_port")) + return obj + def export(self, outfile, level=1, namespace_='', name_='MirrorActionType', namespacedef_='', pretty_print=True): + if pretty_print: + eol_ = '\n' + else: + eol_ = '' + showIndent(outfile, level, pretty_print) + outfile.write('<%s%s%s' % (namespace_, name_, namespacedef_ and ' ' + namespacedef_ or '', )) + already_processed = [] + self.exportAttributes(outfile, level, already_processed, namespace_, name_='MirrorActionType') + if self.hasContent_(): + outfile.write('>%s' % (eol_, )) + self.exportChildren(outfile, level + 1, namespace_, name_, pretty_print=pretty_print) + showIndent(outfile, level, pretty_print) + outfile.write('</%s%s>%s' % (namespace_, name_, eol_)) + else: + outfile.write('/>%s' % (eol_, )) + def exportAttributes(self, outfile, level, already_processed, namespace_='', name_='MirrorActionType'): + pass + def exportChildren(self, outfile, level, namespace_='', name_='MirrorActionType', fromsubclass_=False, pretty_print=True): + if pretty_print: + eol_ = '\n' + else: + eol_ = '' + if self.analyzer_name is not None: + showIndent(outfile, level, pretty_print) + outfile.write('<%sanalyzer-name>%s</%sanalyzer-name>%s' % (namespace_, self.gds_format_string(quote_xml(self.analyzer_name).encode(ExternalEncoding), input_name='analyzer-name'), namespace_, eol_)) + if self.encapsulation is not None: + showIndent(outfile, level, pretty_print) + outfile.write('<%sencapsulation>%s</%sencapsulation>%s' % (namespace_, self.gds_format_string(quote_xml(self.encapsulation).encode(ExternalEncoding), input_name='encapsulation'), namespace_, eol_)) + if self.analyzer_ip_address is not None: + showIndent(outfile, level, pretty_print) + outfile.write('<%sanalyzer-ip-address>%s</%sanalyzer-ip-address>%s' % (namespace_, self.gds_format_string(quote_xml(self.analyzer_ip_address).encode(ExternalEncoding), input_name='analyzer-ip-address'), namespace_, eol_)) + if self.routing_instance is not None: + showIndent(outfile, level, pretty_print) + outfile.write('<%srouting-instance>%s</%srouting-instance>%s' % (namespace_, self.gds_format_string(quote_xml(self.routing_instance).encode(ExternalEncoding), input_name='routing-instance'), namespace_, eol_)) + if self.udp_port is not None: + showIndent(outfile, level, pretty_print) + outfile.write('<%sudp-port>%s</%sudp-port>%s' % (namespace_, self.gds_format_integer(self.udp_port, input_name='udp-port'), namespace_, eol_)) + def hasContent_(self): + if ( + self.analyzer_name is not None or + self.encapsulation is not None or + self.analyzer_ip_address is not None or + self.routing_instance is not None or + self.udp_port is not None + ): + return True + else: + return False + def exportLiteral(self, outfile, level, name_='MirrorActionType'): + level += 1 + self.exportLiteralAttributes(outfile, level, [], name_) + if self.hasContent_(): + self.exportLiteralChildren(outfile, level, name_) + def exportLiteralAttributes(self, outfile, level, already_processed, name_): + pass + def exportLiteralChildren(self, outfile, level, name_): + if self.analyzer_name is not None: + showIndent(outfile, level) + outfile.write('analyzer_name=%s,\n' % quote_python(self.analyzer_name).encode(ExternalEncoding)) + if self.encapsulation is not None: + showIndent(outfile, level) + outfile.write('encapsulation=%s,\n' % quote_python(self.encapsulation).encode(ExternalEncoding)) + if self.analyzer_ip_address is not None: + showIndent(outfile, level) + outfile.write('analyzer_ip_address=%s,\n' % quote_python(self.analyzer_ip_address).encode(ExternalEncoding)) + if self.routing_instance is not None: + showIndent(outfile, level) + outfile.write('routing_instance=%s,\n' % quote_python(self.routing_instance).encode(ExternalEncoding)) + if self.udp_port is not None: + showIndent(outfile, level) + outfile.write('udp_port=%d,\n' % self.udp_port) + def exportDict(self, name_='MirrorActionType'): + obj_json = json.dumps(self, default=lambda o: dict((k, v) for k, v in o.__dict__.iteritems())) + obj_dict = json.loads(obj_json) + return {name_: obj_dict} + def build(self, node): + self.buildAttributes(node, node.attrib, []) + for child in node: + nodeName_ = Tag_pattern_.match(child.tag).groups()[-1] + self.buildChildren(child, node, nodeName_) + def buildAttributes(self, node, attrs, already_processed): + pass + def buildChildren(self, child_, node, nodeName_, fromsubclass_=False): + if nodeName_ == 'analyzer-name': + analyzer_name_ = child_.text + analyzer_name_ = self.gds_validate_string(analyzer_name_, node, 'analyzer_name') + self.analyzer_name = analyzer_name_ + elif nodeName_ == 'encapsulation': + encapsulation_ = child_.text + encapsulation_ = self.gds_validate_string(encapsulation_, node, 'encapsulation') + self.encapsulation = encapsulation_ + elif nodeName_ == 'analyzer-ip-address': + analyzer_ip_address_ = child_.text + analyzer_ip_address_ = self.gds_validate_string(analyzer_ip_address_, node, 'analyzer_ip_address') + self.analyzer_ip_address = analyzer_ip_address_ + self.validate_IpAddress(self.analyzer_ip_address) # validate type IpAddress + elif nodeName_ == 'routing-instance': + routing_instance_ = child_.text + routing_instance_ = self.gds_validate_string(routing_instance_, node, 'routing_instance') + self.routing_instance = routing_instance_ + elif nodeName_ == 'udp-port': + sval_ = child_.text + try: + ival_ = int(sval_) + except (TypeError, ValueError), exp: + raise_parse_error(child_, 'requires integer: %s' % exp) + ival_ = self.gds_validate_integer(ival_, node, 'udp_port') + self.udp_port = ival_ +# end class MirrorActionType + + +class ActionListType(GeneratedsSuper): + """ + ActionListType class definition from :doc:`vnc_cfg.xsd` + """ + subclass = None + superclass = None + def __init__(self, simple_action=None, gateway_name=None, apply_service=None, mirror_to=None, assign_routing_instance=None, **kwargs): + self.simple_action = simple_action + self.gateway_name = gateway_name + if (apply_service is None) or (apply_service == []): + self.apply_service = [] + else: + self.apply_service = apply_service + if isinstance(mirror_to, dict): + obj = MirrorActionType(**mirror_to) + self.mirror_to = obj + else: + self.mirror_to = mirror_to + self.assign_routing_instance = assign_routing_instance + def factory(*args_, **kwargs_): + if ActionListType.subclass: + return ActionListType.subclass(*args_, **kwargs_) + else: + return ActionListType(*args_, **kwargs_) + factory = staticmethod(factory) + def get_simple_action(self): return self.simple_action + def set_simple_action(self, simple_action): self.simple_action = simple_action + def validate_SimpleActionType(self, value): + # Validate type SimpleActionType, a restriction on xsd:string. + error = False + if isinstance(value, list): + error = set(value) - set([u'alert', u'drop', u'deny', u'log', u'pass', u'reject']) + else: + error = value not in [u'alert', u'drop', u'deny', u'log', u'pass', u'reject'] + if error: + raise ValueError("SimpleActionType must be one of [u'alert', u'drop', u'deny', u'log', u'pass', u'reject']") + def get_gateway_name(self): return self.gateway_name + def set_gateway_name(self, gateway_name): self.gateway_name = gateway_name + def get_apply_service(self): return self.apply_service + def set_apply_service(self, apply_service): self.apply_service = apply_service + def add_apply_service(self, value): self.apply_service.append(value) + def insert_apply_service(self, index, value): self.apply_service[index] = value + def delete_apply_service(self, value): self.apply_service.remove(value) + def get_mirror_to(self): return self.mirror_to + def set_mirror_to(self, mirror_to): self.mirror_to = mirror_to + def get_assign_routing_instance(self): return self.assign_routing_instance + def set_assign_routing_instance(self, assign_routing_instance): self.assign_routing_instance = assign_routing_instance + def __eq__(self, other): + if isinstance(other, self.__class__): + return (self.simple_action == other.simple_action and + self.gateway_name == other.gateway_name and + self.apply_service == other.apply_service and + self.mirror_to == other.mirror_to and + self.assign_routing_instance == other.assign_routing_instance) + return NotImplemented + def __ne__(self, other): + if isinstance(other, self.__class__): + return not self.__eq__(other) + return NotImplemented + + @classmethod + def populate (cls, *a, **kwa): + obj = cls (*a, **kwa) + obj.set_simple_action (obj.populate_string ("simple_action")) + obj.set_gateway_name (obj.populate_string ("gateway_name")) + obj.set_apply_service ([obj.populate_string ("apply_service")]) + obj.set_mirror_to (MirrorActionType.populate ()) + obj.set_assign_routing_instance (obj.populate_string ("assign_routing_instance")) + return obj + def export(self, outfile, level=1, namespace_='', name_='ActionListType', namespacedef_='', pretty_print=True): + if pretty_print: + eol_ = '\n' + else: + eol_ = '' + showIndent(outfile, level, pretty_print) + outfile.write('<%s%s%s' % (namespace_, name_, namespacedef_ and ' ' + namespacedef_ or '', )) + already_processed = [] + self.exportAttributes(outfile, level, already_processed, namespace_, name_='ActionListType') + if self.hasContent_(): + outfile.write('>%s' % (eol_, )) + self.exportChildren(outfile, level + 1, namespace_, name_, pretty_print=pretty_print) + showIndent(outfile, level, pretty_print) + outfile.write('</%s%s>%s' % (namespace_, name_, eol_)) + else: + outfile.write('/>%s' % (eol_, )) + def exportAttributes(self, outfile, level, already_processed, namespace_='', name_='ActionListType'): + pass + def exportChildren(self, outfile, level, namespace_='', name_='ActionListType', fromsubclass_=False, pretty_print=True): + if pretty_print: + eol_ = '\n' + else: + eol_ = '' + if self.simple_action is not None: + showIndent(outfile, level, pretty_print) + outfile.write('<%ssimple-action>%s</%ssimple-action>%s' % (namespace_, self.gds_format_string(quote_xml(self.simple_action).encode(ExternalEncoding), input_name='simple-action'), namespace_, eol_)) + if self.gateway_name is not None: + showIndent(outfile, level, pretty_print) + outfile.write('<%sgateway-name>%s</%sgateway-name>%s' % (namespace_, self.gds_format_string(quote_xml(self.gateway_name).encode(ExternalEncoding), input_name='gateway-name'), namespace_, eol_)) + for apply_service_ in self.apply_service: + showIndent(outfile, level, pretty_print) + outfile.write('<%sapply-service>%s</%sapply-service>%s' % (namespace_, self.gds_format_string(quote_xml(apply_service_).encode(ExternalEncoding), input_name='apply-service'), namespace_, eol_)) + if self.mirror_to is not None: + self.mirror_to.export(outfile, level, namespace_, name_='mirror-to', pretty_print=pretty_print) + if self.assign_routing_instance is not None: + showIndent(outfile, level, pretty_print) + outfile.write('<%sassign-routing-instance>%s</%sassign-routing-instance>%s' % (namespace_, self.gds_format_string(quote_xml(self.assign_routing_instance).encode(ExternalEncoding), input_name='assign-routing-instance'), namespace_, eol_)) + def hasContent_(self): + if ( + self.simple_action is not None or + self.gateway_name is not None or + self.apply_service or + self.mirror_to is not None or + self.assign_routing_instance is not None + ): + return True + else: + return False + def exportLiteral(self, outfile, level, name_='ActionListType'): + level += 1 + self.exportLiteralAttributes(outfile, level, [], name_) + if self.hasContent_(): + self.exportLiteralChildren(outfile, level, name_) + def exportLiteralAttributes(self, outfile, level, already_processed, name_): + pass + def exportLiteralChildren(self, outfile, level, name_): + if self.simple_action is not None: + showIndent(outfile, level) + outfile.write('simple_action=%s,\n' % quote_python(self.simple_action).encode(ExternalEncoding)) + if self.gateway_name is not None: + showIndent(outfile, level) + outfile.write('gateway_name=%s,\n' % quote_python(self.gateway_name).encode(ExternalEncoding)) + showIndent(outfile, level) + outfile.write('apply_service=[\n') + level += 1 + for apply_service_ in self.apply_service: + showIndent(outfile, level) + outfile.write('%s,\n' % quote_python(apply_service_).encode(ExternalEncoding)) + level -= 1 + showIndent(outfile, level) + outfile.write('],\n') + if self.mirror_to is not None: + showIndent(outfile, level) + outfile.write('mirror_to=model_.MirrorActionType(\n') + self.mirror_to.exportLiteral(outfile, level, name_='mirror_to') + showIndent(outfile, level) + outfile.write('),\n') + if self.assign_routing_instance is not None: + showIndent(outfile, level) + outfile.write('assign_routing_instance=%s,\n' % quote_python(self.assign_routing_instance).encode(ExternalEncoding)) + def exportDict(self, name_='ActionListType'): + obj_json = json.dumps(self, default=lambda o: dict((k, v) for k, v in o.__dict__.iteritems())) + obj_dict = json.loads(obj_json) + return {name_: obj_dict} + def build(self, node): + self.buildAttributes(node, node.attrib, []) + for child in node: + nodeName_ = Tag_pattern_.match(child.tag).groups()[-1] + self.buildChildren(child, node, nodeName_) + def buildAttributes(self, node, attrs, already_processed): + pass + def buildChildren(self, child_, node, nodeName_, fromsubclass_=False): + if nodeName_ == 'simple-action': + simple_action_ = child_.text + simple_action_ = self.gds_validate_string(simple_action_, node, 'simple_action') + self.simple_action = simple_action_ + self.validate_SimpleActionType(self.simple_action) # validate type SimpleActionType + elif nodeName_ == 'gateway-name': + gateway_name_ = child_.text + gateway_name_ = self.gds_validate_string(gateway_name_, node, 'gateway_name') + self.gateway_name = gateway_name_ + elif nodeName_ == 'apply-service': + apply_service_ = child_.text + apply_service_ = self.gds_validate_string(apply_service_, node, 'apply_service') + self.apply_service.append(apply_service_) + elif nodeName_ == 'mirror-to': + obj_ = MirrorActionType.factory() + obj_.build(child_) + self.set_mirror_to(obj_) + elif nodeName_ == 'assign-routing-instance': + assign_routing_instance_ = child_.text + assign_routing_instance_ = self.gds_validate_string(assign_routing_instance_, node, 'assign_routing_instance') + self.assign_routing_instance = assign_routing_instance_ +# end class ActionListType + + +class AclRuleType(GeneratedsSuper): + """ + AclRuleType class definition from :doc:`vnc_cfg.xsd` + """ + subclass = None + superclass = None + def __init__(self, match_condition=None, action_list=None, rule_uuid=None, **kwargs): + if isinstance(match_condition, dict): + obj = MatchConditionType(**match_condition) + self.match_condition = obj + else: + self.match_condition = match_condition + if isinstance(action_list, dict): + obj = ActionListType(**action_list) + self.action_list = obj + else: + self.action_list = action_list + self.rule_uuid = rule_uuid + def factory(*args_, **kwargs_): + if AclRuleType.subclass: + return AclRuleType.subclass(*args_, **kwargs_) + else: + return AclRuleType(*args_, **kwargs_) + factory = staticmethod(factory) + def get_match_condition(self): return self.match_condition + def set_match_condition(self, match_condition): self.match_condition = match_condition + def get_action_list(self): return self.action_list + def set_action_list(self, action_list): self.action_list = action_list + def get_rule_uuid(self): return self.rule_uuid + def set_rule_uuid(self, rule_uuid): self.rule_uuid = rule_uuid + def __eq__(self, other): + if isinstance(other, self.__class__): + return (self.match_condition == other.match_condition and + self.action_list == other.action_list and + self.rule_uuid == other.rule_uuid) + return NotImplemented + def __ne__(self, other): + if isinstance(other, self.__class__): + return not self.__eq__(other) + return NotImplemented + + @classmethod + def populate (cls, *a, **kwa): + obj = cls (*a, **kwa) + obj.set_match_condition (MatchConditionType.populate ()) + obj.set_action_list (ActionListType.populate ()) + obj.set_rule_uuid (obj.populate_string ("rule_uuid")) + return obj + def export(self, outfile, level=1, namespace_='', name_='AclRuleType', namespacedef_='', pretty_print=True): + if pretty_print: + eol_ = '\n' + else: + eol_ = '' + showIndent(outfile, level, pretty_print) + outfile.write('<%s%s%s' % (namespace_, name_, namespacedef_ and ' ' + namespacedef_ or '', )) + already_processed = [] + self.exportAttributes(outfile, level, already_processed, namespace_, name_='AclRuleType') + if self.hasContent_(): + outfile.write('>%s' % (eol_, )) + self.exportChildren(outfile, level + 1, namespace_, name_, pretty_print=pretty_print) + showIndent(outfile, level, pretty_print) + outfile.write('</%s%s>%s' % (namespace_, name_, eol_)) + else: + outfile.write('/>%s' % (eol_, )) + def exportAttributes(self, outfile, level, already_processed, namespace_='', name_='AclRuleType'): + pass + def exportChildren(self, outfile, level, namespace_='', name_='AclRuleType', fromsubclass_=False, pretty_print=True): + if pretty_print: + eol_ = '\n' + else: + eol_ = '' + if self.match_condition is not None: + self.match_condition.export(outfile, level, namespace_, name_='match-condition', pretty_print=pretty_print) + if self.action_list is not None: + self.action_list.export(outfile, level, namespace_, name_='action-list', pretty_print=pretty_print) + if self.rule_uuid is not None: + showIndent(outfile, level, pretty_print) + outfile.write('<%srule-uuid>%s</%srule-uuid>%s' % (namespace_, self.gds_format_string(quote_xml(self.rule_uuid).encode(ExternalEncoding), input_name='rule-uuid'), namespace_, eol_)) + def hasContent_(self): + if ( + self.match_condition is not None or + self.action_list is not None or + self.rule_uuid is not None + ): + return True + else: + return False + def exportLiteral(self, outfile, level, name_='AclRuleType'): + level += 1 + self.exportLiteralAttributes(outfile, level, [], name_) + if self.hasContent_(): + self.exportLiteralChildren(outfile, level, name_) + def exportLiteralAttributes(self, outfile, level, already_processed, name_): + pass + def exportLiteralChildren(self, outfile, level, name_): + if self.match_condition is not None: + showIndent(outfile, level) + outfile.write('match_condition=model_.MatchConditionType(\n') + self.match_condition.exportLiteral(outfile, level, name_='match_condition') + showIndent(outfile, level) + outfile.write('),\n') + if self.action_list is not None: + showIndent(outfile, level) + outfile.write('action_list=model_.ActionListType(\n') + self.action_list.exportLiteral(outfile, level, name_='action_list') + showIndent(outfile, level) + outfile.write('),\n') + if self.rule_uuid is not None: + showIndent(outfile, level) + outfile.write('rule_uuid=%s,\n' % quote_python(self.rule_uuid).encode(ExternalEncoding)) + def exportDict(self, name_='AclRuleType'): + obj_json = json.dumps(self, default=lambda o: dict((k, v) for k, v in o.__dict__.iteritems())) + obj_dict = json.loads(obj_json) + return {name_: obj_dict} + def build(self, node): + self.buildAttributes(node, node.attrib, []) + for child in node: + nodeName_ = Tag_pattern_.match(child.tag).groups()[-1] + self.buildChildren(child, node, nodeName_) + def buildAttributes(self, node, attrs, already_processed): + pass + def buildChildren(self, child_, node, nodeName_, fromsubclass_=False): + if nodeName_ == 'match-condition': + obj_ = MatchConditionType.factory() + obj_.build(child_) + self.set_match_condition(obj_) + elif nodeName_ == 'action-list': + obj_ = ActionListType.factory() + obj_.build(child_) + self.set_action_list(obj_) + elif nodeName_ == 'rule-uuid': + rule_uuid_ = child_.text + rule_uuid_ = self.gds_validate_string(rule_uuid_, node, 'rule_uuid') + self.rule_uuid = rule_uuid_ +# end class AclRuleType + + +class AclEntriesType(GeneratedsSuper): + """ + AclEntriesType class definition from :doc:`vnc_cfg.xsd` + """ + subclass = None + superclass = None + def __init__(self, dynamic=None, acl_rule=None, **kwargs): + self.dynamic = dynamic + if (acl_rule is None) or (acl_rule == []): + self.acl_rule = [] + else: + if isinstance(acl_rule[0], dict): + objs = [AclRuleType(**elem) for elem in acl_rule] + self.acl_rule = objs + else: + self.acl_rule = acl_rule + def factory(*args_, **kwargs_): + if AclEntriesType.subclass: + return AclEntriesType.subclass(*args_, **kwargs_) + else: + return AclEntriesType(*args_, **kwargs_) + factory = staticmethod(factory) + def get_dynamic(self): return self.dynamic + def set_dynamic(self, dynamic): self.dynamic = dynamic + def get_acl_rule(self): return self.acl_rule + def set_acl_rule(self, acl_rule): self.acl_rule = acl_rule + def add_acl_rule(self, value): self.acl_rule.append(value) + def insert_acl_rule(self, index, value): self.acl_rule[index] = value + def delete_acl_rule(self, value): self.acl_rule.remove(value) + def __eq__(self, other): + if isinstance(other, self.__class__): + return (self.dynamic == other.dynamic and + self.acl_rule == other.acl_rule) + return NotImplemented + def __ne__(self, other): + if isinstance(other, self.__class__): + return not self.__eq__(other) + return NotImplemented + + @classmethod + def populate (cls, *a, **kwa): + obj = cls (*a, **kwa) + obj.set_dynamic (obj.populate_boolean ("dynamic")) + obj.set_acl_rule ([AclRuleType.populate ()]) + return obj + def export(self, outfile, level=1, namespace_='', name_='AclEntriesType', namespacedef_='', pretty_print=True): + if pretty_print: + eol_ = '\n' + else: + eol_ = '' + showIndent(outfile, level, pretty_print) + outfile.write('<%s%s%s' % (namespace_, name_, namespacedef_ and ' ' + namespacedef_ or '', )) + already_processed = [] + self.exportAttributes(outfile, level, already_processed, namespace_, name_='AclEntriesType') + if self.hasContent_(): + outfile.write('>%s' % (eol_, )) + self.exportChildren(outfile, level + 1, namespace_, name_, pretty_print=pretty_print) + showIndent(outfile, level, pretty_print) + outfile.write('</%s%s>%s' % (namespace_, name_, eol_)) + else: + outfile.write('/>%s' % (eol_, )) + def exportAttributes(self, outfile, level, already_processed, namespace_='', name_='AclEntriesType'): + pass + def exportChildren(self, outfile, level, namespace_='', name_='AclEntriesType', fromsubclass_=False, pretty_print=True): + if pretty_print: + eol_ = '\n' + else: + eol_ = '' + if self.dynamic is not None: + showIndent(outfile, level, pretty_print) + outfile.write('<%sdynamic>%s</%sdynamic>%s' % (namespace_, self.gds_format_boolean(self.gds_str_lower(str(self.dynamic)), input_name='dynamic'), namespace_, eol_)) + for acl_rule_ in self.acl_rule: + if isinstance(acl_rule_, dict): + acl_rule_ = AclRuleType(**acl_rule_) + acl_rule_.export(outfile, level, namespace_, name_='acl-rule', pretty_print=pretty_print) + def hasContent_(self): + if ( + self.dynamic is not None or + self.acl_rule + ): + return True + else: + return False + def exportLiteral(self, outfile, level, name_='AclEntriesType'): + level += 1 + self.exportLiteralAttributes(outfile, level, [], name_) + if self.hasContent_(): + self.exportLiteralChildren(outfile, level, name_) + def exportLiteralAttributes(self, outfile, level, already_processed, name_): + pass + def exportLiteralChildren(self, outfile, level, name_): + if self.dynamic is not None: + showIndent(outfile, level) + outfile.write('dynamic=%s,\n' % self.dynamic) + showIndent(outfile, level) + outfile.write('acl_rule=[\n') + level += 1 + for acl_rule_ in self.acl_rule: + showIndent(outfile, level) + outfile.write('model_.AclRuleType(\n') + acl_rule_.exportLiteral(outfile, level, name_='AclRuleType') + showIndent(outfile, level) + outfile.write('),\n') + level -= 1 + showIndent(outfile, level) + outfile.write('],\n') + def exportDict(self, name_='AclEntriesType'): + obj_json = json.dumps(self, default=lambda o: dict((k, v) for k, v in o.__dict__.iteritems())) + obj_dict = json.loads(obj_json) + return {name_: obj_dict} + def build(self, node): + self.buildAttributes(node, node.attrib, []) + for child in node: + nodeName_ = Tag_pattern_.match(child.tag).groups()[-1] + self.buildChildren(child, node, nodeName_) + def buildAttributes(self, node, attrs, already_processed): + pass + def buildChildren(self, child_, node, nodeName_, fromsubclass_=False): + if nodeName_ == 'dynamic': + sval_ = child_.text + if sval_ in ('true', '1'): + ival_ = True + elif sval_ in ('false', '0'): + ival_ = False + else: + raise_parse_error(child_, 'requires boolean') + ival_ = self.gds_validate_boolean(ival_, node, 'dynamic') + self.dynamic = ival_ + elif nodeName_ == 'acl-rule': + obj_ = AclRuleType.factory() + obj_.build(child_) + self.acl_rule.append(obj_) +# end class AclEntriesType + + +class PolicyRuleType(GeneratedsSuper): + """ + PolicyRuleType class definition from :doc:`vnc_cfg.xsd` + """ + subclass = None + superclass = None + def __init__(self, rule_sequence=None, rule_uuid=None, direction=None, protocol=None, src_addresses=None, src_ports=None, application=None, dst_addresses=None, dst_ports=None, action_list=None, ethertype=None, **kwargs): + if isinstance(rule_sequence, dict): + obj = SequenceType(**rule_sequence) + self.rule_sequence = obj + else: + self.rule_sequence = rule_sequence + self.rule_uuid = rule_uuid + self.direction = direction + self.protocol = protocol + if (src_addresses is None) or (src_addresses == []): + self.src_addresses = [] + else: + if isinstance(src_addresses[0], dict): + objs = [AddressType(**elem) for elem in src_addresses] + self.src_addresses = objs + else: + self.src_addresses = src_addresses + if (src_ports is None) or (src_ports == []): + self.src_ports = [] + else: + if isinstance(src_ports[0], dict): + objs = [PortType(**elem) for elem in src_ports] + self.src_ports = objs + else: + self.src_ports = src_ports + if (application is None) or (application == []): + self.application = [] + else: + self.application = application + if (dst_addresses is None) or (dst_addresses == []): + self.dst_addresses = [] + else: + if isinstance(dst_addresses[0], dict): + objs = [AddressType(**elem) for elem in dst_addresses] + self.dst_addresses = objs + else: + self.dst_addresses = dst_addresses + if (dst_ports is None) or (dst_ports == []): + self.dst_ports = [] + else: + if isinstance(dst_ports[0], dict): + objs = [PortType(**elem) for elem in dst_ports] + self.dst_ports = objs + else: + self.dst_ports = dst_ports + if isinstance(action_list, dict): + obj = ActionListType(**action_list) + self.action_list = obj + else: + self.action_list = action_list + self.ethertype = ethertype + def factory(*args_, **kwargs_): + if PolicyRuleType.subclass: + return PolicyRuleType.subclass(*args_, **kwargs_) + else: + return PolicyRuleType(*args_, **kwargs_) + factory = staticmethod(factory) + def get_rule_sequence(self): return self.rule_sequence + def set_rule_sequence(self, rule_sequence): self.rule_sequence = rule_sequence + def get_rule_uuid(self): return self.rule_uuid + def set_rule_uuid(self, rule_uuid): self.rule_uuid = rule_uuid + def get_direction(self): return self.direction + def set_direction(self, direction): self.direction = direction + def validate_DirectionType(self, value): + # Validate type DirectionType, a restriction on xsd:string. + error = False + if isinstance(value, list): + error = set(value) - set([u'>', u'<>']) + else: + error = value not in [u'>', u'<>'] + if error: + raise ValueError("DirectionType must be one of [u'>', u'<>']") + def get_protocol(self): return self.protocol + def set_protocol(self, protocol): self.protocol = protocol + def validate_ProtocolType(self, value): + # Validate type ProtocolType, a restriction on xsd:string. + error = False + if isinstance(value, list): + error = set(value) - set([u'tcp', u'udp', u'icmp', u'any', u'1', u'6', u'17']) + else: + error = value not in [u'tcp', u'udp', u'icmp', u'any', u'1', u'6', u'17'] + if error: + raise ValueError("ProtocolType must be one of [u'tcp', u'udp', u'icmp', u'any', u'1', u'6', u'17']") + def get_src_addresses(self): return self.src_addresses + def set_src_addresses(self, src_addresses): self.src_addresses = src_addresses + def add_src_addresses(self, value): self.src_addresses.append(value) + def insert_src_addresses(self, index, value): self.src_addresses[index] = value + def delete_src_addresses(self, value): self.src_addresses.remove(value) + def get_src_ports(self): return self.src_ports + def set_src_ports(self, src_ports): self.src_ports = src_ports + def add_src_ports(self, value): self.src_ports.append(value) + def insert_src_ports(self, index, value): self.src_ports[index] = value + def delete_src_ports(self, value): self.src_ports.remove(value) + def get_application(self): return self.application + def set_application(self, application): self.application = application + def add_application(self, value): self.application.append(value) + def insert_application(self, index, value): self.application[index] = value + def delete_application(self, value): self.application.remove(value) + def get_dst_addresses(self): return self.dst_addresses + def set_dst_addresses(self, dst_addresses): self.dst_addresses = dst_addresses + def add_dst_addresses(self, value): self.dst_addresses.append(value) + def insert_dst_addresses(self, index, value): self.dst_addresses[index] = value + def delete_dst_addresses(self, value): self.dst_addresses.remove(value) + def get_dst_ports(self): return self.dst_ports + def set_dst_ports(self, dst_ports): self.dst_ports = dst_ports + def add_dst_ports(self, value): self.dst_ports.append(value) + def insert_dst_ports(self, index, value): self.dst_ports[index] = value + def delete_dst_ports(self, value): self.dst_ports.remove(value) + def get_action_list(self): return self.action_list + def set_action_list(self, action_list): self.action_list = action_list + def get_ethertype(self): return self.ethertype + def set_ethertype(self, ethertype): self.ethertype = ethertype + def validate_EtherType(self, value): + # Validate type EtherType, a restriction on xsd:string. + error = False + if isinstance(value, list): + error = set(value) - set([u'IPv4', u'IPv6']) + else: + error = value not in [u'IPv4', u'IPv6'] + if error: + raise ValueError("EtherType must be one of [u'IPv4', u'IPv6']") + def __eq__(self, other): + if isinstance(other, self.__class__): + return (self.rule_sequence == other.rule_sequence and + self.rule_uuid == other.rule_uuid and + self.direction == other.direction and + self.protocol == other.protocol and + self.src_addresses == other.src_addresses and + self.src_ports == other.src_ports and + self.application == other.application and + self.dst_addresses == other.dst_addresses and + self.dst_ports == other.dst_ports and + self.action_list == other.action_list and + self.ethertype == other.ethertype) + return NotImplemented + def __ne__(self, other): + if isinstance(other, self.__class__): + return not self.__eq__(other) + return NotImplemented + + @classmethod + def populate (cls, *a, **kwa): + obj = cls (*a, **kwa) + obj.set_rule_sequence (SequenceType.populate ()) + obj.set_rule_uuid (obj.populate_string ("rule_uuid")) + obj.set_direction (obj.populate_string ("direction")) + obj.set_protocol (obj.populate_string ("protocol")) + obj.set_src_addresses ([AddressType.populate ()]) + obj.set_src_ports ([PortType.populate ()]) + obj.set_application ([obj.populate_string ("application")]) + obj.set_dst_addresses ([AddressType.populate ()]) + obj.set_dst_ports ([PortType.populate ()]) + obj.set_action_list (ActionListType.populate ()) + obj.set_ethertype (obj.populate_string ("ethertype")) + return obj + def export(self, outfile, level=1, namespace_='', name_='PolicyRuleType', namespacedef_='', pretty_print=True): + if pretty_print: + eol_ = '\n' + else: + eol_ = '' + showIndent(outfile, level, pretty_print) + outfile.write('<%s%s%s' % (namespace_, name_, namespacedef_ and ' ' + namespacedef_ or '', )) + already_processed = [] + self.exportAttributes(outfile, level, already_processed, namespace_, name_='PolicyRuleType') + if self.hasContent_(): + outfile.write('>%s' % (eol_, )) + self.exportChildren(outfile, level + 1, namespace_, name_, pretty_print=pretty_print) + showIndent(outfile, level, pretty_print) + outfile.write('</%s%s>%s' % (namespace_, name_, eol_)) + else: + outfile.write('/>%s' % (eol_, )) + def exportAttributes(self, outfile, level, already_processed, namespace_='', name_='PolicyRuleType'): + pass + def exportChildren(self, outfile, level, namespace_='', name_='PolicyRuleType', fromsubclass_=False, pretty_print=True): + if pretty_print: + eol_ = '\n' + else: + eol_ = '' + if self.rule_sequence is not None: + self.rule_sequence.export(outfile, level, namespace_, name_='rule-sequence', pretty_print=pretty_print) + if self.rule_uuid is not None: + showIndent(outfile, level, pretty_print) + outfile.write('<%srule-uuid>%s</%srule-uuid>%s' % (namespace_, self.gds_format_string(quote_xml(self.rule_uuid).encode(ExternalEncoding), input_name='rule-uuid'), namespace_, eol_)) + if self.direction is not None: + showIndent(outfile, level, pretty_print) + outfile.write('<%sdirection>%s</%sdirection>%s' % (namespace_, self.gds_format_string(quote_xml(self.direction).encode(ExternalEncoding), input_name='direction'), namespace_, eol_)) + if self.protocol is not None: + showIndent(outfile, level, pretty_print) + outfile.write('<%sprotocol>%s</%sprotocol>%s' % (namespace_, self.gds_format_string(quote_xml(self.protocol).encode(ExternalEncoding), input_name='protocol'), namespace_, eol_)) + for src_addresses_ in self.src_addresses: + if isinstance(src_addresses_, dict): + src_addresses_ = AddressType(**src_addresses_) + src_addresses_.export(outfile, level, namespace_, name_='src-addresses', pretty_print=pretty_print) + for src_ports_ in self.src_ports: + if isinstance(src_ports_, dict): + src_ports_ = PortType(**src_ports_) + src_ports_.export(outfile, level, namespace_, name_='src-ports', pretty_print=pretty_print) + for application_ in self.application: + showIndent(outfile, level, pretty_print) + outfile.write('<%sapplication>%s</%sapplication>%s' % (namespace_, self.gds_format_string(quote_xml(application_).encode(ExternalEncoding), input_name='application'), namespace_, eol_)) + for dst_addresses_ in self.dst_addresses: + if isinstance(dst_addresses_, dict): + dst_addresses_ = AddressType(**dst_addresses_) + dst_addresses_.export(outfile, level, namespace_, name_='dst-addresses', pretty_print=pretty_print) + for dst_ports_ in self.dst_ports: + if isinstance(dst_ports_, dict): + dst_ports_ = PortType(**dst_ports_) + dst_ports_.export(outfile, level, namespace_, name_='dst-ports', pretty_print=pretty_print) + if self.action_list is not None: + self.action_list.export(outfile, level, namespace_, name_='action-list', pretty_print=pretty_print) + if self.ethertype is not None: + showIndent(outfile, level, pretty_print) + outfile.write('<%sethertype>%s</%sethertype>%s' % (namespace_, self.gds_format_string(quote_xml(self.ethertype).encode(ExternalEncoding), input_name='ethertype'), namespace_, eol_)) + def hasContent_(self): + if ( + self.rule_sequence is not None or + self.rule_uuid is not None or + self.direction is not None or + self.protocol is not None or + self.src_addresses or + self.src_ports or + self.application or + self.dst_addresses or + self.dst_ports or + self.action_list is not None or + self.ethertype is not None + ): + return True + else: + return False + def exportLiteral(self, outfile, level, name_='PolicyRuleType'): + level += 1 + self.exportLiteralAttributes(outfile, level, [], name_) + if self.hasContent_(): + self.exportLiteralChildren(outfile, level, name_) + def exportLiteralAttributes(self, outfile, level, already_processed, name_): + pass + def exportLiteralChildren(self, outfile, level, name_): + if self.rule_sequence is not None: + showIndent(outfile, level) + outfile.write('rule_sequence=model_.SequenceType(\n') + self.rule_sequence.exportLiteral(outfile, level, name_='rule_sequence') + showIndent(outfile, level) + outfile.write('),\n') + if self.rule_uuid is not None: + showIndent(outfile, level) + outfile.write('rule_uuid=%s,\n' % quote_python(self.rule_uuid).encode(ExternalEncoding)) + if self.direction is not None: + showIndent(outfile, level) + outfile.write('direction=%s,\n' % quote_python(self.direction).encode(ExternalEncoding)) + if self.protocol is not None: + showIndent(outfile, level) + outfile.write('protocol=%s,\n' % quote_python(self.protocol).encode(ExternalEncoding)) + showIndent(outfile, level) + outfile.write('src_addresses=[\n') + level += 1 + for src_addresses_ in self.src_addresses: + showIndent(outfile, level) + outfile.write('model_.AddressType(\n') + src_addresses_.exportLiteral(outfile, level, name_='AddressType') + showIndent(outfile, level) + outfile.write('),\n') + level -= 1 + showIndent(outfile, level) + outfile.write('],\n') + showIndent(outfile, level) + outfile.write('src_ports=[\n') + level += 1 + for src_ports_ in self.src_ports: + showIndent(outfile, level) + outfile.write('model_.PortType(\n') + src_ports_.exportLiteral(outfile, level, name_='PortType') + showIndent(outfile, level) + outfile.write('),\n') + level -= 1 + showIndent(outfile, level) + outfile.write('],\n') + showIndent(outfile, level) + outfile.write('application=[\n') + level += 1 + for application_ in self.application: + showIndent(outfile, level) + outfile.write('%s,\n' % quote_python(application_).encode(ExternalEncoding)) + level -= 1 + showIndent(outfile, level) + outfile.write('],\n') + showIndent(outfile, level) + outfile.write('dst_addresses=[\n') + level += 1 + for dst_addresses_ in self.dst_addresses: + showIndent(outfile, level) + outfile.write('model_.AddressType(\n') + dst_addresses_.exportLiteral(outfile, level, name_='AddressType') + showIndent(outfile, level) + outfile.write('),\n') + level -= 1 + showIndent(outfile, level) + outfile.write('],\n') + showIndent(outfile, level) + outfile.write('dst_ports=[\n') + level += 1 + for dst_ports_ in self.dst_ports: + showIndent(outfile, level) + outfile.write('model_.PortType(\n') + dst_ports_.exportLiteral(outfile, level, name_='PortType') + showIndent(outfile, level) + outfile.write('),\n') + level -= 1 + showIndent(outfile, level) + outfile.write('],\n') + if self.action_list is not None: + showIndent(outfile, level) + outfile.write('action_list=model_.ActionListType(\n') + self.action_list.exportLiteral(outfile, level, name_='action_list') + showIndent(outfile, level) + outfile.write('),\n') + if self.ethertype is not None: + showIndent(outfile, level) + outfile.write('ethertype=%s,\n' % quote_python(self.ethertype).encode(ExternalEncoding)) + def exportDict(self, name_='PolicyRuleType'): + obj_json = json.dumps(self, default=lambda o: dict((k, v) for k, v in o.__dict__.iteritems())) + obj_dict = json.loads(obj_json) + return {name_: obj_dict} + def build(self, node): + self.buildAttributes(node, node.attrib, []) + for child in node: + nodeName_ = Tag_pattern_.match(child.tag).groups()[-1] + self.buildChildren(child, node, nodeName_) + def buildAttributes(self, node, attrs, already_processed): + pass + def buildChildren(self, child_, node, nodeName_, fromsubclass_=False): + if nodeName_ == 'rule-sequence': + obj_ = SequenceType.factory() + obj_.build(child_) + self.set_rule_sequence(obj_) + elif nodeName_ == 'rule-uuid': + rule_uuid_ = child_.text + rule_uuid_ = self.gds_validate_string(rule_uuid_, node, 'rule_uuid') + self.rule_uuid = rule_uuid_ + elif nodeName_ == 'direction': + direction_ = child_.text + direction_ = self.gds_validate_string(direction_, node, 'direction') + self.direction = direction_ + self.validate_DirectionType(self.direction) # validate type DirectionType + elif nodeName_ == 'protocol': + protocol_ = child_.text + protocol_ = self.gds_validate_string(protocol_, node, 'protocol') + self.protocol = protocol_ + self.validate_ProtocolType(self.protocol) # validate type ProtocolType + elif nodeName_ == 'src-addresses': + obj_ = AddressType.factory() + obj_.build(child_) + self.src_addresses.append(obj_) + elif nodeName_ == 'src-ports': + obj_ = PortType.factory() + obj_.build(child_) + self.src_ports.append(obj_) + elif nodeName_ == 'application': + application_ = child_.text + application_ = self.gds_validate_string(application_, node, 'application') + self.application.append(application_) + elif nodeName_ == 'dst-addresses': + obj_ = AddressType.factory() + obj_.build(child_) + self.dst_addresses.append(obj_) + elif nodeName_ == 'dst-ports': + obj_ = PortType.factory() + obj_.build(child_) + self.dst_ports.append(obj_) + elif nodeName_ == 'action-list': + obj_ = ActionListType.factory() + obj_.build(child_) + self.set_action_list(obj_) + elif nodeName_ == 'ethertype': + ethertype_ = child_.text + ethertype_ = self.gds_validate_string(ethertype_, node, 'ethertype') + self.ethertype = ethertype_ + self.validate_EtherType(self.ethertype) # validate type EtherType +# end class PolicyRuleType + + +class PolicyEntriesType(GeneratedsSuper): + """ + PolicyEntriesType class definition from :doc:`vnc_cfg.xsd` + """ + subclass = None + superclass = None + def __init__(self, policy_rule=None, **kwargs): + if (policy_rule is None) or (policy_rule == []): + self.policy_rule = [] + else: + if isinstance(policy_rule[0], dict): + objs = [PolicyRuleType(**elem) for elem in policy_rule] + self.policy_rule = objs + else: + self.policy_rule = policy_rule + def factory(*args_, **kwargs_): + if PolicyEntriesType.subclass: + return PolicyEntriesType.subclass(*args_, **kwargs_) + else: + return PolicyEntriesType(*args_, **kwargs_) + factory = staticmethod(factory) + def get_policy_rule(self): return self.policy_rule + def set_policy_rule(self, policy_rule): self.policy_rule = policy_rule + def add_policy_rule(self, value): self.policy_rule.append(value) + def insert_policy_rule(self, index, value): self.policy_rule[index] = value + def delete_policy_rule(self, value): self.policy_rule.remove(value) + def __eq__(self, other): + if isinstance(other, self.__class__): + return (self.policy_rule == other.policy_rule) + return NotImplemented + def __ne__(self, other): + if isinstance(other, self.__class__): + return not self.__eq__(other) + return NotImplemented + + @classmethod + def populate (cls, *a, **kwa): + obj = cls (*a, **kwa) + obj.set_policy_rule ([PolicyRuleType.populate ()]) + return obj + def export(self, outfile, level=1, namespace_='', name_='PolicyEntriesType', namespacedef_='', pretty_print=True): + if pretty_print: + eol_ = '\n' + else: + eol_ = '' + showIndent(outfile, level, pretty_print) + outfile.write('<%s%s%s' % (namespace_, name_, namespacedef_ and ' ' + namespacedef_ or '', )) + already_processed = [] + self.exportAttributes(outfile, level, already_processed, namespace_, name_='PolicyEntriesType') + if self.hasContent_(): + outfile.write('>%s' % (eol_, )) + self.exportChildren(outfile, level + 1, namespace_, name_, pretty_print=pretty_print) + showIndent(outfile, level, pretty_print) + outfile.write('</%s%s>%s' % (namespace_, name_, eol_)) + else: + outfile.write('/>%s' % (eol_, )) + def exportAttributes(self, outfile, level, already_processed, namespace_='', name_='PolicyEntriesType'): + pass + def exportChildren(self, outfile, level, namespace_='', name_='PolicyEntriesType', fromsubclass_=False, pretty_print=True): + if pretty_print: + eol_ = '\n' + else: + eol_ = '' + for policy_rule_ in self.policy_rule: + if isinstance(policy_rule_, dict): + policy_rule_ = PolicyRuleType(**policy_rule_) + policy_rule_.export(outfile, level, namespace_, name_='policy-rule', pretty_print=pretty_print) + def hasContent_(self): + if ( + self.policy_rule + ): + return True + else: + return False + def exportLiteral(self, outfile, level, name_='PolicyEntriesType'): + level += 1 + self.exportLiteralAttributes(outfile, level, [], name_) + if self.hasContent_(): + self.exportLiteralChildren(outfile, level, name_) + def exportLiteralAttributes(self, outfile, level, already_processed, name_): + pass + def exportLiteralChildren(self, outfile, level, name_): + showIndent(outfile, level) + outfile.write('policy_rule=[\n') + level += 1 + for policy_rule_ in self.policy_rule: + showIndent(outfile, level) + outfile.write('model_.PolicyRuleType(\n') + policy_rule_.exportLiteral(outfile, level, name_='PolicyRuleType') + showIndent(outfile, level) + outfile.write('),\n') + level -= 1 + showIndent(outfile, level) + outfile.write('],\n') + def exportDict(self, name_='PolicyEntriesType'): + obj_json = json.dumps(self, default=lambda o: dict((k, v) for k, v in o.__dict__.iteritems())) + obj_dict = json.loads(obj_json) + return {name_: obj_dict} + def build(self, node): + self.buildAttributes(node, node.attrib, []) + for child in node: + nodeName_ = Tag_pattern_.match(child.tag).groups()[-1] + self.buildChildren(child, node, nodeName_) + def buildAttributes(self, node, attrs, already_processed): + pass + def buildChildren(self, child_, node, nodeName_, fromsubclass_=False): + if nodeName_ == 'policy-rule': + obj_ = PolicyRuleType.factory() + obj_.build(child_) + self.policy_rule.append(obj_) +# end class PolicyEntriesType + + +class ApiAccessType(GeneratedsSuper): + """ + ApiAccessType class definition from :doc:`vnc_cfg.xsd` + """ + subclass = None + superclass = None + def __init__(self, api_name=None, permissions=None, **kwargs): + self.api_name = api_name + if isinstance(permissions, dict): + obj = PermType(**permissions) + self.permissions = obj + else: + self.permissions = permissions + def factory(*args_, **kwargs_): + if ApiAccessType.subclass: + return ApiAccessType.subclass(*args_, **kwargs_) + else: + return ApiAccessType(*args_, **kwargs_) + factory = staticmethod(factory) + def get_api_name(self): return self.api_name + def set_api_name(self, api_name): self.api_name = api_name + def get_permissions(self): return self.permissions + def set_permissions(self, permissions): self.permissions = permissions + def __eq__(self, other): + if isinstance(other, self.__class__): + return (self.api_name == other.api_name and + self.permissions == other.permissions) + return NotImplemented + def __ne__(self, other): + if isinstance(other, self.__class__): + return not self.__eq__(other) + return NotImplemented + + @classmethod + def populate (cls, *a, **kwa): + obj = cls (*a, **kwa) + obj.set_api_name (obj.populate_string ("api_name")) + obj.set_permissions (PermType.populate ()) + return obj + def export(self, outfile, level=1, namespace_='', name_='ApiAccessType', namespacedef_='', pretty_print=True): + if pretty_print: + eol_ = '\n' + else: + eol_ = '' + showIndent(outfile, level, pretty_print) + outfile.write('<%s%s%s' % (namespace_, name_, namespacedef_ and ' ' + namespacedef_ or '', )) + already_processed = [] + self.exportAttributes(outfile, level, already_processed, namespace_, name_='ApiAccessType') + if self.hasContent_(): + outfile.write('>%s' % (eol_, )) + self.exportChildren(outfile, level + 1, namespace_, name_, pretty_print=pretty_print) + showIndent(outfile, level, pretty_print) + outfile.write('</%s%s>%s' % (namespace_, name_, eol_)) + else: + outfile.write('/>%s' % (eol_, )) + def exportAttributes(self, outfile, level, already_processed, namespace_='', name_='ApiAccessType'): + pass + def exportChildren(self, outfile, level, namespace_='', name_='ApiAccessType', fromsubclass_=False, pretty_print=True): + if pretty_print: + eol_ = '\n' + else: + eol_ = '' + if self.api_name is not None: + showIndent(outfile, level, pretty_print) + outfile.write('<%sapi-name>%s</%sapi-name>%s' % (namespace_, self.gds_format_string(quote_xml(self.api_name).encode(ExternalEncoding), input_name='api-name'), namespace_, eol_)) + if self.permissions is not None: + self.permissions.export(outfile, level, namespace_, name_='permissions', pretty_print=pretty_print) + def hasContent_(self): + if ( + self.api_name is not None or + self.permissions is not None + ): + return True + else: + return False + def exportLiteral(self, outfile, level, name_='ApiAccessType'): + level += 1 + self.exportLiteralAttributes(outfile, level, [], name_) + if self.hasContent_(): + self.exportLiteralChildren(outfile, level, name_) + def exportLiteralAttributes(self, outfile, level, already_processed, name_): + pass + def exportLiteralChildren(self, outfile, level, name_): + if self.api_name is not None: + showIndent(outfile, level) + outfile.write('api_name=%s,\n' % quote_python(self.api_name).encode(ExternalEncoding)) + if self.permissions is not None: + showIndent(outfile, level) + outfile.write('permissions=model_.PermType(\n') + self.permissions.exportLiteral(outfile, level, name_='permissions') + showIndent(outfile, level) + outfile.write('),\n') + def exportDict(self, name_='ApiAccessType'): + obj_json = json.dumps(self, default=lambda o: dict((k, v) for k, v in o.__dict__.iteritems())) + obj_dict = json.loads(obj_json) + return {name_: obj_dict} + def build(self, node): + self.buildAttributes(node, node.attrib, []) + for child in node: + nodeName_ = Tag_pattern_.match(child.tag).groups()[-1] + self.buildChildren(child, node, nodeName_) + def buildAttributes(self, node, attrs, already_processed): + pass + def buildChildren(self, child_, node, nodeName_, fromsubclass_=False): + if nodeName_ == 'api-name': + api_name_ = child_.text + api_name_ = self.gds_validate_string(api_name_, node, 'api_name') + self.api_name = api_name_ + elif nodeName_ == 'permissions': + obj_ = PermType.factory() + obj_.build(child_) + self.set_permissions(obj_) +# end class ApiAccessType + + +class ApiAccessListType(GeneratedsSuper): + """ + ApiAccessListType class definition from :doc:`vnc_cfg.xsd` + """ + subclass = None + superclass = None + def __init__(self, api_access=None, **kwargs): + if (api_access is None) or (api_access == []): + self.api_access = [] + else: + if isinstance(api_access[0], dict): + objs = [ApiAccessType(**elem) for elem in api_access] + self.api_access = objs + else: + self.api_access = api_access + def factory(*args_, **kwargs_): + if ApiAccessListType.subclass: + return ApiAccessListType.subclass(*args_, **kwargs_) + else: + return ApiAccessListType(*args_, **kwargs_) + factory = staticmethod(factory) + def get_api_access(self): return self.api_access + def set_api_access(self, api_access): self.api_access = api_access + def add_api_access(self, value): self.api_access.append(value) + def insert_api_access(self, index, value): self.api_access[index] = value + def delete_api_access(self, value): self.api_access.remove(value) + def __eq__(self, other): + if isinstance(other, self.__class__): + return (self.api_access == other.api_access) + return NotImplemented + def __ne__(self, other): + if isinstance(other, self.__class__): + return not self.__eq__(other) + return NotImplemented + + @classmethod + def populate (cls, *a, **kwa): + obj = cls (*a, **kwa) + obj.set_api_access ([ApiAccessType.populate ()]) + return obj + def export(self, outfile, level=1, namespace_='', name_='ApiAccessListType', namespacedef_='', pretty_print=True): + if pretty_print: + eol_ = '\n' + else: + eol_ = '' + showIndent(outfile, level, pretty_print) + outfile.write('<%s%s%s' % (namespace_, name_, namespacedef_ and ' ' + namespacedef_ or '', )) + already_processed = [] + self.exportAttributes(outfile, level, already_processed, namespace_, name_='ApiAccessListType') + if self.hasContent_(): + outfile.write('>%s' % (eol_, )) + self.exportChildren(outfile, level + 1, namespace_, name_, pretty_print=pretty_print) + showIndent(outfile, level, pretty_print) + outfile.write('</%s%s>%s' % (namespace_, name_, eol_)) + else: + outfile.write('/>%s' % (eol_, )) + def exportAttributes(self, outfile, level, already_processed, namespace_='', name_='ApiAccessListType'): + pass + def exportChildren(self, outfile, level, namespace_='', name_='ApiAccessListType', fromsubclass_=False, pretty_print=True): + if pretty_print: + eol_ = '\n' + else: + eol_ = '' + for api_access_ in self.api_access: + if isinstance(api_access_, dict): + api_access_ = ApiAccessType(**api_access_) + api_access_.export(outfile, level, namespace_, name_='api-access', pretty_print=pretty_print) + def hasContent_(self): + if ( + self.api_access + ): + return True + else: + return False + def exportLiteral(self, outfile, level, name_='ApiAccessListType'): + level += 1 + self.exportLiteralAttributes(outfile, level, [], name_) + if self.hasContent_(): + self.exportLiteralChildren(outfile, level, name_) + def exportLiteralAttributes(self, outfile, level, already_processed, name_): + pass + def exportLiteralChildren(self, outfile, level, name_): + showIndent(outfile, level) + outfile.write('api_access=[\n') + level += 1 + for api_access_ in self.api_access: + showIndent(outfile, level) + outfile.write('model_.ApiAccessType(\n') + api_access_.exportLiteral(outfile, level, name_='ApiAccessType') + showIndent(outfile, level) + outfile.write('),\n') + level -= 1 + showIndent(outfile, level) + outfile.write('],\n') + def exportDict(self, name_='ApiAccessListType'): + obj_json = json.dumps(self, default=lambda o: dict((k, v) for k, v in o.__dict__.iteritems())) + obj_dict = json.loads(obj_json) + return {name_: obj_dict} + def build(self, node): + self.buildAttributes(node, node.attrib, []) + for child in node: + nodeName_ = Tag_pattern_.match(child.tag).groups()[-1] + self.buildChildren(child, node, nodeName_) + def buildAttributes(self, node, attrs, already_processed): + pass + def buildChildren(self, child_, node, nodeName_, fromsubclass_=False): + if nodeName_ == 'api-access': + obj_ = ApiAccessType.factory() + obj_.build(child_) + self.api_access.append(obj_) +# end class ApiAccessListType + + +class DhcpOptionType(GeneratedsSuper): + """ + DhcpOptionType class definition from :doc:`vnc_cfg.xsd` + """ + subclass = None + superclass = None + def __init__(self, dhcp_option_name=None, dhcp_option_value=None, **kwargs): + self.dhcp_option_name = dhcp_option_name + self.dhcp_option_value = dhcp_option_value + def factory(*args_, **kwargs_): + if DhcpOptionType.subclass: + return DhcpOptionType.subclass(*args_, **kwargs_) + else: + return DhcpOptionType(*args_, **kwargs_) + factory = staticmethod(factory) + def get_dhcp_option_name(self): return self.dhcp_option_name + def set_dhcp_option_name(self, dhcp_option_name): self.dhcp_option_name = dhcp_option_name + def get_dhcp_option_value(self): return self.dhcp_option_value + def set_dhcp_option_value(self, dhcp_option_value): self.dhcp_option_value = dhcp_option_value + def __eq__(self, other): + if isinstance(other, self.__class__): + return (self.dhcp_option_name == other.dhcp_option_name and + self.dhcp_option_value == other.dhcp_option_value) + return NotImplemented + def __ne__(self, other): + if isinstance(other, self.__class__): + return not self.__eq__(other) + return NotImplemented + + @classmethod + def populate (cls, *a, **kwa): + obj = cls (*a, **kwa) + obj.set_dhcp_option_name (obj.populate_string ("dhcp_option_name")) + obj.set_dhcp_option_value (obj.populate_string ("dhcp_option_value")) + return obj + def export(self, outfile, level=1, namespace_='', name_='DhcpOptionType', namespacedef_='', pretty_print=True): + if pretty_print: + eol_ = '\n' + else: + eol_ = '' + showIndent(outfile, level, pretty_print) + outfile.write('<%s%s%s' % (namespace_, name_, namespacedef_ and ' ' + namespacedef_ or '', )) + already_processed = [] + self.exportAttributes(outfile, level, already_processed, namespace_, name_='DhcpOptionType') + if self.hasContent_(): + outfile.write('>%s' % (eol_, )) + self.exportChildren(outfile, level + 1, namespace_, name_, pretty_print=pretty_print) + showIndent(outfile, level, pretty_print) + outfile.write('</%s%s>%s' % (namespace_, name_, eol_)) + else: + outfile.write('/>%s' % (eol_, )) + def exportAttributes(self, outfile, level, already_processed, namespace_='', name_='DhcpOptionType'): + pass + def exportChildren(self, outfile, level, namespace_='', name_='DhcpOptionType', fromsubclass_=False, pretty_print=True): + if pretty_print: + eol_ = '\n' + else: + eol_ = '' + if self.dhcp_option_name is not None: + showIndent(outfile, level, pretty_print) + outfile.write('<%sdhcp-option-name>%s</%sdhcp-option-name>%s' % (namespace_, self.gds_format_string(quote_xml(self.dhcp_option_name).encode(ExternalEncoding), input_name='dhcp-option-name'), namespace_, eol_)) + if self.dhcp_option_value is not None: + showIndent(outfile, level, pretty_print) + outfile.write('<%sdhcp-option-value>%s</%sdhcp-option-value>%s' % (namespace_, self.gds_format_string(quote_xml(self.dhcp_option_value).encode(ExternalEncoding), input_name='dhcp-option-value'), namespace_, eol_)) + def hasContent_(self): + if ( + self.dhcp_option_name is not None or + self.dhcp_option_value is not None + ): + return True + else: + return False + def exportLiteral(self, outfile, level, name_='DhcpOptionType'): + level += 1 + self.exportLiteralAttributes(outfile, level, [], name_) + if self.hasContent_(): + self.exportLiteralChildren(outfile, level, name_) + def exportLiteralAttributes(self, outfile, level, already_processed, name_): + pass + def exportLiteralChildren(self, outfile, level, name_): + if self.dhcp_option_name is not None: + showIndent(outfile, level) + outfile.write('dhcp_option_name=%s,\n' % quote_python(self.dhcp_option_name).encode(ExternalEncoding)) + if self.dhcp_option_value is not None: + showIndent(outfile, level) + outfile.write('dhcp_option_value=%s,\n' % quote_python(self.dhcp_option_value).encode(ExternalEncoding)) + def exportDict(self, name_='DhcpOptionType'): + obj_json = json.dumps(self, default=lambda o: dict((k, v) for k, v in o.__dict__.iteritems())) + obj_dict = json.loads(obj_json) + return {name_: obj_dict} + def build(self, node): + self.buildAttributes(node, node.attrib, []) + for child in node: + nodeName_ = Tag_pattern_.match(child.tag).groups()[-1] + self.buildChildren(child, node, nodeName_) + def buildAttributes(self, node, attrs, already_processed): + pass + def buildChildren(self, child_, node, nodeName_, fromsubclass_=False): + if nodeName_ == 'dhcp-option-name': + dhcp_option_name_ = child_.text + dhcp_option_name_ = self.gds_validate_string(dhcp_option_name_, node, 'dhcp_option_name') + self.dhcp_option_name = dhcp_option_name_ + elif nodeName_ == 'dhcp-option-value': + dhcp_option_value_ = child_.text + dhcp_option_value_ = self.gds_validate_string(dhcp_option_value_, node, 'dhcp_option_value') + self.dhcp_option_value = dhcp_option_value_ +# end class DhcpOptionType + + +class DhcpOptionsListType(GeneratedsSuper): + """ + DhcpOptionsListType class definition from :doc:`vnc_cfg.xsd` + """ + subclass = None + superclass = None + def __init__(self, dhcp_option=None, **kwargs): + if (dhcp_option is None) or (dhcp_option == []): + self.dhcp_option = [] + else: + if isinstance(dhcp_option[0], dict): + objs = [DhcpOptionType(**elem) for elem in dhcp_option] + self.dhcp_option = objs + else: + self.dhcp_option = dhcp_option + def factory(*args_, **kwargs_): + if DhcpOptionsListType.subclass: + return DhcpOptionsListType.subclass(*args_, **kwargs_) + else: + return DhcpOptionsListType(*args_, **kwargs_) + factory = staticmethod(factory) + def get_dhcp_option(self): return self.dhcp_option + def set_dhcp_option(self, dhcp_option): self.dhcp_option = dhcp_option + def add_dhcp_option(self, value): self.dhcp_option.append(value) + def insert_dhcp_option(self, index, value): self.dhcp_option[index] = value + def delete_dhcp_option(self, value): self.dhcp_option.remove(value) + def __eq__(self, other): + if isinstance(other, self.__class__): + return (self.dhcp_option == other.dhcp_option) + return NotImplemented + def __ne__(self, other): + if isinstance(other, self.__class__): + return not self.__eq__(other) + return NotImplemented + + @classmethod + def populate (cls, *a, **kwa): + obj = cls (*a, **kwa) + obj.set_dhcp_option ([DhcpOptionType.populate ()]) + return obj + def export(self, outfile, level=1, namespace_='', name_='DhcpOptionsListType', namespacedef_='', pretty_print=True): + if pretty_print: + eol_ = '\n' + else: + eol_ = '' + showIndent(outfile, level, pretty_print) + outfile.write('<%s%s%s' % (namespace_, name_, namespacedef_ and ' ' + namespacedef_ or '', )) + already_processed = [] + self.exportAttributes(outfile, level, already_processed, namespace_, name_='DhcpOptionsListType') + if self.hasContent_(): + outfile.write('>%s' % (eol_, )) + self.exportChildren(outfile, level + 1, namespace_, name_, pretty_print=pretty_print) + showIndent(outfile, level, pretty_print) + outfile.write('</%s%s>%s' % (namespace_, name_, eol_)) + else: + outfile.write('/>%s' % (eol_, )) + def exportAttributes(self, outfile, level, already_processed, namespace_='', name_='DhcpOptionsListType'): + pass + def exportChildren(self, outfile, level, namespace_='', name_='DhcpOptionsListType', fromsubclass_=False, pretty_print=True): + if pretty_print: + eol_ = '\n' + else: + eol_ = '' + for dhcp_option_ in self.dhcp_option: + if isinstance(dhcp_option_, dict): + dhcp_option_ = DhcpOptionType(**dhcp_option_) + dhcp_option_.export(outfile, level, namespace_, name_='dhcp-option', pretty_print=pretty_print) + def hasContent_(self): + if ( + self.dhcp_option + ): + return True + else: + return False + def exportLiteral(self, outfile, level, name_='DhcpOptionsListType'): + level += 1 + self.exportLiteralAttributes(outfile, level, [], name_) + if self.hasContent_(): + self.exportLiteralChildren(outfile, level, name_) + def exportLiteralAttributes(self, outfile, level, already_processed, name_): + pass + def exportLiteralChildren(self, outfile, level, name_): + showIndent(outfile, level) + outfile.write('dhcp_option=[\n') + level += 1 + for dhcp_option_ in self.dhcp_option: + showIndent(outfile, level) + outfile.write('model_.DhcpOptionType(\n') + dhcp_option_.exportLiteral(outfile, level, name_='DhcpOptionType') + showIndent(outfile, level) + outfile.write('),\n') + level -= 1 + showIndent(outfile, level) + outfile.write('],\n') + def exportDict(self, name_='DhcpOptionsListType'): + obj_json = json.dumps(self, default=lambda o: dict((k, v) for k, v in o.__dict__.iteritems())) + obj_dict = json.loads(obj_json) + return {name_: obj_dict} + def build(self, node): + self.buildAttributes(node, node.attrib, []) + for child in node: + nodeName_ = Tag_pattern_.match(child.tag).groups()[-1] + self.buildChildren(child, node, nodeName_) + def buildAttributes(self, node, attrs, already_processed): + pass + def buildChildren(self, child_, node, nodeName_, fromsubclass_=False): + if nodeName_ == 'dhcp-option': + obj_ = DhcpOptionType.factory() + obj_.build(child_) + self.dhcp_option.append(obj_) +# end class DhcpOptionsListType + + +class IpamDnsAddressType(GeneratedsSuper): + """ + IpamDnsAddressType class definition from :doc:`vnc_cfg.xsd` + """ + subclass = None + superclass = None + def __init__(self, tenant_dns_server_address=None, virtual_dns_server_name=None, **kwargs): + if isinstance(tenant_dns_server_address, dict): + obj = IpAddressesType(**tenant_dns_server_address) + self.tenant_dns_server_address = obj + else: + self.tenant_dns_server_address = tenant_dns_server_address + self.virtual_dns_server_name = virtual_dns_server_name + def factory(*args_, **kwargs_): + if IpamDnsAddressType.subclass: + return IpamDnsAddressType.subclass(*args_, **kwargs_) + else: + return IpamDnsAddressType(*args_, **kwargs_) + factory = staticmethod(factory) + def get_tenant_dns_server_address(self): return self.tenant_dns_server_address + def set_tenant_dns_server_address(self, tenant_dns_server_address): self.tenant_dns_server_address = tenant_dns_server_address + def get_virtual_dns_server_name(self): return self.virtual_dns_server_name + def set_virtual_dns_server_name(self, virtual_dns_server_name): self.virtual_dns_server_name = virtual_dns_server_name + def __eq__(self, other): + if isinstance(other, self.__class__): + return (self.tenant_dns_server_address == other.tenant_dns_server_address and + self.virtual_dns_server_name == other.virtual_dns_server_name) + return NotImplemented + def __ne__(self, other): + if isinstance(other, self.__class__): + return not self.__eq__(other) + return NotImplemented + + @classmethod + def populate (cls, *a, **kwa): + obj = cls (*a, **kwa) + obj.set_tenant_dns_server_address (IpAddressesType.populate ()) + obj.set_virtual_dns_server_name (obj.populate_string ("virtual_dns_server_name")) + return obj + def export(self, outfile, level=1, namespace_='', name_='IpamDnsAddressType', namespacedef_='', pretty_print=True): + if pretty_print: + eol_ = '\n' + else: + eol_ = '' + showIndent(outfile, level, pretty_print) + outfile.write('<%s%s%s' % (namespace_, name_, namespacedef_ and ' ' + namespacedef_ or '', )) + already_processed = [] + self.exportAttributes(outfile, level, already_processed, namespace_, name_='IpamDnsAddressType') + if self.hasContent_(): + outfile.write('>%s' % (eol_, )) + self.exportChildren(outfile, level + 1, namespace_, name_, pretty_print=pretty_print) + showIndent(outfile, level, pretty_print) + outfile.write('</%s%s>%s' % (namespace_, name_, eol_)) + else: + outfile.write('/>%s' % (eol_, )) + def exportAttributes(self, outfile, level, already_processed, namespace_='', name_='IpamDnsAddressType'): + pass + def exportChildren(self, outfile, level, namespace_='', name_='IpamDnsAddressType', fromsubclass_=False, pretty_print=True): + if pretty_print: + eol_ = '\n' + else: + eol_ = '' + if self.tenant_dns_server_address is not None: + self.tenant_dns_server_address.export(outfile, level, namespace_, name_='tenant-dns-server-address', pretty_print=pretty_print) + if self.virtual_dns_server_name is not None: + showIndent(outfile, level, pretty_print) + outfile.write('<%svirtual-dns-server-name>%s</%svirtual-dns-server-name>%s' % (namespace_, self.gds_format_string(quote_xml(self.virtual_dns_server_name).encode(ExternalEncoding), input_name='virtual-dns-server-name'), namespace_, eol_)) + def hasContent_(self): + if ( + self.tenant_dns_server_address is not None or + self.virtual_dns_server_name is not None + ): + return True + else: + return False + def exportLiteral(self, outfile, level, name_='IpamDnsAddressType'): + level += 1 + self.exportLiteralAttributes(outfile, level, [], name_) + if self.hasContent_(): + self.exportLiteralChildren(outfile, level, name_) + def exportLiteralAttributes(self, outfile, level, already_processed, name_): + pass + def exportLiteralChildren(self, outfile, level, name_): + if self.tenant_dns_server_address is not None: + showIndent(outfile, level) + outfile.write('tenant_dns_server_address=model_.IpAddressesType(\n') + self.tenant_dns_server_address.exportLiteral(outfile, level, name_='tenant_dns_server_address') + showIndent(outfile, level) + outfile.write('),\n') + if self.virtual_dns_server_name is not None: + showIndent(outfile, level) + outfile.write('virtual_dns_server_name=%s,\n' % quote_python(self.virtual_dns_server_name).encode(ExternalEncoding)) + def exportDict(self, name_='IpamDnsAddressType'): + obj_json = json.dumps(self, default=lambda o: dict((k, v) for k, v in o.__dict__.iteritems())) + obj_dict = json.loads(obj_json) + return {name_: obj_dict} + def build(self, node): + self.buildAttributes(node, node.attrib, []) + for child in node: + nodeName_ = Tag_pattern_.match(child.tag).groups()[-1] + self.buildChildren(child, node, nodeName_) + def buildAttributes(self, node, attrs, already_processed): + pass + def buildChildren(self, child_, node, nodeName_, fromsubclass_=False): + if nodeName_ == 'tenant-dns-server-address': + obj_ = IpAddressesType.factory() + obj_.build(child_) + self.set_tenant_dns_server_address(obj_) + elif nodeName_ == 'virtual-dns-server-name': + virtual_dns_server_name_ = child_.text + virtual_dns_server_name_ = self.gds_validate_string(virtual_dns_server_name_, node, 'virtual_dns_server_name') + self.virtual_dns_server_name = virtual_dns_server_name_ +# end class IpamDnsAddressType + + +class IpamType(GeneratedsSuper): + """ + IpamType class definition from :doc:`vnc_cfg.xsd` + """ + subclass = None + superclass = None + def __init__(self, ipam_method=None, ipam_dns_method=None, ipam_dns_server=None, dhcp_option_list=None, cidr_block=None, host_routes=None, **kwargs): + self.ipam_method = ipam_method + self.ipam_dns_method = ipam_dns_method + if isinstance(ipam_dns_server, dict): + obj = IpamDnsAddressType(**ipam_dns_server) + self.ipam_dns_server = obj + else: + self.ipam_dns_server = ipam_dns_server + if isinstance(dhcp_option_list, dict): + obj = DhcpOptionsListType(**dhcp_option_list) + self.dhcp_option_list = obj + else: + self.dhcp_option_list = dhcp_option_list + if isinstance(cidr_block, dict): + obj = SubnetType(**cidr_block) + self.cidr_block = obj + else: + self.cidr_block = cidr_block + if isinstance(host_routes, dict): + obj = RouteTableType(**host_routes) + self.host_routes = obj + else: + self.host_routes = host_routes + def factory(*args_, **kwargs_): + if IpamType.subclass: + return IpamType.subclass(*args_, **kwargs_) + else: + return IpamType(*args_, **kwargs_) + factory = staticmethod(factory) + def get_ipam_method(self): return self.ipam_method + def set_ipam_method(self, ipam_method): self.ipam_method = ipam_method + def validate_IpamMethodType(self, value): + # Validate type IpamMethodType, a restriction on xsd:string. + error = False + if isinstance(value, list): + error = set(value) - set([u'dhcp', u'fixed']) + else: + error = value not in [u'dhcp', u'fixed'] + if error: + raise ValueError("IpamMethodType must be one of [u'dhcp', u'fixed']") + def get_ipam_dns_method(self): return self.ipam_dns_method + def set_ipam_dns_method(self, ipam_dns_method): self.ipam_dns_method = ipam_dns_method + def validate_IpamDnsMethodType(self, value): + # Validate type IpamDnsMethodType, a restriction on xsd:string. + error = False + if isinstance(value, list): + error = set(value) - set([u'none', u'default-dns-server', u'tenant-dns-server', u'virtual-dns-server']) + else: + error = value not in [u'none', u'default-dns-server', u'tenant-dns-server', u'virtual-dns-server'] + if error: + raise ValueError("IpamDnsMethodType must be one of [u'none', u'default-dns-server', u'tenant-dns-server', u'virtual-dns-server']") + def get_ipam_dns_server(self): return self.ipam_dns_server + def set_ipam_dns_server(self, ipam_dns_server): self.ipam_dns_server = ipam_dns_server + def get_dhcp_option_list(self): return self.dhcp_option_list + def set_dhcp_option_list(self, dhcp_option_list): self.dhcp_option_list = dhcp_option_list + def get_cidr_block(self): return self.cidr_block + def set_cidr_block(self, cidr_block): self.cidr_block = cidr_block + def get_host_routes(self): return self.host_routes + def set_host_routes(self, host_routes): self.host_routes = host_routes + def __eq__(self, other): + if isinstance(other, self.__class__): + return (self.ipam_method == other.ipam_method and + self.ipam_dns_method == other.ipam_dns_method and + self.ipam_dns_server == other.ipam_dns_server and + self.dhcp_option_list == other.dhcp_option_list and + self.cidr_block == other.cidr_block and + self.host_routes == other.host_routes) + return NotImplemented + def __ne__(self, other): + if isinstance(other, self.__class__): + return not self.__eq__(other) + return NotImplemented + + @classmethod + def populate (cls, *a, **kwa): + obj = cls (*a, **kwa) + obj.set_ipam_method (obj.populate_string ("ipam_method")) + obj.set_ipam_dns_method (obj.populate_string ("ipam_dns_method")) + obj.set_ipam_dns_server (IpamDnsAddressType.populate ()) + obj.set_dhcp_option_list (DhcpOptionsListType.populate ()) + obj.set_cidr_block (SubnetType.populate ()) + obj.set_host_routes (RouteTableType.populate ()) + return obj + def export(self, outfile, level=1, namespace_='', name_='IpamType', namespacedef_='', pretty_print=True): + if pretty_print: + eol_ = '\n' + else: + eol_ = '' + showIndent(outfile, level, pretty_print) + outfile.write('<%s%s%s' % (namespace_, name_, namespacedef_ and ' ' + namespacedef_ or '', )) + already_processed = [] + self.exportAttributes(outfile, level, already_processed, namespace_, name_='IpamType') + if self.hasContent_(): + outfile.write('>%s' % (eol_, )) + self.exportChildren(outfile, level + 1, namespace_, name_, pretty_print=pretty_print) + showIndent(outfile, level, pretty_print) + outfile.write('</%s%s>%s' % (namespace_, name_, eol_)) + else: + outfile.write('/>%s' % (eol_, )) + def exportAttributes(self, outfile, level, already_processed, namespace_='', name_='IpamType'): + pass + def exportChildren(self, outfile, level, namespace_='', name_='IpamType', fromsubclass_=False, pretty_print=True): + if pretty_print: + eol_ = '\n' + else: + eol_ = '' + if self.ipam_method is not None: + showIndent(outfile, level, pretty_print) + outfile.write('<%sipam-method>%s</%sipam-method>%s' % (namespace_, self.gds_format_string(quote_xml(self.ipam_method).encode(ExternalEncoding), input_name='ipam-method'), namespace_, eol_)) + if self.ipam_dns_method is not None: + showIndent(outfile, level, pretty_print) + outfile.write('<%sipam-dns-method>%s</%sipam-dns-method>%s' % (namespace_, self.gds_format_string(quote_xml(self.ipam_dns_method).encode(ExternalEncoding), input_name='ipam-dns-method'), namespace_, eol_)) + if self.ipam_dns_server is not None: + self.ipam_dns_server.export(outfile, level, namespace_, name_='ipam-dns-server', pretty_print=pretty_print) + if self.dhcp_option_list is not None: + self.dhcp_option_list.export(outfile, level, namespace_, name_='dhcp-option-list', pretty_print=pretty_print) + if self.cidr_block is not None: + self.cidr_block.export(outfile, level, namespace_, name_='cidr-block', pretty_print=pretty_print) + if self.host_routes is not None: + self.host_routes.export(outfile, level, namespace_, name_='host-routes', pretty_print=pretty_print) + def hasContent_(self): + if ( + self.ipam_method is not None or + self.ipam_dns_method is not None or + self.ipam_dns_server is not None or + self.dhcp_option_list is not None or + self.cidr_block is not None or + self.host_routes is not None + ): + return True + else: + return False + def exportLiteral(self, outfile, level, name_='IpamType'): + level += 1 + self.exportLiteralAttributes(outfile, level, [], name_) + if self.hasContent_(): + self.exportLiteralChildren(outfile, level, name_) + def exportLiteralAttributes(self, outfile, level, already_processed, name_): + pass + def exportLiteralChildren(self, outfile, level, name_): + if self.ipam_method is not None: + showIndent(outfile, level) + outfile.write('ipam_method=%s,\n' % quote_python(self.ipam_method).encode(ExternalEncoding)) + if self.ipam_dns_method is not None: + showIndent(outfile, level) + outfile.write('ipam_dns_method=%s,\n' % quote_python(self.ipam_dns_method).encode(ExternalEncoding)) + if self.ipam_dns_server is not None: + showIndent(outfile, level) + outfile.write('ipam_dns_server=model_.IpamDnsAddressType(\n') + self.ipam_dns_server.exportLiteral(outfile, level, name_='ipam_dns_server') + showIndent(outfile, level) + outfile.write('),\n') + if self.dhcp_option_list is not None: + showIndent(outfile, level) + outfile.write('dhcp_option_list=model_.DhcpOptionsListType(\n') + self.dhcp_option_list.exportLiteral(outfile, level, name_='dhcp_option_list') + showIndent(outfile, level) + outfile.write('),\n') + if self.cidr_block is not None: + showIndent(outfile, level) + outfile.write('cidr_block=model_.SubnetType(\n') + self.cidr_block.exportLiteral(outfile, level, name_='cidr_block') + showIndent(outfile, level) + outfile.write('),\n') + if self.host_routes is not None: + showIndent(outfile, level) + outfile.write('host_routes=model_.RouteTableType(\n') + self.host_routes.exportLiteral(outfile, level, name_='host_routes') + showIndent(outfile, level) + outfile.write('),\n') + def exportDict(self, name_='IpamType'): + obj_json = json.dumps(self, default=lambda o: dict((k, v) for k, v in o.__dict__.iteritems())) + obj_dict = json.loads(obj_json) + return {name_: obj_dict} + def build(self, node): + self.buildAttributes(node, node.attrib, []) + for child in node: + nodeName_ = Tag_pattern_.match(child.tag).groups()[-1] + self.buildChildren(child, node, nodeName_) + def buildAttributes(self, node, attrs, already_processed): + pass + def buildChildren(self, child_, node, nodeName_, fromsubclass_=False): + if nodeName_ == 'ipam-method': + ipam_method_ = child_.text + ipam_method_ = self.gds_validate_string(ipam_method_, node, 'ipam_method') + self.ipam_method = ipam_method_ + self.validate_IpamMethodType(self.ipam_method) # validate type IpamMethodType + elif nodeName_ == 'ipam-dns-method': + ipam_dns_method_ = child_.text + ipam_dns_method_ = self.gds_validate_string(ipam_dns_method_, node, 'ipam_dns_method') + self.ipam_dns_method = ipam_dns_method_ + self.validate_IpamDnsMethodType(self.ipam_dns_method) # validate type IpamDnsMethodType + elif nodeName_ == 'ipam-dns-server': + obj_ = IpamDnsAddressType.factory() + obj_.build(child_) + self.set_ipam_dns_server(obj_) + elif nodeName_ == 'dhcp-option-list': + obj_ = DhcpOptionsListType.factory() + obj_.build(child_) + self.set_dhcp_option_list(obj_) + elif nodeName_ == 'cidr-block': + obj_ = SubnetType.factory() + obj_.build(child_) + self.set_cidr_block(obj_) + elif nodeName_ == 'host-routes': + obj_ = RouteTableType.factory() + obj_.build(child_) + self.set_host_routes(obj_) +# end class IpamType + + +class EncapsulationPrioritiesType(GeneratedsSuper): + """ + EncapsulationPrioritiesType class definition from :doc:`vnc_cfg.xsd` + """ + subclass = None + superclass = None + def __init__(self, encapsulation=None, **kwargs): + if (encapsulation is None) or (encapsulation == []): + self.encapsulation = [] + else: + self.encapsulation = encapsulation + def factory(*args_, **kwargs_): + if EncapsulationPrioritiesType.subclass: + return EncapsulationPrioritiesType.subclass(*args_, **kwargs_) + else: + return EncapsulationPrioritiesType(*args_, **kwargs_) + factory = staticmethod(factory) + def get_encapsulation(self): return self.encapsulation + def set_encapsulation(self, encapsulation): self.encapsulation = encapsulation + def add_encapsulation(self, value): self.encapsulation.append(value) + def insert_encapsulation(self, index, value): self.encapsulation[index] = value + def delete_encapsulation(self, value): self.encapsulation.remove(value) + def validate_EncapsulationType(self, value): + # Validate type EncapsulationType, a restriction on xsd:string. + error = False + if isinstance(value, list): + error = set(value) - set([u'MPLSoGRE', u'MPLSoUDP', u'VXLAN']) + else: + error = value not in [u'MPLSoGRE', u'MPLSoUDP', u'VXLAN'] + if error: + raise ValueError("EncapsulationType must be one of [u'MPLSoGRE', u'MPLSoUDP', u'VXLAN']") + def __eq__(self, other): + if isinstance(other, self.__class__): + return (self.encapsulation == other.encapsulation) + return NotImplemented + def __ne__(self, other): + if isinstance(other, self.__class__): + return not self.__eq__(other) + return NotImplemented + + @classmethod + def populate (cls, *a, **kwa): + obj = cls (*a, **kwa) + obj.set_encapsulation ([obj.populate_string ("encapsulation")]) + return obj + def export(self, outfile, level=1, namespace_='', name_='EncapsulationPrioritiesType', namespacedef_='', pretty_print=True): + if pretty_print: + eol_ = '\n' + else: + eol_ = '' + showIndent(outfile, level, pretty_print) + outfile.write('<%s%s%s' % (namespace_, name_, namespacedef_ and ' ' + namespacedef_ or '', )) + already_processed = [] + self.exportAttributes(outfile, level, already_processed, namespace_, name_='EncapsulationPrioritiesType') + if self.hasContent_(): + outfile.write('>%s' % (eol_, )) + self.exportChildren(outfile, level + 1, namespace_, name_, pretty_print=pretty_print) + showIndent(outfile, level, pretty_print) + outfile.write('</%s%s>%s' % (namespace_, name_, eol_)) + else: + outfile.write('/>%s' % (eol_, )) + def exportAttributes(self, outfile, level, already_processed, namespace_='', name_='EncapsulationPrioritiesType'): + pass + def exportChildren(self, outfile, level, namespace_='', name_='EncapsulationPrioritiesType', fromsubclass_=False, pretty_print=True): + if pretty_print: + eol_ = '\n' + else: + eol_ = '' + for encapsulation_ in self.encapsulation: + showIndent(outfile, level, pretty_print) + outfile.write('<%sencapsulation>%s</%sencapsulation>%s' % (namespace_, self.gds_format_string(quote_xml(encapsulation_).encode(ExternalEncoding), input_name='encapsulation'), namespace_, eol_)) + def hasContent_(self): + if ( + self.encapsulation + ): + return True + else: + return False + def exportLiteral(self, outfile, level, name_='EncapsulationPrioritiesType'): + level += 1 + self.exportLiteralAttributes(outfile, level, [], name_) + if self.hasContent_(): + self.exportLiteralChildren(outfile, level, name_) + def exportLiteralAttributes(self, outfile, level, already_processed, name_): + pass + def exportLiteralChildren(self, outfile, level, name_): + showIndent(outfile, level) + outfile.write('encapsulation=[\n') + level += 1 + for encapsulation_ in self.encapsulation: + showIndent(outfile, level) + outfile.write('%s,\n' % quote_python(encapsulation_).encode(ExternalEncoding)) + level -= 1 + showIndent(outfile, level) + outfile.write('],\n') + def exportDict(self, name_='EncapsulationPrioritiesType'): + obj_json = json.dumps(self, default=lambda o: dict((k, v) for k, v in o.__dict__.iteritems())) + obj_dict = json.loads(obj_json) + return {name_: obj_dict} + def build(self, node): + self.buildAttributes(node, node.attrib, []) + for child in node: + nodeName_ = Tag_pattern_.match(child.tag).groups()[-1] + self.buildChildren(child, node, nodeName_) + def buildAttributes(self, node, attrs, already_processed): + pass + def buildChildren(self, child_, node, nodeName_, fromsubclass_=False): + if nodeName_ == 'encapsulation': + encapsulation_ = child_.text + encapsulation_ = self.gds_validate_string(encapsulation_, node, 'encapsulation') + self.encapsulation.append(encapsulation_) + self.validate_EncapsulationType(self.encapsulation) # validate type EncapsulationType +# end class EncapsulationPrioritiesType + + +class LinklocalServiceEntryType(GeneratedsSuper): + """ + LinklocalServiceEntryType class definition from :doc:`vnc_cfg.xsd` + """ + subclass = None + superclass = None + def __init__(self, linklocal_service_name=None, linklocal_service_ip=None, linklocal_service_port=None, ip_fabric_DNS_service_name=None, ip_fabric_service_port=None, ip_fabric_service_ip=None, **kwargs): + self.linklocal_service_name = linklocal_service_name + self.linklocal_service_ip = linklocal_service_ip + self.linklocal_service_port = linklocal_service_port + self.ip_fabric_DNS_service_name = ip_fabric_DNS_service_name + self.ip_fabric_service_port = ip_fabric_service_port + if (ip_fabric_service_ip is None) or (ip_fabric_service_ip == []): + self.ip_fabric_service_ip = [] + else: + self.ip_fabric_service_ip = ip_fabric_service_ip + def factory(*args_, **kwargs_): + if LinklocalServiceEntryType.subclass: + return LinklocalServiceEntryType.subclass(*args_, **kwargs_) + else: + return LinklocalServiceEntryType(*args_, **kwargs_) + factory = staticmethod(factory) + def get_linklocal_service_name(self): return self.linklocal_service_name + def set_linklocal_service_name(self, linklocal_service_name): self.linklocal_service_name = linklocal_service_name + def get_linklocal_service_ip(self): return self.linklocal_service_ip + def set_linklocal_service_ip(self, linklocal_service_ip): self.linklocal_service_ip = linklocal_service_ip + def validate_IpAddress(self, value): + # Validate type IpAddress, a restriction on xsd:string. + pass + def get_linklocal_service_port(self): return self.linklocal_service_port + def set_linklocal_service_port(self, linklocal_service_port): self.linklocal_service_port = linklocal_service_port + def get_ip_fabric_DNS_service_name(self): return self.ip_fabric_DNS_service_name + def set_ip_fabric_DNS_service_name(self, ip_fabric_DNS_service_name): self.ip_fabric_DNS_service_name = ip_fabric_DNS_service_name + def get_ip_fabric_service_port(self): return self.ip_fabric_service_port + def set_ip_fabric_service_port(self, ip_fabric_service_port): self.ip_fabric_service_port = ip_fabric_service_port + def get_ip_fabric_service_ip(self): return self.ip_fabric_service_ip + def set_ip_fabric_service_ip(self, ip_fabric_service_ip): self.ip_fabric_service_ip = ip_fabric_service_ip + def add_ip_fabric_service_ip(self, value): self.ip_fabric_service_ip.append(value) + def insert_ip_fabric_service_ip(self, index, value): self.ip_fabric_service_ip[index] = value + def delete_ip_fabric_service_ip(self, value): self.ip_fabric_service_ip.remove(value) + def __eq__(self, other): + if isinstance(other, self.__class__): + return (self.linklocal_service_name == other.linklocal_service_name and + self.linklocal_service_ip == other.linklocal_service_ip and + self.linklocal_service_port == other.linklocal_service_port and + self.ip_fabric_DNS_service_name == other.ip_fabric_DNS_service_name and + self.ip_fabric_service_port == other.ip_fabric_service_port and + self.ip_fabric_service_ip == other.ip_fabric_service_ip) + return NotImplemented + def __ne__(self, other): + if isinstance(other, self.__class__): + return not self.__eq__(other) + return NotImplemented + + @classmethod + def populate (cls, *a, **kwa): + obj = cls (*a, **kwa) + obj.set_linklocal_service_name (obj.populate_string ("linklocal_service_name")) + obj.set_linklocal_service_ip (obj.populate_string ("linklocal_service_ip")) + obj.set_linklocal_service_port (obj.populate_integer ("linklocal_service_port")) + obj.set_ip_fabric_DNS_service_name (obj.populate_string ("ip_fabric_DNS_service_name")) + obj.set_ip_fabric_service_port (obj.populate_integer ("ip_fabric_service_port")) + obj.set_ip_fabric_service_ip ([obj.populate_string ("ip_fabric_service_ip")]) + return obj + def export(self, outfile, level=1, namespace_='', name_='LinklocalServiceEntryType', namespacedef_='', pretty_print=True): + if pretty_print: + eol_ = '\n' + else: + eol_ = '' + showIndent(outfile, level, pretty_print) + outfile.write('<%s%s%s' % (namespace_, name_, namespacedef_ and ' ' + namespacedef_ or '', )) + already_processed = [] + self.exportAttributes(outfile, level, already_processed, namespace_, name_='LinklocalServiceEntryType') + if self.hasContent_(): + outfile.write('>%s' % (eol_, )) + self.exportChildren(outfile, level + 1, namespace_, name_, pretty_print=pretty_print) + showIndent(outfile, level, pretty_print) + outfile.write('</%s%s>%s' % (namespace_, name_, eol_)) + else: + outfile.write('/>%s' % (eol_, )) + def exportAttributes(self, outfile, level, already_processed, namespace_='', name_='LinklocalServiceEntryType'): + pass + def exportChildren(self, outfile, level, namespace_='', name_='LinklocalServiceEntryType', fromsubclass_=False, pretty_print=True): + if pretty_print: + eol_ = '\n' + else: + eol_ = '' + if self.linklocal_service_name is not None: + showIndent(outfile, level, pretty_print) + outfile.write('<%slinklocal-service-name>%s</%slinklocal-service-name>%s' % (namespace_, self.gds_format_string(quote_xml(self.linklocal_service_name).encode(ExternalEncoding), input_name='linklocal-service-name'), namespace_, eol_)) + if self.linklocal_service_ip is not None: + showIndent(outfile, level, pretty_print) + outfile.write('<%slinklocal-service-ip>%s</%slinklocal-service-ip>%s' % (namespace_, self.gds_format_string(quote_xml(self.linklocal_service_ip).encode(ExternalEncoding), input_name='linklocal-service-ip'), namespace_, eol_)) + if self.linklocal_service_port is not None: + showIndent(outfile, level, pretty_print) + outfile.write('<%slinklocal-service-port>%s</%slinklocal-service-port>%s' % (namespace_, self.gds_format_integer(self.linklocal_service_port, input_name='linklocal-service-port'), namespace_, eol_)) + if self.ip_fabric_DNS_service_name is not None: + showIndent(outfile, level, pretty_print) + outfile.write('<%sip-fabric-DNS-service-name>%s</%sip-fabric-DNS-service-name>%s' % (namespace_, self.gds_format_string(quote_xml(self.ip_fabric_DNS_service_name).encode(ExternalEncoding), input_name='ip-fabric-DNS-service-name'), namespace_, eol_)) + if self.ip_fabric_service_port is not None: + showIndent(outfile, level, pretty_print) + outfile.write('<%sip-fabric-service-port>%s</%sip-fabric-service-port>%s' % (namespace_, self.gds_format_integer(self.ip_fabric_service_port, input_name='ip-fabric-service-port'), namespace_, eol_)) + for ip_fabric_service_ip_ in self.ip_fabric_service_ip: + showIndent(outfile, level, pretty_print) + outfile.write('<%sip-fabric-service-ip>%s</%sip-fabric-service-ip>%s' % (namespace_, self.gds_format_string(quote_xml(ip_fabric_service_ip_).encode(ExternalEncoding), input_name='ip-fabric-service-ip'), namespace_, eol_)) + def hasContent_(self): + if ( + self.linklocal_service_name is not None or + self.linklocal_service_ip is not None or + self.linklocal_service_port is not None or + self.ip_fabric_DNS_service_name is not None or + self.ip_fabric_service_port is not None or + self.ip_fabric_service_ip + ): + return True + else: + return False + def exportLiteral(self, outfile, level, name_='LinklocalServiceEntryType'): + level += 1 + self.exportLiteralAttributes(outfile, level, [], name_) + if self.hasContent_(): + self.exportLiteralChildren(outfile, level, name_) + def exportLiteralAttributes(self, outfile, level, already_processed, name_): + pass + def exportLiteralChildren(self, outfile, level, name_): + if self.linklocal_service_name is not None: + showIndent(outfile, level) + outfile.write('linklocal_service_name=%s,\n' % quote_python(self.linklocal_service_name).encode(ExternalEncoding)) + if self.linklocal_service_ip is not None: + showIndent(outfile, level) + outfile.write('linklocal_service_ip=%s,\n' % quote_python(self.linklocal_service_ip).encode(ExternalEncoding)) + if self.linklocal_service_port is not None: + showIndent(outfile, level) + outfile.write('linklocal_service_port=%d,\n' % self.linklocal_service_port) + if self.ip_fabric_DNS_service_name is not None: + showIndent(outfile, level) + outfile.write('ip_fabric_DNS_service_name=%s,\n' % quote_python(self.ip_fabric_DNS_service_name).encode(ExternalEncoding)) + if self.ip_fabric_service_port is not None: + showIndent(outfile, level) + outfile.write('ip_fabric_service_port=%d,\n' % self.ip_fabric_service_port) + showIndent(outfile, level) + outfile.write('ip_fabric_service_ip=[\n') + level += 1 + for ip_fabric_service_ip_ in self.ip_fabric_service_ip: + showIndent(outfile, level) + outfile.write('%s,\n' % quote_python(ip_fabric_service_ip_).encode(ExternalEncoding)) + level -= 1 + showIndent(outfile, level) + outfile.write('],\n') + def exportDict(self, name_='LinklocalServiceEntryType'): + obj_json = json.dumps(self, default=lambda o: dict((k, v) for k, v in o.__dict__.iteritems())) + obj_dict = json.loads(obj_json) + return {name_: obj_dict} + def build(self, node): + self.buildAttributes(node, node.attrib, []) + for child in node: + nodeName_ = Tag_pattern_.match(child.tag).groups()[-1] + self.buildChildren(child, node, nodeName_) + def buildAttributes(self, node, attrs, already_processed): + pass + def buildChildren(self, child_, node, nodeName_, fromsubclass_=False): + if nodeName_ == 'linklocal-service-name': + linklocal_service_name_ = child_.text + linklocal_service_name_ = self.gds_validate_string(linklocal_service_name_, node, 'linklocal_service_name') + self.linklocal_service_name = linklocal_service_name_ + elif nodeName_ == 'linklocal-service-ip': + linklocal_service_ip_ = child_.text + linklocal_service_ip_ = self.gds_validate_string(linklocal_service_ip_, node, 'linklocal_service_ip') + self.linklocal_service_ip = linklocal_service_ip_ + self.validate_IpAddress(self.linklocal_service_ip) # validate type IpAddress + elif nodeName_ == 'linklocal-service-port': + sval_ = child_.text + try: + ival_ = int(sval_) + except (TypeError, ValueError), exp: + raise_parse_error(child_, 'requires integer: %s' % exp) + ival_ = self.gds_validate_integer(ival_, node, 'linklocal_service_port') + self.linklocal_service_port = ival_ + elif nodeName_ == 'ip-fabric-DNS-service-name': + ip_fabric_DNS_service_name_ = child_.text + ip_fabric_DNS_service_name_ = self.gds_validate_string(ip_fabric_DNS_service_name_, node, 'ip_fabric_DNS_service_name') + self.ip_fabric_DNS_service_name = ip_fabric_DNS_service_name_ + elif nodeName_ == 'ip-fabric-service-port': + sval_ = child_.text + try: + ival_ = int(sval_) + except (TypeError, ValueError), exp: + raise_parse_error(child_, 'requires integer: %s' % exp) + ival_ = self.gds_validate_integer(ival_, node, 'ip_fabric_service_port') + self.ip_fabric_service_port = ival_ + elif nodeName_ == 'ip-fabric-service-ip': + ip_fabric_service_ip_ = child_.text + ip_fabric_service_ip_ = self.gds_validate_string(ip_fabric_service_ip_, node, 'ip_fabric_service_ip') + self.ip_fabric_service_ip.append(ip_fabric_service_ip_) + self.validate_IpAddress(self.ip_fabric_service_ip) # validate type IpAddress +# end class LinklocalServiceEntryType + + +class LinklocalServicesTypes(GeneratedsSuper): + """ + LinklocalServicesTypes class definition from :doc:`vnc_cfg.xsd` + """ + subclass = None + superclass = None + def __init__(self, linklocal_service_entry=None, **kwargs): + if (linklocal_service_entry is None) or (linklocal_service_entry == []): + self.linklocal_service_entry = [] + else: + if isinstance(linklocal_service_entry[0], dict): + objs = [LinklocalServiceEntryType(**elem) for elem in linklocal_service_entry] + self.linklocal_service_entry = objs + else: + self.linklocal_service_entry = linklocal_service_entry + def factory(*args_, **kwargs_): + if LinklocalServicesTypes.subclass: + return LinklocalServicesTypes.subclass(*args_, **kwargs_) + else: + return LinklocalServicesTypes(*args_, **kwargs_) + factory = staticmethod(factory) + def get_linklocal_service_entry(self): return self.linklocal_service_entry + def set_linklocal_service_entry(self, linklocal_service_entry): self.linklocal_service_entry = linklocal_service_entry + def add_linklocal_service_entry(self, value): self.linklocal_service_entry.append(value) + def insert_linklocal_service_entry(self, index, value): self.linklocal_service_entry[index] = value + def delete_linklocal_service_entry(self, value): self.linklocal_service_entry.remove(value) + def __eq__(self, other): + if isinstance(other, self.__class__): + return (self.linklocal_service_entry == other.linklocal_service_entry) + return NotImplemented + def __ne__(self, other): + if isinstance(other, self.__class__): + return not self.__eq__(other) + return NotImplemented + + @classmethod + def populate (cls, *a, **kwa): + obj = cls (*a, **kwa) + obj.set_linklocal_service_entry ([LinklocalServiceEntryType.populate ()]) + return obj + def export(self, outfile, level=1, namespace_='', name_='LinklocalServicesTypes', namespacedef_='', pretty_print=True): + if pretty_print: + eol_ = '\n' + else: + eol_ = '' + showIndent(outfile, level, pretty_print) + outfile.write('<%s%s%s' % (namespace_, name_, namespacedef_ and ' ' + namespacedef_ or '', )) + already_processed = [] + self.exportAttributes(outfile, level, already_processed, namespace_, name_='LinklocalServicesTypes') + if self.hasContent_(): + outfile.write('>%s' % (eol_, )) + self.exportChildren(outfile, level + 1, namespace_, name_, pretty_print=pretty_print) + showIndent(outfile, level, pretty_print) + outfile.write('</%s%s>%s' % (namespace_, name_, eol_)) + else: + outfile.write('/>%s' % (eol_, )) + def exportAttributes(self, outfile, level, already_processed, namespace_='', name_='LinklocalServicesTypes'): + pass + def exportChildren(self, outfile, level, namespace_='', name_='LinklocalServicesTypes', fromsubclass_=False, pretty_print=True): + if pretty_print: + eol_ = '\n' + else: + eol_ = '' + for linklocal_service_entry_ in self.linklocal_service_entry: + if isinstance(linklocal_service_entry_, dict): + linklocal_service_entry_ = LinklocalServiceEntryType(**linklocal_service_entry_) + linklocal_service_entry_.export(outfile, level, namespace_, name_='linklocal-service-entry', pretty_print=pretty_print) + def hasContent_(self): + if ( + self.linklocal_service_entry + ): + return True + else: + return False + def exportLiteral(self, outfile, level, name_='LinklocalServicesTypes'): + level += 1 + self.exportLiteralAttributes(outfile, level, [], name_) + if self.hasContent_(): + self.exportLiteralChildren(outfile, level, name_) + def exportLiteralAttributes(self, outfile, level, already_processed, name_): + pass + def exportLiteralChildren(self, outfile, level, name_): + showIndent(outfile, level) + outfile.write('linklocal_service_entry=[\n') + level += 1 + for linklocal_service_entry_ in self.linklocal_service_entry: + showIndent(outfile, level) + outfile.write('model_.LinklocalServiceEntryType(\n') + linklocal_service_entry_.exportLiteral(outfile, level, name_='LinklocalServiceEntryType') + showIndent(outfile, level) + outfile.write('),\n') + level -= 1 + showIndent(outfile, level) + outfile.write('],\n') + def exportDict(self, name_='LinklocalServicesTypes'): + obj_json = json.dumps(self, default=lambda o: dict((k, v) for k, v in o.__dict__.iteritems())) + obj_dict = json.loads(obj_json) + return {name_: obj_dict} + def build(self, node): + self.buildAttributes(node, node.attrib, []) + for child in node: + nodeName_ = Tag_pattern_.match(child.tag).groups()[-1] + self.buildChildren(child, node, nodeName_) + def buildAttributes(self, node, attrs, already_processed): + pass + def buildChildren(self, child_, node, nodeName_, fromsubclass_=False): + if nodeName_ == 'linklocal-service-entry': + obj_ = LinklocalServiceEntryType.factory() + obj_.build(child_) + self.linklocal_service_entry.append(obj_) +# end class LinklocalServicesTypes + + +class VirtualDnsType(GeneratedsSuper): + """ + VirtualDnsType class definition from :doc:`vnc_cfg.xsd` + """ + subclass = None + superclass = None + def __init__(self, domain_name=None, dynamic_records_from_client=None, record_order=None, default_ttl_seconds=None, next_virtual_DNS=None, floating_ip_record=None, **kwargs): + self.domain_name = domain_name + self.dynamic_records_from_client = dynamic_records_from_client + self.record_order = record_order + self.default_ttl_seconds = default_ttl_seconds + self.next_virtual_DNS = next_virtual_DNS + self.floating_ip_record = floating_ip_record + def factory(*args_, **kwargs_): + if VirtualDnsType.subclass: + return VirtualDnsType.subclass(*args_, **kwargs_) + else: + return VirtualDnsType(*args_, **kwargs_) + factory = staticmethod(factory) + def get_domain_name(self): return self.domain_name + def set_domain_name(self, domain_name): self.domain_name = domain_name + def get_dynamic_records_from_client(self): return self.dynamic_records_from_client + def set_dynamic_records_from_client(self, dynamic_records_from_client): self.dynamic_records_from_client = dynamic_records_from_client + def get_record_order(self): return self.record_order + def set_record_order(self, record_order): self.record_order = record_order + def validate_DnsRecordOrderType(self, value): + # Validate type DnsRecordOrderType, a restriction on xsd:string. + error = False + if isinstance(value, list): + error = set(value) - set([u'fixed', u'random', u'round-robin']) + else: + error = value not in [u'fixed', u'random', u'round-robin'] + if error: + raise ValueError("DnsRecordOrderType must be one of [u'fixed', u'random', u'round-robin']") + def get_default_ttl_seconds(self): return self.default_ttl_seconds + def set_default_ttl_seconds(self, default_ttl_seconds): self.default_ttl_seconds = default_ttl_seconds + def get_next_virtual_DNS(self): return self.next_virtual_DNS + def set_next_virtual_DNS(self, next_virtual_DNS): self.next_virtual_DNS = next_virtual_DNS + def get_floating_ip_record(self): return self.floating_ip_record + def set_floating_ip_record(self, floating_ip_record): self.floating_ip_record = floating_ip_record + def validate_FloatingIpDnsNotation(self, value): + # Validate type FloatingIpDnsNotation, a restriction on xsd:string. + error = False + if isinstance(value, list): + error = set(value) - set([u'dashed-ip', u'dashed-ip-tenant-name', u'vm-name', u'vm-name-tenant-name']) + else: + error = value not in [u'dashed-ip', u'dashed-ip-tenant-name', u'vm-name', u'vm-name-tenant-name'] + if error: + raise ValueError("FloatingIpDnsNotation must be one of [u'dashed-ip', u'dashed-ip-tenant-name', u'vm-name', u'vm-name-tenant-name']") + def __eq__(self, other): + if isinstance(other, self.__class__): + return (self.domain_name == other.domain_name and + self.dynamic_records_from_client == other.dynamic_records_from_client and + self.record_order == other.record_order and + self.default_ttl_seconds == other.default_ttl_seconds and + self.next_virtual_DNS == other.next_virtual_DNS and + self.floating_ip_record == other.floating_ip_record) + return NotImplemented + def __ne__(self, other): + if isinstance(other, self.__class__): + return not self.__eq__(other) + return NotImplemented + + @classmethod + def populate (cls, *a, **kwa): + obj = cls (*a, **kwa) + obj.set_domain_name (obj.populate_string ("domain_name")) + obj.set_dynamic_records_from_client (obj.populate_boolean ("dynamic_records_from_client")) + obj.set_record_order (obj.populate_string ("record_order")) + obj.set_default_ttl_seconds (obj.populate_integer ("default_ttl_seconds")) + obj.set_next_virtual_DNS (obj.populate_string ("next_virtual_DNS")) + obj.set_floating_ip_record (obj.populate_string ("floating_ip_record")) + return obj + def export(self, outfile, level=1, namespace_='', name_='VirtualDnsType', namespacedef_='', pretty_print=True): + if pretty_print: + eol_ = '\n' + else: + eol_ = '' + showIndent(outfile, level, pretty_print) + outfile.write('<%s%s%s' % (namespace_, name_, namespacedef_ and ' ' + namespacedef_ or '', )) + already_processed = [] + self.exportAttributes(outfile, level, already_processed, namespace_, name_='VirtualDnsType') + if self.hasContent_(): + outfile.write('>%s' % (eol_, )) + self.exportChildren(outfile, level + 1, namespace_, name_, pretty_print=pretty_print) + showIndent(outfile, level, pretty_print) + outfile.write('</%s%s>%s' % (namespace_, name_, eol_)) + else: + outfile.write('/>%s' % (eol_, )) + def exportAttributes(self, outfile, level, already_processed, namespace_='', name_='VirtualDnsType'): + pass + def exportChildren(self, outfile, level, namespace_='', name_='VirtualDnsType', fromsubclass_=False, pretty_print=True): + if pretty_print: + eol_ = '\n' + else: + eol_ = '' + if self.domain_name is not None: + showIndent(outfile, level, pretty_print) + outfile.write('<%sdomain-name>%s</%sdomain-name>%s' % (namespace_, self.gds_format_string(quote_xml(self.domain_name).encode(ExternalEncoding), input_name='domain-name'), namespace_, eol_)) + if self.dynamic_records_from_client is not None: + showIndent(outfile, level, pretty_print) + outfile.write('<%sdynamic-records-from-client>%s</%sdynamic-records-from-client>%s' % (namespace_, self.gds_format_boolean(self.gds_str_lower(str(self.dynamic_records_from_client)), input_name='dynamic-records-from-client'), namespace_, eol_)) + if self.record_order is not None: + showIndent(outfile, level, pretty_print) + outfile.write('<%srecord-order>%s</%srecord-order>%s' % (namespace_, self.gds_format_string(quote_xml(self.record_order).encode(ExternalEncoding), input_name='record-order'), namespace_, eol_)) + if self.default_ttl_seconds is not None: + showIndent(outfile, level, pretty_print) + outfile.write('<%sdefault-ttl-seconds>%s</%sdefault-ttl-seconds>%s' % (namespace_, self.gds_format_integer(self.default_ttl_seconds, input_name='default-ttl-seconds'), namespace_, eol_)) + if self.next_virtual_DNS is not None: + showIndent(outfile, level, pretty_print) + outfile.write('<%snext-virtual-DNS>%s</%snext-virtual-DNS>%s' % (namespace_, self.gds_format_string(quote_xml(self.next_virtual_DNS).encode(ExternalEncoding), input_name='next-virtual-DNS'), namespace_, eol_)) + if self.floating_ip_record is not None: + showIndent(outfile, level, pretty_print) + outfile.write('<%sfloating-ip-record>%s</%sfloating-ip-record>%s' % (namespace_, self.gds_format_string(quote_xml(self.floating_ip_record).encode(ExternalEncoding), input_name='floating-ip-record'), namespace_, eol_)) + def hasContent_(self): + if ( + self.domain_name is not None or + self.dynamic_records_from_client is not None or + self.record_order is not None or + self.default_ttl_seconds is not None or + self.next_virtual_DNS is not None or + self.floating_ip_record is not None + ): + return True + else: + return False + def exportLiteral(self, outfile, level, name_='VirtualDnsType'): + level += 1 + self.exportLiteralAttributes(outfile, level, [], name_) + if self.hasContent_(): + self.exportLiteralChildren(outfile, level, name_) + def exportLiteralAttributes(self, outfile, level, already_processed, name_): + pass + def exportLiteralChildren(self, outfile, level, name_): + if self.domain_name is not None: + showIndent(outfile, level) + outfile.write('domain_name=%s,\n' % quote_python(self.domain_name).encode(ExternalEncoding)) + if self.dynamic_records_from_client is not None: + showIndent(outfile, level) + outfile.write('dynamic_records_from_client=%s,\n' % self.dynamic_records_from_client) + if self.record_order is not None: + showIndent(outfile, level) + outfile.write('record_order=%s,\n' % quote_python(self.record_order).encode(ExternalEncoding)) + if self.default_ttl_seconds is not None: + showIndent(outfile, level) + outfile.write('default_ttl_seconds=%d,\n' % self.default_ttl_seconds) + if self.next_virtual_DNS is not None: + showIndent(outfile, level) + outfile.write('next_virtual_DNS=%s,\n' % quote_python(self.next_virtual_DNS).encode(ExternalEncoding)) + if self.floating_ip_record is not None: + showIndent(outfile, level) + outfile.write('floating_ip_record=%s,\n' % quote_python(self.floating_ip_record).encode(ExternalEncoding)) + def exportDict(self, name_='VirtualDnsType'): + obj_json = json.dumps(self, default=lambda o: dict((k, v) for k, v in o.__dict__.iteritems())) + obj_dict = json.loads(obj_json) + return {name_: obj_dict} + def build(self, node): + self.buildAttributes(node, node.attrib, []) + for child in node: + nodeName_ = Tag_pattern_.match(child.tag).groups()[-1] + self.buildChildren(child, node, nodeName_) + def buildAttributes(self, node, attrs, already_processed): + pass + def buildChildren(self, child_, node, nodeName_, fromsubclass_=False): + if nodeName_ == 'domain-name': + domain_name_ = child_.text + domain_name_ = self.gds_validate_string(domain_name_, node, 'domain_name') + self.domain_name = domain_name_ + elif nodeName_ == 'dynamic-records-from-client': + sval_ = child_.text + if sval_ in ('true', '1'): + ival_ = True + elif sval_ in ('false', '0'): + ival_ = False + else: + raise_parse_error(child_, 'requires boolean') + ival_ = self.gds_validate_boolean(ival_, node, 'dynamic_records_from_client') + self.dynamic_records_from_client = ival_ + elif nodeName_ == 'record-order': + record_order_ = child_.text + record_order_ = self.gds_validate_string(record_order_, node, 'record_order') + self.record_order = record_order_ + self.validate_DnsRecordOrderType(self.record_order) # validate type DnsRecordOrderType + elif nodeName_ == 'default-ttl-seconds': + sval_ = child_.text + try: + ival_ = int(sval_) + except (TypeError, ValueError), exp: + raise_parse_error(child_, 'requires integer: %s' % exp) + ival_ = self.gds_validate_integer(ival_, node, 'default_ttl_seconds') + self.default_ttl_seconds = ival_ + elif nodeName_ == 'next-virtual-DNS': + next_virtual_DNS_ = child_.text + next_virtual_DNS_ = self.gds_validate_string(next_virtual_DNS_, node, 'next_virtual_DNS') + self.next_virtual_DNS = next_virtual_DNS_ + elif nodeName_ == 'floating-ip-record': + floating_ip_record_ = child_.text + floating_ip_record_ = self.gds_validate_string(floating_ip_record_, node, 'floating_ip_record') + self.floating_ip_record = floating_ip_record_ + self.validate_FloatingIpDnsNotation(self.floating_ip_record) # validate type FloatingIpDnsNotation +# end class VirtualDnsType + + +class VirtualDnsRecordType(GeneratedsSuper): + """ + VirtualDnsRecordType class definition from :doc:`vnc_cfg.xsd` + """ + subclass = None + superclass = None + def __init__(self, record_name=None, record_type=None, record_class=None, record_data=None, record_ttl_seconds=None, record_mx_preference=None, **kwargs): + self.record_name = record_name + self.record_type = record_type + self.record_class = record_class + self.record_data = record_data + self.record_ttl_seconds = record_ttl_seconds + self.record_mx_preference = record_mx_preference + def factory(*args_, **kwargs_): + if VirtualDnsRecordType.subclass: + return VirtualDnsRecordType.subclass(*args_, **kwargs_) + else: + return VirtualDnsRecordType(*args_, **kwargs_) + factory = staticmethod(factory) + def get_record_name(self): return self.record_name + def set_record_name(self, record_name): self.record_name = record_name + def get_record_type(self): return self.record_type + def set_record_type(self, record_type): self.record_type = record_type + def validate_DnsRecordTypeType(self, value): + # Validate type DnsRecordTypeType, a restriction on xsd:string. + error = False + if isinstance(value, list): + error = set(value) - set([u'A', u'AAAA', u'CNAME', u'PTR', u'NS', u'MX']) + else: + error = value not in [u'A', u'AAAA', u'CNAME', u'PTR', u'NS', u'MX'] + if error: + raise ValueError("DnsRecordTypeType must be one of [u'A', u'AAAA', u'CNAME', u'PTR', u'NS', u'MX']") + def get_record_class(self): return self.record_class + def set_record_class(self, record_class): self.record_class = record_class + def validate_DnsRecordClassType(self, value): + # Validate type DnsRecordClassType, a restriction on xsd:string. + error = False + if isinstance(value, list): + error = set(value) - set([u'IN']) + else: + error = value not in [u'IN'] + if error: + raise ValueError("DnsRecordClassType must be one of [u'IN']") + def get_record_data(self): return self.record_data + def set_record_data(self, record_data): self.record_data = record_data + def get_record_ttl_seconds(self): return self.record_ttl_seconds + def set_record_ttl_seconds(self, record_ttl_seconds): self.record_ttl_seconds = record_ttl_seconds + def get_record_mx_preference(self): return self.record_mx_preference + def set_record_mx_preference(self, record_mx_preference): self.record_mx_preference = record_mx_preference + def __eq__(self, other): + if isinstance(other, self.__class__): + return (self.record_name == other.record_name and + self.record_type == other.record_type and + self.record_class == other.record_class and + self.record_data == other.record_data and + self.record_ttl_seconds == other.record_ttl_seconds and + self.record_mx_preference == other.record_mx_preference) + return NotImplemented + def __ne__(self, other): + if isinstance(other, self.__class__): + return not self.__eq__(other) + return NotImplemented + + @classmethod + def populate (cls, *a, **kwa): + obj = cls (*a, **kwa) + obj.set_record_name (obj.populate_string ("record_name")) + obj.set_record_type (obj.populate_string ("record_type")) + obj.set_record_class (obj.populate_string ("record_class")) + obj.set_record_data (obj.populate_string ("record_data")) + obj.set_record_ttl_seconds (obj.populate_integer ("record_ttl_seconds")) + obj.set_record_mx_preference (obj.populate_integer ("record_mx_preference")) + return obj + def export(self, outfile, level=1, namespace_='', name_='VirtualDnsRecordType', namespacedef_='', pretty_print=True): + if pretty_print: + eol_ = '\n' + else: + eol_ = '' + showIndent(outfile, level, pretty_print) + outfile.write('<%s%s%s' % (namespace_, name_, namespacedef_ and ' ' + namespacedef_ or '', )) + already_processed = [] + self.exportAttributes(outfile, level, already_processed, namespace_, name_='VirtualDnsRecordType') + if self.hasContent_(): + outfile.write('>%s' % (eol_, )) + self.exportChildren(outfile, level + 1, namespace_, name_, pretty_print=pretty_print) + showIndent(outfile, level, pretty_print) + outfile.write('</%s%s>%s' % (namespace_, name_, eol_)) + else: + outfile.write('/>%s' % (eol_, )) + def exportAttributes(self, outfile, level, already_processed, namespace_='', name_='VirtualDnsRecordType'): + pass + def exportChildren(self, outfile, level, namespace_='', name_='VirtualDnsRecordType', fromsubclass_=False, pretty_print=True): + if pretty_print: + eol_ = '\n' + else: + eol_ = '' + if self.record_name is not None: + showIndent(outfile, level, pretty_print) + outfile.write('<%srecord-name>%s</%srecord-name>%s' % (namespace_, self.gds_format_string(quote_xml(self.record_name).encode(ExternalEncoding), input_name='record-name'), namespace_, eol_)) + if self.record_type is not None: + showIndent(outfile, level, pretty_print) + outfile.write('<%srecord-type>%s</%srecord-type>%s' % (namespace_, self.gds_format_string(quote_xml(self.record_type).encode(ExternalEncoding), input_name='record-type'), namespace_, eol_)) + if self.record_class is not None: + showIndent(outfile, level, pretty_print) + outfile.write('<%srecord-class>%s</%srecord-class>%s' % (namespace_, self.gds_format_string(quote_xml(self.record_class).encode(ExternalEncoding), input_name='record-class'), namespace_, eol_)) + if self.record_data is not None: + showIndent(outfile, level, pretty_print) + outfile.write('<%srecord-data>%s</%srecord-data>%s' % (namespace_, self.gds_format_string(quote_xml(self.record_data).encode(ExternalEncoding), input_name='record-data'), namespace_, eol_)) + if self.record_ttl_seconds is not None: + showIndent(outfile, level, pretty_print) + outfile.write('<%srecord-ttl-seconds>%s</%srecord-ttl-seconds>%s' % (namespace_, self.gds_format_integer(self.record_ttl_seconds, input_name='record-ttl-seconds'), namespace_, eol_)) + if self.record_mx_preference is not None: + showIndent(outfile, level, pretty_print) + outfile.write('<%srecord-mx-preference>%s</%srecord-mx-preference>%s' % (namespace_, self.gds_format_integer(self.record_mx_preference, input_name='record-mx-preference'), namespace_, eol_)) + def hasContent_(self): + if ( + self.record_name is not None or + self.record_type is not None or + self.record_class is not None or + self.record_data is not None or + self.record_ttl_seconds is not None or + self.record_mx_preference is not None + ): + return True + else: + return False + def exportLiteral(self, outfile, level, name_='VirtualDnsRecordType'): + level += 1 + self.exportLiteralAttributes(outfile, level, [], name_) + if self.hasContent_(): + self.exportLiteralChildren(outfile, level, name_) + def exportLiteralAttributes(self, outfile, level, already_processed, name_): + pass + def exportLiteralChildren(self, outfile, level, name_): + if self.record_name is not None: + showIndent(outfile, level) + outfile.write('record_name=%s,\n' % quote_python(self.record_name).encode(ExternalEncoding)) + if self.record_type is not None: + showIndent(outfile, level) + outfile.write('record_type=%s,\n' % quote_python(self.record_type).encode(ExternalEncoding)) + if self.record_class is not None: + showIndent(outfile, level) + outfile.write('record_class=%s,\n' % quote_python(self.record_class).encode(ExternalEncoding)) + if self.record_data is not None: + showIndent(outfile, level) + outfile.write('record_data=%s,\n' % quote_python(self.record_data).encode(ExternalEncoding)) + if self.record_ttl_seconds is not None: + showIndent(outfile, level) + outfile.write('record_ttl_seconds=%d,\n' % self.record_ttl_seconds) + if self.record_mx_preference is not None: + showIndent(outfile, level) + outfile.write('record_mx_preference=%d,\n' % self.record_mx_preference) + def exportDict(self, name_='VirtualDnsRecordType'): + obj_json = json.dumps(self, default=lambda o: dict((k, v) for k, v in o.__dict__.iteritems())) + obj_dict = json.loads(obj_json) + return {name_: obj_dict} + def build(self, node): + self.buildAttributes(node, node.attrib, []) + for child in node: + nodeName_ = Tag_pattern_.match(child.tag).groups()[-1] + self.buildChildren(child, node, nodeName_) + def buildAttributes(self, node, attrs, already_processed): + pass + def buildChildren(self, child_, node, nodeName_, fromsubclass_=False): + if nodeName_ == 'record-name': + record_name_ = child_.text + record_name_ = self.gds_validate_string(record_name_, node, 'record_name') + self.record_name = record_name_ + elif nodeName_ == 'record-type': + record_type_ = child_.text + record_type_ = self.gds_validate_string(record_type_, node, 'record_type') + self.record_type = record_type_ + self.validate_DnsRecordTypeType(self.record_type) # validate type DnsRecordTypeType + elif nodeName_ == 'record-class': + record_class_ = child_.text + record_class_ = self.gds_validate_string(record_class_, node, 'record_class') + self.record_class = record_class_ + self.validate_DnsRecordClassType(self.record_class) # validate type DnsRecordClassType + elif nodeName_ == 'record-data': + record_data_ = child_.text + record_data_ = self.gds_validate_string(record_data_, node, 'record_data') + self.record_data = record_data_ + elif nodeName_ == 'record-ttl-seconds': + sval_ = child_.text + try: + ival_ = int(sval_) + except (TypeError, ValueError), exp: + raise_parse_error(child_, 'requires integer: %s' % exp) + ival_ = self.gds_validate_integer(ival_, node, 'record_ttl_seconds') + self.record_ttl_seconds = ival_ + elif nodeName_ == 'record-mx-preference': + sval_ = child_.text + try: + ival_ = int(sval_) + except (TypeError, ValueError), exp: + raise_parse_error(child_, 'requires integer: %s' % exp) + ival_ = self.gds_validate_integer(ival_, node, 'record_mx_preference') + self.record_mx_preference = ival_ +# end class VirtualDnsRecordType + + +class FloatingIpPoolType(GeneratedsSuper): + """ + FloatingIpPoolType class definition from :doc:`vnc_cfg.xsd` + """ + subclass = None + superclass = None + def __init__(self, subnet=None, **kwargs): + if (subnet is None) or (subnet == []): + self.subnet = [] + else: + if isinstance(subnet[0], dict): + objs = [SubnetType(**elem) for elem in subnet] + self.subnet = objs + else: + self.subnet = subnet + def factory(*args_, **kwargs_): + if FloatingIpPoolType.subclass: + return FloatingIpPoolType.subclass(*args_, **kwargs_) + else: + return FloatingIpPoolType(*args_, **kwargs_) + factory = staticmethod(factory) + def get_subnet(self): return self.subnet + def set_subnet(self, subnet): self.subnet = subnet + def add_subnet(self, value): self.subnet.append(value) + def insert_subnet(self, index, value): self.subnet[index] = value + def delete_subnet(self, value): self.subnet.remove(value) + def __eq__(self, other): + if isinstance(other, self.__class__): + return (self.subnet == other.subnet) + return NotImplemented + def __ne__(self, other): + if isinstance(other, self.__class__): + return not self.__eq__(other) + return NotImplemented + + @classmethod + def populate (cls, *a, **kwa): + obj = cls (*a, **kwa) + obj.set_subnet ([SubnetType.populate ()]) + return obj + def export(self, outfile, level=1, namespace_='', name_='FloatingIpPoolType', namespacedef_='', pretty_print=True): + if pretty_print: + eol_ = '\n' + else: + eol_ = '' + showIndent(outfile, level, pretty_print) + outfile.write('<%s%s%s' % (namespace_, name_, namespacedef_ and ' ' + namespacedef_ or '', )) + already_processed = [] + self.exportAttributes(outfile, level, already_processed, namespace_, name_='FloatingIpPoolType') + if self.hasContent_(): + outfile.write('>%s' % (eol_, )) + self.exportChildren(outfile, level + 1, namespace_, name_, pretty_print=pretty_print) + showIndent(outfile, level, pretty_print) + outfile.write('</%s%s>%s' % (namespace_, name_, eol_)) + else: + outfile.write('/>%s' % (eol_, )) + def exportAttributes(self, outfile, level, already_processed, namespace_='', name_='FloatingIpPoolType'): + pass + def exportChildren(self, outfile, level, namespace_='', name_='FloatingIpPoolType', fromsubclass_=False, pretty_print=True): + if pretty_print: + eol_ = '\n' + else: + eol_ = '' + for subnet_ in self.subnet: + if isinstance(subnet_, dict): + subnet_ = SubnetType(**subnet_) + subnet_.export(outfile, level, namespace_, name_='subnet', pretty_print=pretty_print) + def hasContent_(self): + if ( + self.subnet + ): + return True + else: + return False + def exportLiteral(self, outfile, level, name_='FloatingIpPoolType'): + level += 1 + self.exportLiteralAttributes(outfile, level, [], name_) + if self.hasContent_(): + self.exportLiteralChildren(outfile, level, name_) + def exportLiteralAttributes(self, outfile, level, already_processed, name_): + pass + def exportLiteralChildren(self, outfile, level, name_): + showIndent(outfile, level) + outfile.write('subnet=[\n') + level += 1 + for subnet_ in self.subnet: + showIndent(outfile, level) + outfile.write('model_.SubnetType(\n') + subnet_.exportLiteral(outfile, level, name_='SubnetType') + showIndent(outfile, level) + outfile.write('),\n') + level -= 1 + showIndent(outfile, level) + outfile.write('],\n') + def exportDict(self, name_='FloatingIpPoolType'): + obj_json = json.dumps(self, default=lambda o: dict((k, v) for k, v in o.__dict__.iteritems())) + obj_dict = json.loads(obj_json) + return {name_: obj_dict} + def build(self, node): + self.buildAttributes(node, node.attrib, []) + for child in node: + nodeName_ = Tag_pattern_.match(child.tag).groups()[-1] + self.buildChildren(child, node, nodeName_) + def buildAttributes(self, node, attrs, already_processed): + pass + def buildChildren(self, child_, node, nodeName_, fromsubclass_=False): + if nodeName_ == 'subnet': + obj_ = SubnetType.factory() + obj_.build(child_) + self.subnet.append(obj_) +# end class FloatingIpPoolType + + +class SubnetListType(GeneratedsSuper): + """ + SubnetListType class definition from :doc:`vnc_cfg.xsd` + """ + subclass = None + superclass = None + def __init__(self, subnet=None, **kwargs): + if (subnet is None) or (subnet == []): + self.subnet = [] + else: + if isinstance(subnet[0], dict): + objs = [SubnetType(**elem) for elem in subnet] + self.subnet = objs + else: + self.subnet = subnet + def factory(*args_, **kwargs_): + if SubnetListType.subclass: + return SubnetListType.subclass(*args_, **kwargs_) + else: + return SubnetListType(*args_, **kwargs_) + factory = staticmethod(factory) + def get_subnet(self): return self.subnet + def set_subnet(self, subnet): self.subnet = subnet + def add_subnet(self, value): self.subnet.append(value) + def insert_subnet(self, index, value): self.subnet[index] = value + def delete_subnet(self, value): self.subnet.remove(value) + def __eq__(self, other): + if isinstance(other, self.__class__): + return (self.subnet == other.subnet) + return NotImplemented + def __ne__(self, other): + if isinstance(other, self.__class__): + return not self.__eq__(other) + return NotImplemented + + @classmethod + def populate (cls, *a, **kwa): + obj = cls (*a, **kwa) + obj.set_subnet ([SubnetType.populate ()]) + return obj + def export(self, outfile, level=1, namespace_='', name_='SubnetListType', namespacedef_='', pretty_print=True): + if pretty_print: + eol_ = '\n' + else: + eol_ = '' + showIndent(outfile, level, pretty_print) + outfile.write('<%s%s%s' % (namespace_, name_, namespacedef_ and ' ' + namespacedef_ or '', )) + already_processed = [] + self.exportAttributes(outfile, level, already_processed, namespace_, name_='SubnetListType') + if self.hasContent_(): + outfile.write('>%s' % (eol_, )) + self.exportChildren(outfile, level + 1, namespace_, name_, pretty_print=pretty_print) + showIndent(outfile, level, pretty_print) + outfile.write('</%s%s>%s' % (namespace_, name_, eol_)) + else: + outfile.write('/>%s' % (eol_, )) + def exportAttributes(self, outfile, level, already_processed, namespace_='', name_='SubnetListType'): + pass + def exportChildren(self, outfile, level, namespace_='', name_='SubnetListType', fromsubclass_=False, pretty_print=True): + if pretty_print: + eol_ = '\n' + else: + eol_ = '' + for subnet_ in self.subnet: + if isinstance(subnet_, dict): + subnet_ = SubnetType(**subnet_) + subnet_.export(outfile, level, namespace_, name_='subnet', pretty_print=pretty_print) + def hasContent_(self): + if ( + self.subnet + ): + return True + else: + return False + def exportLiteral(self, outfile, level, name_='SubnetListType'): + level += 1 + self.exportLiteralAttributes(outfile, level, [], name_) + if self.hasContent_(): + self.exportLiteralChildren(outfile, level, name_) + def exportLiteralAttributes(self, outfile, level, already_processed, name_): + pass + def exportLiteralChildren(self, outfile, level, name_): + showIndent(outfile, level) + outfile.write('subnet=[\n') + level += 1 + for subnet_ in self.subnet: + showIndent(outfile, level) + outfile.write('model_.SubnetType(\n') + subnet_.exportLiteral(outfile, level, name_='SubnetType') + showIndent(outfile, level) + outfile.write('),\n') + level -= 1 + showIndent(outfile, level) + outfile.write('],\n') + def exportDict(self, name_='SubnetListType'): + obj_json = json.dumps(self, default=lambda o: dict((k, v) for k, v in o.__dict__.iteritems())) + obj_dict = json.loads(obj_json) + return {name_: obj_dict} + def build(self, node): + self.buildAttributes(node, node.attrib, []) + for child in node: + nodeName_ = Tag_pattern_.match(child.tag).groups()[-1] + self.buildChildren(child, node, nodeName_) + def buildAttributes(self, node, attrs, already_processed): + pass + def buildChildren(self, child_, node, nodeName_, fromsubclass_=False): + if nodeName_ == 'subnet': + obj_ = SubnetType.factory() + obj_.build(child_) + self.subnet.append(obj_) +# end class SubnetListType + + +class IpamSubnetType(GeneratedsSuper): + """ + IpamSubnetType class definition from :doc:`vnc_cfg.xsd` + """ + subclass = None + superclass = None + def __init__(self, subnet=None, default_gateway=None, dns_server_address=None, subnet_uuid=None, enable_dhcp=True, dns_nameservers=None, allocation_pools=None, addr_from_start=None, dhcp_option_list=None, host_routes=None, subnet_name=None, **kwargs): + if isinstance(subnet, dict): + obj = SubnetType(**subnet) + self.subnet = obj + else: + self.subnet = subnet + self.default_gateway = default_gateway + self.dns_server_address = dns_server_address + self.subnet_uuid = subnet_uuid + self.enable_dhcp = enable_dhcp + if (dns_nameservers is None) or (dns_nameservers == []): + self.dns_nameservers = [] + else: + self.dns_nameservers = dns_nameservers + if (allocation_pools is None) or (allocation_pools == []): + self.allocation_pools = [] + else: + if isinstance(allocation_pools[0], dict): + objs = [AllocationPoolType(**elem) for elem in allocation_pools] + self.allocation_pools = objs + else: + self.allocation_pools = allocation_pools + self.addr_from_start = addr_from_start + if isinstance(dhcp_option_list, dict): + obj = DhcpOptionsListType(**dhcp_option_list) + self.dhcp_option_list = obj + else: + self.dhcp_option_list = dhcp_option_list + if isinstance(host_routes, dict): + obj = RouteTableType(**host_routes) + self.host_routes = obj + else: + self.host_routes = host_routes + self.subnet_name = subnet_name + def factory(*args_, **kwargs_): + if IpamSubnetType.subclass: + return IpamSubnetType.subclass(*args_, **kwargs_) + else: + return IpamSubnetType(*args_, **kwargs_) + factory = staticmethod(factory) + def get_subnet(self): return self.subnet + def set_subnet(self, subnet): self.subnet = subnet + def get_default_gateway(self): return self.default_gateway + def set_default_gateway(self, default_gateway): self.default_gateway = default_gateway + def validate_IpAddressType(self, value): + # Validate type IpAddressType, a restriction on xsd:string. + pass + def get_dns_server_address(self): return self.dns_server_address + def set_dns_server_address(self, dns_server_address): self.dns_server_address = dns_server_address + def get_subnet_uuid(self): return self.subnet_uuid + def set_subnet_uuid(self, subnet_uuid): self.subnet_uuid = subnet_uuid + def get_enable_dhcp(self): return self.enable_dhcp + def set_enable_dhcp(self, enable_dhcp): self.enable_dhcp = enable_dhcp + def get_dns_nameservers(self): return self.dns_nameservers + def set_dns_nameservers(self, dns_nameservers): self.dns_nameservers = dns_nameservers + def add_dns_nameservers(self, value): self.dns_nameservers.append(value) + def insert_dns_nameservers(self, index, value): self.dns_nameservers[index] = value + def delete_dns_nameservers(self, value): self.dns_nameservers.remove(value) + def get_allocation_pools(self): return self.allocation_pools + def set_allocation_pools(self, allocation_pools): self.allocation_pools = allocation_pools + def add_allocation_pools(self, value): self.allocation_pools.append(value) + def insert_allocation_pools(self, index, value): self.allocation_pools[index] = value + def delete_allocation_pools(self, value): self.allocation_pools.remove(value) + def get_addr_from_start(self): return self.addr_from_start + def set_addr_from_start(self, addr_from_start): self.addr_from_start = addr_from_start + def get_dhcp_option_list(self): return self.dhcp_option_list + def set_dhcp_option_list(self, dhcp_option_list): self.dhcp_option_list = dhcp_option_list + def get_host_routes(self): return self.host_routes + def set_host_routes(self, host_routes): self.host_routes = host_routes + def get_subnet_name(self): return self.subnet_name + def set_subnet_name(self, subnet_name): self.subnet_name = subnet_name + def __eq__(self, other): + if isinstance(other, self.__class__): + return (self.subnet == other.subnet and + self.default_gateway == other.default_gateway and + self.dns_server_address == other.dns_server_address and + self.subnet_uuid == other.subnet_uuid and + self.enable_dhcp == other.enable_dhcp and + self.dns_nameservers == other.dns_nameservers and + self.allocation_pools == other.allocation_pools and + self.addr_from_start == other.addr_from_start and + self.dhcp_option_list == other.dhcp_option_list and + self.host_routes == other.host_routes and + self.subnet_name == other.subnet_name) + return NotImplemented + def __ne__(self, other): + if isinstance(other, self.__class__): + return not self.__eq__(other) + return NotImplemented + + @classmethod + def populate (cls, *a, **kwa): + obj = cls (*a, **kwa) + obj.set_subnet (SubnetType.populate ()) + obj.set_default_gateway (obj.populate_string ("default_gateway")) + obj.set_dns_server_address (obj.populate_string ("dns_server_address")) + obj.set_subnet_uuid (obj.populate_string ("subnet_uuid")) + obj.set_enable_dhcp (obj.populate_boolean ("enable_dhcp")) + obj.set_dns_nameservers ([obj.populate_string ("dns_nameservers")]) + obj.set_allocation_pools ([AllocationPoolType.populate ()]) + obj.set_addr_from_start (obj.populate_boolean ("addr_from_start")) + obj.set_dhcp_option_list (DhcpOptionsListType.populate ()) + obj.set_host_routes (RouteTableType.populate ()) + obj.set_subnet_name (obj.populate_string ("subnet_name")) + return obj + def export(self, outfile, level=1, namespace_='', name_='IpamSubnetType', namespacedef_='', pretty_print=True): + if pretty_print: + eol_ = '\n' + else: + eol_ = '' + showIndent(outfile, level, pretty_print) + outfile.write('<%s%s%s' % (namespace_, name_, namespacedef_ and ' ' + namespacedef_ or '', )) + already_processed = [] + self.exportAttributes(outfile, level, already_processed, namespace_, name_='IpamSubnetType') + if self.hasContent_(): + outfile.write('>%s' % (eol_, )) + self.exportChildren(outfile, level + 1, namespace_, name_, pretty_print=pretty_print) + showIndent(outfile, level, pretty_print) + outfile.write('</%s%s>%s' % (namespace_, name_, eol_)) + else: + outfile.write('/>%s' % (eol_, )) + def exportAttributes(self, outfile, level, already_processed, namespace_='', name_='IpamSubnetType'): + pass + def exportChildren(self, outfile, level, namespace_='', name_='IpamSubnetType', fromsubclass_=False, pretty_print=True): + if pretty_print: + eol_ = '\n' + else: + eol_ = '' + if self.subnet is not None: + self.subnet.export(outfile, level, namespace_, name_='subnet', pretty_print=pretty_print) + if self.default_gateway is not None: + showIndent(outfile, level, pretty_print) + outfile.write('<%sdefault-gateway>%s</%sdefault-gateway>%s' % (namespace_, self.gds_format_string(quote_xml(self.default_gateway).encode(ExternalEncoding), input_name='default-gateway'), namespace_, eol_)) + if self.dns_server_address is not None: + showIndent(outfile, level, pretty_print) + outfile.write('<%sdns-server-address>%s</%sdns-server-address>%s' % (namespace_, self.gds_format_string(quote_xml(self.dns_server_address).encode(ExternalEncoding), input_name='dns-server-address'), namespace_, eol_)) + if self.subnet_uuid is not None: + showIndent(outfile, level, pretty_print) + outfile.write('<%ssubnet-uuid>%s</%ssubnet-uuid>%s' % (namespace_, self.gds_format_string(quote_xml(self.subnet_uuid).encode(ExternalEncoding), input_name='subnet-uuid'), namespace_, eol_)) + if self.enable_dhcp is not None: + showIndent(outfile, level, pretty_print) + outfile.write('<%senable-dhcp>%s</%senable-dhcp>%s' % (namespace_, self.gds_format_boolean(self.gds_str_lower(str(self.enable_dhcp)), input_name='enable-dhcp'), namespace_, eol_)) + for dns_nameservers_ in self.dns_nameservers: + showIndent(outfile, level, pretty_print) + outfile.write('<%sdns-nameservers>%s</%sdns-nameservers>%s' % (namespace_, self.gds_format_string(quote_xml(dns_nameservers_).encode(ExternalEncoding), input_name='dns-nameservers'), namespace_, eol_)) + for allocation_pools_ in self.allocation_pools: + if isinstance(allocation_pools_, dict): + allocation_pools_ = AllocationPoolType(**allocation_pools_) + allocation_pools_.export(outfile, level, namespace_, name_='allocation-pools', pretty_print=pretty_print) + if self.addr_from_start is not None: + showIndent(outfile, level, pretty_print) + outfile.write('<%saddr_from_start>%s</%saddr_from_start>%s' % (namespace_, self.gds_format_boolean(self.gds_str_lower(str(self.addr_from_start)), input_name='addr_from_start'), namespace_, eol_)) + if self.dhcp_option_list is not None: + self.dhcp_option_list.export(outfile, level, namespace_, name_='dhcp-option-list', pretty_print=pretty_print) + if self.host_routes is not None: + self.host_routes.export(outfile, level, namespace_, name_='host-routes', pretty_print=pretty_print) + if self.subnet_name is not None: + showIndent(outfile, level, pretty_print) + outfile.write('<%ssubnet-name>%s</%ssubnet-name>%s' % (namespace_, self.gds_format_string(quote_xml(self.subnet_name).encode(ExternalEncoding), input_name='subnet-name'), namespace_, eol_)) + def hasContent_(self): + if ( + self.subnet is not None or + self.default_gateway is not None or + self.dns_server_address is not None or + self.subnet_uuid is not None or + self.enable_dhcp is not None or + self.dns_nameservers or + self.allocation_pools or + self.addr_from_start is not None or + self.dhcp_option_list is not None or + self.host_routes is not None or + self.subnet_name is not None + ): + return True + else: + return False + def exportLiteral(self, outfile, level, name_='IpamSubnetType'): + level += 1 + self.exportLiteralAttributes(outfile, level, [], name_) + if self.hasContent_(): + self.exportLiteralChildren(outfile, level, name_) + def exportLiteralAttributes(self, outfile, level, already_processed, name_): + pass + def exportLiteralChildren(self, outfile, level, name_): + if self.subnet is not None: + showIndent(outfile, level) + outfile.write('subnet=model_.SubnetType(\n') + self.subnet.exportLiteral(outfile, level, name_='subnet') + showIndent(outfile, level) + outfile.write('),\n') + if self.default_gateway is not None: + showIndent(outfile, level) + outfile.write('default_gateway=%s,\n' % quote_python(self.default_gateway).encode(ExternalEncoding)) + if self.dns_server_address is not None: + showIndent(outfile, level) + outfile.write('dns_server_address=%s,\n' % quote_python(self.dns_server_address).encode(ExternalEncoding)) + if self.subnet_uuid is not None: + showIndent(outfile, level) + outfile.write('subnet_uuid=%s,\n' % quote_python(self.subnet_uuid).encode(ExternalEncoding)) + if self.enable_dhcp is not None: + showIndent(outfile, level) + outfile.write('enable_dhcp=%s,\n' % self.enable_dhcp) + showIndent(outfile, level) + outfile.write('dns_nameservers=[\n') + level += 1 + for dns_nameservers_ in self.dns_nameservers: + showIndent(outfile, level) + outfile.write('%s,\n' % quote_python(dns_nameservers_).encode(ExternalEncoding)) + level -= 1 + showIndent(outfile, level) + outfile.write('],\n') + showIndent(outfile, level) + outfile.write('allocation_pools=[\n') + level += 1 + for allocation_pools_ in self.allocation_pools: + showIndent(outfile, level) + outfile.write('model_.AllocationPoolType(\n') + allocation_pools_.exportLiteral(outfile, level, name_='AllocationPoolType') + showIndent(outfile, level) + outfile.write('),\n') + level -= 1 + showIndent(outfile, level) + outfile.write('],\n') + if self.addr_from_start is not None: + showIndent(outfile, level) + outfile.write('addr_from_start=%s,\n' % self.addr_from_start) + if self.dhcp_option_list is not None: + showIndent(outfile, level) + outfile.write('dhcp_option_list=model_.DhcpOptionsListType(\n') + self.dhcp_option_list.exportLiteral(outfile, level, name_='dhcp_option_list') + showIndent(outfile, level) + outfile.write('),\n') + if self.host_routes is not None: + showIndent(outfile, level) + outfile.write('host_routes=model_.RouteTableType(\n') + self.host_routes.exportLiteral(outfile, level, name_='host_routes') + showIndent(outfile, level) + outfile.write('),\n') + if self.subnet_name is not None: + showIndent(outfile, level) + outfile.write('subnet_name=%s,\n' % quote_python(self.subnet_name).encode(ExternalEncoding)) + def exportDict(self, name_='IpamSubnetType'): + obj_json = json.dumps(self, default=lambda o: dict((k, v) for k, v in o.__dict__.iteritems())) + obj_dict = json.loads(obj_json) + return {name_: obj_dict} + def build(self, node): + self.buildAttributes(node, node.attrib, []) + for child in node: + nodeName_ = Tag_pattern_.match(child.tag).groups()[-1] + self.buildChildren(child, node, nodeName_) + def buildAttributes(self, node, attrs, already_processed): + pass + def buildChildren(self, child_, node, nodeName_, fromsubclass_=False): + if nodeName_ == 'subnet': + obj_ = SubnetType.factory() + obj_.build(child_) + self.set_subnet(obj_) + elif nodeName_ == 'default-gateway': + default_gateway_ = child_.text + default_gateway_ = self.gds_validate_string(default_gateway_, node, 'default_gateway') + self.default_gateway = default_gateway_ + self.validate_IpAddressType(self.default_gateway) # validate type IpAddressType + elif nodeName_ == 'dns-server-address': + dns_server_address_ = child_.text + dns_server_address_ = self.gds_validate_string(dns_server_address_, node, 'dns_server_address') + self.dns_server_address = dns_server_address_ + self.validate_IpAddressType(self.dns_server_address) # validate type IpAddressType + elif nodeName_ == 'subnet-uuid': + subnet_uuid_ = child_.text + subnet_uuid_ = self.gds_validate_string(subnet_uuid_, node, 'subnet_uuid') + self.subnet_uuid = subnet_uuid_ + elif nodeName_ == 'enable-dhcp': + sval_ = child_.text + if sval_ in ('true', '1'): + ival_ = True + elif sval_ in ('false', '0'): + ival_ = False + else: + raise_parse_error(child_, 'requires boolean') + ival_ = self.gds_validate_boolean(ival_, node, 'enable_dhcp') + self.enable_dhcp = ival_ + elif nodeName_ == 'dns-nameservers': + dns_nameservers_ = child_.text + dns_nameservers_ = self.gds_validate_string(dns_nameservers_, node, 'dns_nameservers') + self.dns_nameservers.append(dns_nameservers_) + elif nodeName_ == 'allocation-pools': + obj_ = AllocationPoolType.factory() + obj_.build(child_) + self.allocation_pools.append(obj_) + elif nodeName_ == 'addr_from_start': + sval_ = child_.text + if sval_ in ('true', '1'): + ival_ = True + elif sval_ in ('false', '0'): + ival_ = False + else: + raise_parse_error(child_, 'requires boolean') + ival_ = self.gds_validate_boolean(ival_, node, 'addr_from_start') + self.addr_from_start = ival_ + elif nodeName_ == 'dhcp-option-list': + obj_ = DhcpOptionsListType.factory() + obj_.build(child_) + self.set_dhcp_option_list(obj_) + elif nodeName_ == 'host-routes': + obj_ = RouteTableType.factory() + obj_.build(child_) + self.set_host_routes(obj_) + elif nodeName_ == 'subnet-name': + subnet_name_ = child_.text + subnet_name_ = self.gds_validate_string(subnet_name_, node, 'subnet_name') + self.subnet_name = subnet_name_ +# end class IpamSubnetType + + +class VnSubnetsType(GeneratedsSuper): + """ + VnSubnetsType class definition from :doc:`vnc_cfg.xsd` + """ + subclass = None + superclass = None + def __init__(self, ipam_subnets=None, host_routes=None, **kwargs): + if (ipam_subnets is None) or (ipam_subnets == []): + self.ipam_subnets = [] + else: + if isinstance(ipam_subnets[0], dict): + objs = [IpamSubnetType(**elem) for elem in ipam_subnets] + self.ipam_subnets = objs + else: + self.ipam_subnets = ipam_subnets + if isinstance(host_routes, dict): + obj = RouteTableType(**host_routes) + self.host_routes = obj + else: + self.host_routes = host_routes + def factory(*args_, **kwargs_): + if VnSubnetsType.subclass: + return VnSubnetsType.subclass(*args_, **kwargs_) + else: + return VnSubnetsType(*args_, **kwargs_) + factory = staticmethod(factory) + def get_ipam_subnets(self): return self.ipam_subnets + def set_ipam_subnets(self, ipam_subnets): self.ipam_subnets = ipam_subnets + def add_ipam_subnets(self, value): self.ipam_subnets.append(value) + def insert_ipam_subnets(self, index, value): self.ipam_subnets[index] = value + def delete_ipam_subnets(self, value): self.ipam_subnets.remove(value) + def get_host_routes(self): return self.host_routes + def set_host_routes(self, host_routes): self.host_routes = host_routes + def __eq__(self, other): + if isinstance(other, self.__class__): + return (self.ipam_subnets == other.ipam_subnets and + self.host_routes == other.host_routes) + return NotImplemented + def __ne__(self, other): + if isinstance(other, self.__class__): + return not self.__eq__(other) + return NotImplemented + + @classmethod + def populate (cls, *a, **kwa): + obj = cls (*a, **kwa) + obj.set_ipam_subnets ([IpamSubnetType.populate ()]) + obj.set_host_routes (RouteTableType.populate ()) + return obj + def export(self, outfile, level=1, namespace_='', name_='VnSubnetsType', namespacedef_='', pretty_print=True): + if pretty_print: + eol_ = '\n' + else: + eol_ = '' + showIndent(outfile, level, pretty_print) + outfile.write('<%s%s%s' % (namespace_, name_, namespacedef_ and ' ' + namespacedef_ or '', )) + already_processed = [] + self.exportAttributes(outfile, level, already_processed, namespace_, name_='VnSubnetsType') + if self.hasContent_(): + outfile.write('>%s' % (eol_, )) + self.exportChildren(outfile, level + 1, namespace_, name_, pretty_print=pretty_print) + showIndent(outfile, level, pretty_print) + outfile.write('</%s%s>%s' % (namespace_, name_, eol_)) + else: + outfile.write('/>%s' % (eol_, )) + def exportAttributes(self, outfile, level, already_processed, namespace_='', name_='VnSubnetsType'): + pass + def exportChildren(self, outfile, level, namespace_='', name_='VnSubnetsType', fromsubclass_=False, pretty_print=True): + if pretty_print: + eol_ = '\n' + else: + eol_ = '' + for ipam_subnets_ in self.ipam_subnets: + if isinstance(ipam_subnets_, dict): + ipam_subnets_ = IpamSubnetType(**ipam_subnets_) + ipam_subnets_.export(outfile, level, namespace_, name_='ipam-subnets', pretty_print=pretty_print) + if self.host_routes is not None: + self.host_routes.export(outfile, level, namespace_, name_='host-routes', pretty_print=pretty_print) + def hasContent_(self): + if ( + self.ipam_subnets or + self.host_routes is not None + ): + return True + else: + return False + def exportLiteral(self, outfile, level, name_='VnSubnetsType'): + level += 1 + self.exportLiteralAttributes(outfile, level, [], name_) + if self.hasContent_(): + self.exportLiteralChildren(outfile, level, name_) + def exportLiteralAttributes(self, outfile, level, already_processed, name_): + pass + def exportLiteralChildren(self, outfile, level, name_): + showIndent(outfile, level) + outfile.write('ipam_subnets=[\n') + level += 1 + for ipam_subnets_ in self.ipam_subnets: + showIndent(outfile, level) + outfile.write('model_.IpamSubnetType(\n') + ipam_subnets_.exportLiteral(outfile, level, name_='IpamSubnetType') + showIndent(outfile, level) + outfile.write('),\n') + level -= 1 + showIndent(outfile, level) + outfile.write('],\n') + if self.host_routes is not None: + showIndent(outfile, level) + outfile.write('host_routes=model_.RouteTableType(\n') + self.host_routes.exportLiteral(outfile, level, name_='host_routes') + showIndent(outfile, level) + outfile.write('),\n') + def exportDict(self, name_='VnSubnetsType'): + obj_json = json.dumps(self, default=lambda o: dict((k, v) for k, v in o.__dict__.iteritems())) + obj_dict = json.loads(obj_json) + return {name_: obj_dict} + def build(self, node): + self.buildAttributes(node, node.attrib, []) + for child in node: + nodeName_ = Tag_pattern_.match(child.tag).groups()[-1] + self.buildChildren(child, node, nodeName_) + def buildAttributes(self, node, attrs, already_processed): + pass + def buildChildren(self, child_, node, nodeName_, fromsubclass_=False): + if nodeName_ == 'ipam-subnets': + obj_ = IpamSubnetType.factory() + obj_.build(child_) + self.ipam_subnets.append(obj_) + elif nodeName_ == 'host-routes': + obj_ = RouteTableType.factory() + obj_.build(child_) + self.set_host_routes(obj_) +# end class VnSubnetsType + + +class DomainLimitsType(GeneratedsSuper): + """ + DomainLimitsType class definition from :doc:`vnc_cfg.xsd` + """ + subclass = None + superclass = None + def __init__(self, project_limit=None, virtual_network_limit=None, security_group_limit=None, **kwargs): + self.project_limit = project_limit + self.virtual_network_limit = virtual_network_limit + self.security_group_limit = security_group_limit + def factory(*args_, **kwargs_): + if DomainLimitsType.subclass: + return DomainLimitsType.subclass(*args_, **kwargs_) + else: + return DomainLimitsType(*args_, **kwargs_) + factory = staticmethod(factory) + def get_project_limit(self): return self.project_limit + def set_project_limit(self, project_limit): self.project_limit = project_limit + def get_virtual_network_limit(self): return self.virtual_network_limit + def set_virtual_network_limit(self, virtual_network_limit): self.virtual_network_limit = virtual_network_limit + def get_security_group_limit(self): return self.security_group_limit + def set_security_group_limit(self, security_group_limit): self.security_group_limit = security_group_limit + def __eq__(self, other): + if isinstance(other, self.__class__): + return (self.project_limit == other.project_limit and + self.virtual_network_limit == other.virtual_network_limit and + self.security_group_limit == other.security_group_limit) + return NotImplemented + def __ne__(self, other): + if isinstance(other, self.__class__): + return not self.__eq__(other) + return NotImplemented + + @classmethod + def populate (cls, *a, **kwa): + obj = cls (*a, **kwa) + obj.set_project_limit (obj.populate_integer ("project_limit")) + obj.set_virtual_network_limit (obj.populate_integer ("virtual_network_limit")) + obj.set_security_group_limit (obj.populate_integer ("security_group_limit")) + return obj + def export(self, outfile, level=1, namespace_='', name_='DomainLimitsType', namespacedef_='', pretty_print=True): + if pretty_print: + eol_ = '\n' + else: + eol_ = '' + showIndent(outfile, level, pretty_print) + outfile.write('<%s%s%s' % (namespace_, name_, namespacedef_ and ' ' + namespacedef_ or '', )) + already_processed = [] + self.exportAttributes(outfile, level, already_processed, namespace_, name_='DomainLimitsType') + if self.hasContent_(): + outfile.write('>%s' % (eol_, )) + self.exportChildren(outfile, level + 1, namespace_, name_, pretty_print=pretty_print) + showIndent(outfile, level, pretty_print) + outfile.write('</%s%s>%s' % (namespace_, name_, eol_)) + else: + outfile.write('/>%s' % (eol_, )) + def exportAttributes(self, outfile, level, already_processed, namespace_='', name_='DomainLimitsType'): + pass + def exportChildren(self, outfile, level, namespace_='', name_='DomainLimitsType', fromsubclass_=False, pretty_print=True): + if pretty_print: + eol_ = '\n' + else: + eol_ = '' + if self.project_limit is not None: + showIndent(outfile, level, pretty_print) + outfile.write('<%sproject-limit>%s</%sproject-limit>%s' % (namespace_, self.gds_format_integer(self.project_limit, input_name='project-limit'), namespace_, eol_)) + if self.virtual_network_limit is not None: + showIndent(outfile, level, pretty_print) + outfile.write('<%svirtual-network-limit>%s</%svirtual-network-limit>%s' % (namespace_, self.gds_format_integer(self.virtual_network_limit, input_name='virtual-network-limit'), namespace_, eol_)) + if self.security_group_limit is not None: + showIndent(outfile, level, pretty_print) + outfile.write('<%ssecurity-group-limit>%s</%ssecurity-group-limit>%s' % (namespace_, self.gds_format_integer(self.security_group_limit, input_name='security-group-limit'), namespace_, eol_)) + def hasContent_(self): + if ( + self.project_limit is not None or + self.virtual_network_limit is not None or + self.security_group_limit is not None + ): + return True + else: + return False + def exportLiteral(self, outfile, level, name_='DomainLimitsType'): + level += 1 + self.exportLiteralAttributes(outfile, level, [], name_) + if self.hasContent_(): + self.exportLiteralChildren(outfile, level, name_) + def exportLiteralAttributes(self, outfile, level, already_processed, name_): + pass + def exportLiteralChildren(self, outfile, level, name_): + if self.project_limit is not None: + showIndent(outfile, level) + outfile.write('project_limit=%d,\n' % self.project_limit) + if self.virtual_network_limit is not None: + showIndent(outfile, level) + outfile.write('virtual_network_limit=%d,\n' % self.virtual_network_limit) + if self.security_group_limit is not None: + showIndent(outfile, level) + outfile.write('security_group_limit=%d,\n' % self.security_group_limit) + def exportDict(self, name_='DomainLimitsType'): + obj_json = json.dumps(self, default=lambda o: dict((k, v) for k, v in o.__dict__.iteritems())) + obj_dict = json.loads(obj_json) + return {name_: obj_dict} + def build(self, node): + self.buildAttributes(node, node.attrib, []) + for child in node: + nodeName_ = Tag_pattern_.match(child.tag).groups()[-1] + self.buildChildren(child, node, nodeName_) + def buildAttributes(self, node, attrs, already_processed): + pass + def buildChildren(self, child_, node, nodeName_, fromsubclass_=False): + if nodeName_ == 'project-limit': + sval_ = child_.text + try: + ival_ = int(sval_) + except (TypeError, ValueError), exp: + raise_parse_error(child_, 'requires integer: %s' % exp) + ival_ = self.gds_validate_integer(ival_, node, 'project_limit') + self.project_limit = ival_ + elif nodeName_ == 'virtual-network-limit': + sval_ = child_.text + try: + ival_ = int(sval_) + except (TypeError, ValueError), exp: + raise_parse_error(child_, 'requires integer: %s' % exp) + ival_ = self.gds_validate_integer(ival_, node, 'virtual_network_limit') + self.virtual_network_limit = ival_ + elif nodeName_ == 'security-group-limit': + sval_ = child_.text + try: + ival_ = int(sval_) + except (TypeError, ValueError), exp: + raise_parse_error(child_, 'requires integer: %s' % exp) + ival_ = self.gds_validate_integer(ival_, node, 'security_group_limit') + self.security_group_limit = ival_ +# end class DomainLimitsType + + +class PermType(GeneratedsSuper): + """ + PermType class definition from :doc:`vnc_cfg.xsd` + """ + subclass = None + superclass = None + def __init__(self, owner=None, owner_access=None, group=None, group_access=None, other_access=None, **kwargs): + self.owner = owner + self.owner_access = owner_access + self.group = group + self.group_access = group_access + self.other_access = other_access + def factory(*args_, **kwargs_): + if PermType.subclass: + return PermType.subclass(*args_, **kwargs_) + else: + return PermType(*args_, **kwargs_) + factory = staticmethod(factory) + def get_owner(self): return self.owner + def set_owner(self, owner): self.owner = owner + def get_owner_access(self): return self.owner_access + def set_owner_access(self, owner_access): self.owner_access = owner_access + def validate_AccessType(self, value): + # Validate type AccessType, a restriction on xsd:integer. + error = False + if isinstance(value, list): + v_int = map(int, value) + v1, v2 = min(v_int), max(v_int) + else: + v1, v2 = int(value), int(value) + error = (0 > v1) + error |= (v2 > 7) + if error: + raise ValueError("AccessType must be in the range 0-7") + def get_group(self): return self.group + def set_group(self, group): self.group = group + def get_group_access(self): return self.group_access + def set_group_access(self, group_access): self.group_access = group_access + def get_other_access(self): return self.other_access + def set_other_access(self, other_access): self.other_access = other_access + def __eq__(self, other): + if isinstance(other, self.__class__): + return (self.owner == other.owner and + self.owner_access == other.owner_access and + self.group == other.group and + self.group_access == other.group_access and + self.other_access == other.other_access) + return NotImplemented + def __ne__(self, other): + if isinstance(other, self.__class__): + return not self.__eq__(other) + return NotImplemented + + @classmethod + def populate (cls, *a, **kwa): + obj = cls (*a, **kwa) + obj.set_owner (obj.populate_string ("owner")) + obj.set_owner_access (obj.populate_integer ("owner_access")) + obj.set_group (obj.populate_string ("group")) + obj.set_group_access (obj.populate_integer ("group_access")) + obj.set_other_access (obj.populate_integer ("other_access")) + return obj + def export(self, outfile, level=1, namespace_='', name_='PermType', namespacedef_='', pretty_print=True): + if pretty_print: + eol_ = '\n' + else: + eol_ = '' + showIndent(outfile, level, pretty_print) + outfile.write('<%s%s%s' % (namespace_, name_, namespacedef_ and ' ' + namespacedef_ or '', )) + already_processed = [] + self.exportAttributes(outfile, level, already_processed, namespace_, name_='PermType') + if self.hasContent_(): + outfile.write('>%s' % (eol_, )) + self.exportChildren(outfile, level + 1, namespace_, name_, pretty_print=pretty_print) + showIndent(outfile, level, pretty_print) + outfile.write('</%s%s>%s' % (namespace_, name_, eol_)) + else: + outfile.write('/>%s' % (eol_, )) + def exportAttributes(self, outfile, level, already_processed, namespace_='', name_='PermType'): + pass + def exportChildren(self, outfile, level, namespace_='', name_='PermType', fromsubclass_=False, pretty_print=True): + if pretty_print: + eol_ = '\n' + else: + eol_ = '' + if self.owner is not None: + showIndent(outfile, level, pretty_print) + outfile.write('<%sowner>%s</%sowner>%s' % (namespace_, self.gds_format_string(quote_xml(self.owner).encode(ExternalEncoding), input_name='owner'), namespace_, eol_)) + if self.owner_access is not None: + showIndent(outfile, level, pretty_print) + outfile.write('<%sowner-access>%s</%sowner-access>%s' % (namespace_, self.gds_format_integer(self.owner_access, input_name='owner-access'), namespace_, eol_)) + if self.group is not None: + showIndent(outfile, level, pretty_print) + outfile.write('<%sgroup>%s</%sgroup>%s' % (namespace_, self.gds_format_string(quote_xml(self.group).encode(ExternalEncoding), input_name='group'), namespace_, eol_)) + if self.group_access is not None: + showIndent(outfile, level, pretty_print) + outfile.write('<%sgroup-access>%s</%sgroup-access>%s' % (namespace_, self.gds_format_integer(self.group_access, input_name='group-access'), namespace_, eol_)) + if self.other_access is not None: + showIndent(outfile, level, pretty_print) + outfile.write('<%sother-access>%s</%sother-access>%s' % (namespace_, self.gds_format_integer(self.other_access, input_name='other-access'), namespace_, eol_)) + def hasContent_(self): + if ( + self.owner is not None or + self.owner_access is not None or + self.group is not None or + self.group_access is not None or + self.other_access is not None + ): + return True + else: + return False + def exportLiteral(self, outfile, level, name_='PermType'): + level += 1 + self.exportLiteralAttributes(outfile, level, [], name_) + if self.hasContent_(): + self.exportLiteralChildren(outfile, level, name_) + def exportLiteralAttributes(self, outfile, level, already_processed, name_): + pass + def exportLiteralChildren(self, outfile, level, name_): + if self.owner is not None: + showIndent(outfile, level) + outfile.write('owner=%s,\n' % quote_python(self.owner).encode(ExternalEncoding)) + if self.owner_access is not None: + showIndent(outfile, level) + outfile.write('owner_access=%d,\n' % self.owner_access) + if self.group is not None: + showIndent(outfile, level) + outfile.write('group=%s,\n' % quote_python(self.group).encode(ExternalEncoding)) + if self.group_access is not None: + showIndent(outfile, level) + outfile.write('group_access=%d,\n' % self.group_access) + if self.other_access is not None: + showIndent(outfile, level) + outfile.write('other_access=%d,\n' % self.other_access) + def exportDict(self, name_='PermType'): + obj_json = json.dumps(self, default=lambda o: dict((k, v) for k, v in o.__dict__.iteritems())) + obj_dict = json.loads(obj_json) + return {name_: obj_dict} + def build(self, node): + self.buildAttributes(node, node.attrib, []) + for child in node: + nodeName_ = Tag_pattern_.match(child.tag).groups()[-1] + self.buildChildren(child, node, nodeName_) + def buildAttributes(self, node, attrs, already_processed): + pass + def buildChildren(self, child_, node, nodeName_, fromsubclass_=False): + if nodeName_ == 'owner': + owner_ = child_.text + owner_ = self.gds_validate_string(owner_, node, 'owner') + self.owner = owner_ + elif nodeName_ == 'owner-access': + sval_ = child_.text + try: + ival_ = int(sval_) + except (TypeError, ValueError), exp: + raise_parse_error(child_, 'requires integer: %s' % exp) + ival_ = self.gds_validate_integer(ival_, node, 'owner_access') + self.owner_access = ival_ + self.validate_AccessType(self.owner_access) # validate type AccessType + elif nodeName_ == 'group': + group_ = child_.text + group_ = self.gds_validate_string(group_, node, 'group') + self.group = group_ + elif nodeName_ == 'group-access': + sval_ = child_.text + try: + ival_ = int(sval_) + except (TypeError, ValueError), exp: + raise_parse_error(child_, 'requires integer: %s' % exp) + ival_ = self.gds_validate_integer(ival_, node, 'group_access') + self.group_access = ival_ + self.validate_AccessType(self.group_access) # validate type AccessType + elif nodeName_ == 'other-access': + sval_ = child_.text + try: + ival_ = int(sval_) + except (TypeError, ValueError), exp: + raise_parse_error(child_, 'requires integer: %s' % exp) + ival_ = self.gds_validate_integer(ival_, node, 'other_access') + self.other_access = ival_ + self.validate_AccessType(self.other_access) # validate type AccessType +# end class PermType + + +class IdPermsType(GeneratedsSuper): + """ + IdPermsType class definition from :doc:`vnc_cfg.xsd` + """ + subclass = None + superclass = None + def __init__(self, permissions=None, uuid=None, enable=None, created=None, last_modified=None, description=None, user_visible=True, creator=None, **kwargs): + if isinstance(permissions, dict): + obj = PermType(**permissions) + self.permissions = obj + else: + self.permissions = permissions + if isinstance(uuid, dict): + obj = UuidType(**uuid) + self.uuid = obj + else: + self.uuid = uuid + self.enable = enable + self.created = created + self.last_modified = last_modified + self.description = description + self.user_visible = user_visible + self.creator = creator + def factory(*args_, **kwargs_): + if IdPermsType.subclass: + return IdPermsType.subclass(*args_, **kwargs_) + else: + return IdPermsType(*args_, **kwargs_) + factory = staticmethod(factory) + def get_permissions(self): return self.permissions + def set_permissions(self, permissions): self.permissions = permissions + def get_uuid(self): return self.uuid + def set_uuid(self, uuid): self.uuid = uuid + def get_enable(self): return self.enable + def set_enable(self, enable): self.enable = enable + def get_created(self): return self.created + def set_created(self, created): self.created = created + def get_last_modified(self): return self.last_modified + def set_last_modified(self, last_modified): self.last_modified = last_modified + def get_description(self): return self.description + def set_description(self, description): self.description = description + def get_user_visible(self): return self.user_visible + def set_user_visible(self, user_visible): self.user_visible = user_visible + def get_creator(self): return self.creator + def set_creator(self, creator): self.creator = creator + def validate_CreatorType(self, value): + # Validate type CreatorType, a restriction on xsd:string. + error = False + if isinstance(value, list): + error = set(value) - set([u'vcenter-plugin', u'test']) + else: + error = value not in [u'vcenter-plugin', u'test'] + if error: + raise ValueError("CreatorType must be one of [u'vcenter-plugin', u'test']") + def __eq__(self, other): + if isinstance(other, self.__class__): + return (self.permissions == other.permissions and + self.uuid == other.uuid and + self.enable == other.enable and + self.created == other.created and + self.last_modified == other.last_modified and + self.description == other.description and + self.user_visible == other.user_visible and + self.creator == other.creator) + return NotImplemented + def __ne__(self, other): + if isinstance(other, self.__class__): + return not self.__eq__(other) + return NotImplemented + + @classmethod + def populate (cls, *a, **kwa): + obj = cls (*a, **kwa) + obj.set_permissions (PermType.populate ()) + obj.set_uuid (UuidType.populate ()) + obj.set_enable (obj.populate_boolean ("enable")) + obj.set_created (obj.populate_dateTime ("created")) + obj.set_last_modified (obj.populate_dateTime ("last_modified")) + obj.set_description (obj.populate_string ("description")) + obj.set_user_visible (obj.populate_boolean ("user_visible")) + obj.set_creator (obj.populate_string ("creator")) + return obj + def export(self, outfile, level=1, namespace_='', name_='IdPermsType', namespacedef_='', pretty_print=True): + if pretty_print: + eol_ = '\n' + else: + eol_ = '' + showIndent(outfile, level, pretty_print) + outfile.write('<%s%s%s' % (namespace_, name_, namespacedef_ and ' ' + namespacedef_ or '', )) + already_processed = [] + self.exportAttributes(outfile, level, already_processed, namespace_, name_='IdPermsType') + if self.hasContent_(): + outfile.write('>%s' % (eol_, )) + self.exportChildren(outfile, level + 1, namespace_, name_, pretty_print=pretty_print) + showIndent(outfile, level, pretty_print) + outfile.write('</%s%s>%s' % (namespace_, name_, eol_)) + else: + outfile.write('/>%s' % (eol_, )) + def exportAttributes(self, outfile, level, already_processed, namespace_='', name_='IdPermsType'): + pass + def exportChildren(self, outfile, level, namespace_='', name_='IdPermsType', fromsubclass_=False, pretty_print=True): + if pretty_print: + eol_ = '\n' + else: + eol_ = '' + if self.permissions is not None: + self.permissions.export(outfile, level, namespace_, name_='permissions', pretty_print=pretty_print) + if self.uuid is not None: + self.uuid.export(outfile, level, namespace_, name_='uuid', pretty_print=pretty_print) + if self.enable is not None: + showIndent(outfile, level, pretty_print) + outfile.write('<%senable>%s</%senable>%s' % (namespace_, self.gds_format_boolean(self.gds_str_lower(str(self.enable)), input_name='enable'), namespace_, eol_)) + if self.created is not None: + showIndent(outfile, level, pretty_print) + outfile.write('<%screated>%s</%screated>%s' % (namespace_, self.gds_format_string(quote_xml(self.created).encode(ExternalEncoding), input_name='created'), namespace_, eol_)) + if self.last_modified is not None: + showIndent(outfile, level, pretty_print) + outfile.write('<%slast-modified>%s</%slast-modified>%s' % (namespace_, self.gds_format_string(quote_xml(self.last_modified).encode(ExternalEncoding), input_name='last-modified'), namespace_, eol_)) + if self.description is not None: + showIndent(outfile, level, pretty_print) + outfile.write('<%sdescription>%s</%sdescription>%s' % (namespace_, self.gds_format_string(quote_xml(self.description).encode(ExternalEncoding), input_name='description'), namespace_, eol_)) + if self.user_visible is not None: + showIndent(outfile, level, pretty_print) + outfile.write('<%suser-visible>%s</%suser-visible>%s' % (namespace_, self.gds_format_boolean(self.gds_str_lower(str(self.user_visible)), input_name='user-visible'), namespace_, eol_)) + if self.creator is not None: + showIndent(outfile, level, pretty_print) + outfile.write('<%screator>%s</%screator>%s' % (namespace_, self.gds_format_string(quote_xml(self.creator).encode(ExternalEncoding), input_name='creator'), namespace_, eol_)) + def hasContent_(self): + if ( + self.permissions is not None or + self.uuid is not None or + self.enable is not None or + self.created is not None or + self.last_modified is not None or + self.description is not None or + self.user_visible is not None or + self.creator is not None + ): + return True + else: + return False + def exportLiteral(self, outfile, level, name_='IdPermsType'): + level += 1 + self.exportLiteralAttributes(outfile, level, [], name_) + if self.hasContent_(): + self.exportLiteralChildren(outfile, level, name_) + def exportLiteralAttributes(self, outfile, level, already_processed, name_): + pass + def exportLiteralChildren(self, outfile, level, name_): + if self.permissions is not None: + showIndent(outfile, level) + outfile.write('permissions=model_.PermType(\n') + self.permissions.exportLiteral(outfile, level, name_='permissions') + showIndent(outfile, level) + outfile.write('),\n') + if self.uuid is not None: + showIndent(outfile, level) + outfile.write('uuid=model_.UuidType(\n') + self.uuid.exportLiteral(outfile, level, name_='uuid') + showIndent(outfile, level) + outfile.write('),\n') + if self.enable is not None: + showIndent(outfile, level) + outfile.write('enable=%s,\n' % self.enable) + if self.created is not None: + showIndent(outfile, level) + outfile.write('created=%s,\n' % quote_python(self.created).encode(ExternalEncoding)) + if self.last_modified is not None: + showIndent(outfile, level) + outfile.write('last_modified=%s,\n' % quote_python(self.last_modified).encode(ExternalEncoding)) + if self.description is not None: + showIndent(outfile, level) + outfile.write('description=%s,\n' % quote_python(self.description).encode(ExternalEncoding)) + if self.user_visible is not None: + showIndent(outfile, level) + outfile.write('user_visible=%s,\n' % self.user_visible) + if self.creator is not None: + showIndent(outfile, level) + outfile.write('creator=%s,\n' % quote_python(self.creator).encode(ExternalEncoding)) + def exportDict(self, name_='IdPermsType'): + obj_json = json.dumps(self, default=lambda o: dict((k, v) for k, v in o.__dict__.iteritems())) + obj_dict = json.loads(obj_json) + return {name_: obj_dict} + def build(self, node): + self.buildAttributes(node, node.attrib, []) + for child in node: + nodeName_ = Tag_pattern_.match(child.tag).groups()[-1] + self.buildChildren(child, node, nodeName_) + def buildAttributes(self, node, attrs, already_processed): + pass + def buildChildren(self, child_, node, nodeName_, fromsubclass_=False): + if nodeName_ == 'permissions': + obj_ = PermType.factory() + obj_.build(child_) + self.set_permissions(obj_) + elif nodeName_ == 'uuid': + obj_ = UuidType.factory() + obj_.build(child_) + self.set_uuid(obj_) + elif nodeName_ == 'enable': + sval_ = child_.text + if sval_ in ('true', '1'): + ival_ = True + elif sval_ in ('false', '0'): + ival_ = False + else: + raise_parse_error(child_, 'requires boolean') + ival_ = self.gds_validate_boolean(ival_, node, 'enable') + self.enable = ival_ + elif nodeName_ == 'created': + created_ = child_.text + created_ = self.gds_validate_string(created_, node, 'created') + self.created = created_ + elif nodeName_ == 'last-modified': + last_modified_ = child_.text + last_modified_ = self.gds_validate_string(last_modified_, node, 'last_modified') + self.last_modified = last_modified_ + elif nodeName_ == 'description': + description_ = child_.text + description_ = self.gds_validate_string(description_, node, 'description') + self.description = description_ + elif nodeName_ == 'user-visible': + sval_ = child_.text + if sval_ in ('true', '1'): + ival_ = True + elif sval_ in ('false', '0'): + ival_ = False + else: + raise_parse_error(child_, 'requires boolean') + ival_ = self.gds_validate_boolean(ival_, node, 'user_visible') + self.user_visible = ival_ + elif nodeName_ == 'creator': + creator_ = child_.text + creator_ = self.gds_validate_string(creator_, node, 'creator') + self.creator = creator_ + self.validate_CreatorType(self.creator) # validate type CreatorType +# end class IdPermsType + + +class PluginProperty(GeneratedsSuper): + """ + PluginProperty class definition from :doc:`vnc_cfg.xsd` + """ + subclass = None + superclass = None + def __init__(self, property=None, value=None, **kwargs): + self.property = property + self.value = value + def factory(*args_, **kwargs_): + if PluginProperty.subclass: + return PluginProperty.subclass(*args_, **kwargs_) + else: + return PluginProperty(*args_, **kwargs_) + factory = staticmethod(factory) + def get_property(self): return self.property + def set_property(self, property): self.property = property + def get_value(self): return self.value + def set_value(self, value): self.value = value + def __eq__(self, other): + if isinstance(other, self.__class__): + return (self.property == other.property and + self.value == other.value) + return NotImplemented + def __ne__(self, other): + if isinstance(other, self.__class__): + return not self.__eq__(other) + return NotImplemented + + @classmethod + def populate (cls, *a, **kwa): + obj = cls (*a, **kwa) + obj.set_property (obj.populate_string ("property")) + obj.set_value (obj.populate_string ("value")) + return obj + def export(self, outfile, level=1, namespace_='', name_='PluginProperty', namespacedef_='', pretty_print=True): + if pretty_print: + eol_ = '\n' + else: + eol_ = '' + showIndent(outfile, level, pretty_print) + outfile.write('<%s%s%s' % (namespace_, name_, namespacedef_ and ' ' + namespacedef_ or '', )) + already_processed = [] + self.exportAttributes(outfile, level, already_processed, namespace_, name_='PluginProperty') + if self.hasContent_(): + outfile.write('>%s' % (eol_, )) + self.exportChildren(outfile, level + 1, namespace_, name_, pretty_print=pretty_print) + showIndent(outfile, level, pretty_print) + outfile.write('</%s%s>%s' % (namespace_, name_, eol_)) + else: + outfile.write('/>%s' % (eol_, )) + def exportAttributes(self, outfile, level, already_processed, namespace_='', name_='PluginProperty'): + pass + def exportChildren(self, outfile, level, namespace_='', name_='PluginProperty', fromsubclass_=False, pretty_print=True): + if pretty_print: + eol_ = '\n' + else: + eol_ = '' + if self.property is not None: + showIndent(outfile, level, pretty_print) + outfile.write('<%sproperty>%s</%sproperty>%s' % (namespace_, self.gds_format_string(quote_xml(self.property).encode(ExternalEncoding), input_name='property'), namespace_, eol_)) + if self.value is not None: + showIndent(outfile, level, pretty_print) + outfile.write('<%svalue>%s</%svalue>%s' % (namespace_, self.gds_format_string(quote_xml(self.value).encode(ExternalEncoding), input_name='value'), namespace_, eol_)) + def hasContent_(self): + if ( + self.property is not None or + self.value is not None + ): + return True + else: + return False + def exportLiteral(self, outfile, level, name_='PluginProperty'): + level += 1 + self.exportLiteralAttributes(outfile, level, [], name_) + if self.hasContent_(): + self.exportLiteralChildren(outfile, level, name_) + def exportLiteralAttributes(self, outfile, level, already_processed, name_): + pass + def exportLiteralChildren(self, outfile, level, name_): + if self.property is not None: + showIndent(outfile, level) + outfile.write('property=%s,\n' % quote_python(self.property).encode(ExternalEncoding)) + if self.value is not None: + showIndent(outfile, level) + outfile.write('value=%s,\n' % quote_python(self.value).encode(ExternalEncoding)) + def exportDict(self, name_='PluginProperty'): + obj_json = json.dumps(self, default=lambda o: dict((k, v) for k, v in o.__dict__.iteritems())) + obj_dict = json.loads(obj_json) + return {name_: obj_dict} + def build(self, node): + self.buildAttributes(node, node.attrib, []) + for child in node: + nodeName_ = Tag_pattern_.match(child.tag).groups()[-1] + self.buildChildren(child, node, nodeName_) + def buildAttributes(self, node, attrs, already_processed): + pass + def buildChildren(self, child_, node, nodeName_, fromsubclass_=False): + if nodeName_ == 'property': + property_ = child_.text + property_ = self.gds_validate_string(property_, node, 'property') + self.property = property_ + elif nodeName_ == 'value': + value_ = child_.text + value_ = self.gds_validate_string(value_, node, 'value') + self.value = value_ +# end class PluginProperty + + +class PluginProperties(GeneratedsSuper): + """ + PluginProperties class definition from :doc:`vnc_cfg.xsd` + """ + subclass = None + superclass = None + def __init__(self, plugin_property=None, **kwargs): + if (plugin_property is None) or (plugin_property == []): + self.plugin_property = [] + else: + if isinstance(plugin_property[0], dict): + objs = [PluginProperty(**elem) for elem in plugin_property] + self.plugin_property = objs + else: + self.plugin_property = plugin_property + def factory(*args_, **kwargs_): + if PluginProperties.subclass: + return PluginProperties.subclass(*args_, **kwargs_) + else: + return PluginProperties(*args_, **kwargs_) + factory = staticmethod(factory) + def get_plugin_property(self): return self.plugin_property + def set_plugin_property(self, plugin_property): self.plugin_property = plugin_property + def add_plugin_property(self, value): self.plugin_property.append(value) + def insert_plugin_property(self, index, value): self.plugin_property[index] = value + def delete_plugin_property(self, value): self.plugin_property.remove(value) + def __eq__(self, other): + if isinstance(other, self.__class__): + return (self.plugin_property == other.plugin_property) + return NotImplemented + def __ne__(self, other): + if isinstance(other, self.__class__): + return not self.__eq__(other) + return NotImplemented + + @classmethod + def populate (cls, *a, **kwa): + obj = cls (*a, **kwa) + obj.set_plugin_property ([PluginProperty.populate ()]) + return obj + def export(self, outfile, level=1, namespace_='', name_='PluginProperties', namespacedef_='', pretty_print=True): + if pretty_print: + eol_ = '\n' + else: + eol_ = '' + showIndent(outfile, level, pretty_print) + outfile.write('<%s%s%s' % (namespace_, name_, namespacedef_ and ' ' + namespacedef_ or '', )) + already_processed = [] + self.exportAttributes(outfile, level, already_processed, namespace_, name_='PluginProperties') + if self.hasContent_(): + outfile.write('>%s' % (eol_, )) + self.exportChildren(outfile, level + 1, namespace_, name_, pretty_print=pretty_print) + showIndent(outfile, level, pretty_print) + outfile.write('</%s%s>%s' % (namespace_, name_, eol_)) + else: + outfile.write('/>%s' % (eol_, )) + def exportAttributes(self, outfile, level, already_processed, namespace_='', name_='PluginProperties'): + pass + def exportChildren(self, outfile, level, namespace_='', name_='PluginProperties', fromsubclass_=False, pretty_print=True): + if pretty_print: + eol_ = '\n' + else: + eol_ = '' + for plugin_property_ in self.plugin_property: + if isinstance(plugin_property_, dict): + plugin_property_ = PluginProperty(**plugin_property_) + plugin_property_.export(outfile, level, namespace_, name_='plugin-property', pretty_print=pretty_print) + def hasContent_(self): + if ( + self.plugin_property + ): + return True + else: + return False + def exportLiteral(self, outfile, level, name_='PluginProperties'): + level += 1 + self.exportLiteralAttributes(outfile, level, [], name_) + if self.hasContent_(): + self.exportLiteralChildren(outfile, level, name_) + def exportLiteralAttributes(self, outfile, level, already_processed, name_): + pass + def exportLiteralChildren(self, outfile, level, name_): + showIndent(outfile, level) + outfile.write('plugin_property=[\n') + level += 1 + for plugin_property_ in self.plugin_property: + showIndent(outfile, level) + outfile.write('model_.PluginProperty(\n') + plugin_property_.exportLiteral(outfile, level, name_='PluginProperty') + showIndent(outfile, level) + outfile.write('),\n') + level -= 1 + showIndent(outfile, level) + outfile.write('],\n') + def exportDict(self, name_='PluginProperties'): + obj_json = json.dumps(self, default=lambda o: dict((k, v) for k, v in o.__dict__.iteritems())) + obj_dict = json.loads(obj_json) + return {name_: obj_dict} + def build(self, node): + self.buildAttributes(node, node.attrib, []) + for child in node: + nodeName_ = Tag_pattern_.match(child.tag).groups()[-1] + self.buildChildren(child, node, nodeName_) + def buildAttributes(self, node, attrs, already_processed): + pass + def buildChildren(self, child_, node, nodeName_, fromsubclass_=False): + if nodeName_ == 'plugin-property': + obj_ = PluginProperty.factory() + obj_.build(child_) + self.plugin_property.append(obj_) +# end class PluginProperties + + +class QuotaType(GeneratedsSuper): + """ + QuotaType class definition from :doc:`vnc_cfg.xsd` + """ + subclass = None + superclass = None + def __init__(self, defaults=None, floating_ip=None, instance_ip=None, virtual_machine_interface=None, virtual_network=None, virtual_router=None, virtual_DNS=None, virtual_DNS_record=None, bgp_router=None, network_ipam=None, access_control_list=None, floating_ip_pool=None, service_template=None, service_instance=None, logical_router=None, security_group=None, security_group_rule=None, subnet=None, global_vrouter_config=None, loadbalancer_pool=None, loadbalancer_member=None, loadbalancer_healthmonitor=None, virtual_ip=None, **kwargs): + self.defaults = defaults + self.floating_ip = floating_ip + self.instance_ip = instance_ip + self.virtual_machine_interface = virtual_machine_interface + self.virtual_network = virtual_network + self.virtual_router = virtual_router + self.virtual_DNS = virtual_DNS + self.virtual_DNS_record = virtual_DNS_record + self.bgp_router = bgp_router + self.network_ipam = network_ipam + self.access_control_list = access_control_list + self.floating_ip_pool = floating_ip_pool + self.service_template = service_template + self.service_instance = service_instance + self.logical_router = logical_router + self.security_group = security_group + self.security_group_rule = security_group_rule + self.subnet = subnet + self.global_vrouter_config = global_vrouter_config + self.loadbalancer_pool = loadbalancer_pool + self.loadbalancer_member = loadbalancer_member + self.loadbalancer_healthmonitor = loadbalancer_healthmonitor + self.virtual_ip = virtual_ip + def factory(*args_, **kwargs_): + if QuotaType.subclass: + return QuotaType.subclass(*args_, **kwargs_) + else: + return QuotaType(*args_, **kwargs_) + factory = staticmethod(factory) + def get_defaults(self): return self.defaults + def set_defaults(self, defaults): self.defaults = defaults + def get_floating_ip(self): return self.floating_ip + def set_floating_ip(self, floating_ip): self.floating_ip = floating_ip + def get_instance_ip(self): return self.instance_ip + def set_instance_ip(self, instance_ip): self.instance_ip = instance_ip + def get_virtual_machine_interface(self): return self.virtual_machine_interface + def set_virtual_machine_interface(self, virtual_machine_interface): self.virtual_machine_interface = virtual_machine_interface + def get_virtual_network(self): return self.virtual_network + def set_virtual_network(self, virtual_network): self.virtual_network = virtual_network + def get_virtual_router(self): return self.virtual_router + def set_virtual_router(self, virtual_router): self.virtual_router = virtual_router + def get_virtual_DNS(self): return self.virtual_DNS + def set_virtual_DNS(self, virtual_DNS): self.virtual_DNS = virtual_DNS + def get_virtual_DNS_record(self): return self.virtual_DNS_record + def set_virtual_DNS_record(self, virtual_DNS_record): self.virtual_DNS_record = virtual_DNS_record + def get_bgp_router(self): return self.bgp_router + def set_bgp_router(self, bgp_router): self.bgp_router = bgp_router + def get_network_ipam(self): return self.network_ipam + def set_network_ipam(self, network_ipam): self.network_ipam = network_ipam + def get_access_control_list(self): return self.access_control_list + def set_access_control_list(self, access_control_list): self.access_control_list = access_control_list + def get_floating_ip_pool(self): return self.floating_ip_pool + def set_floating_ip_pool(self, floating_ip_pool): self.floating_ip_pool = floating_ip_pool + def get_service_template(self): return self.service_template + def set_service_template(self, service_template): self.service_template = service_template + def get_service_instance(self): return self.service_instance + def set_service_instance(self, service_instance): self.service_instance = service_instance + def get_logical_router(self): return self.logical_router + def set_logical_router(self, logical_router): self.logical_router = logical_router + def get_security_group(self): return self.security_group + def set_security_group(self, security_group): self.security_group = security_group + def get_security_group_rule(self): return self.security_group_rule + def set_security_group_rule(self, security_group_rule): self.security_group_rule = security_group_rule + def get_subnet(self): return self.subnet + def set_subnet(self, subnet): self.subnet = subnet + def get_global_vrouter_config(self): return self.global_vrouter_config + def set_global_vrouter_config(self, global_vrouter_config): self.global_vrouter_config = global_vrouter_config + def get_loadbalancer_pool(self): return self.loadbalancer_pool + def set_loadbalancer_pool(self, loadbalancer_pool): self.loadbalancer_pool = loadbalancer_pool + def get_loadbalancer_member(self): return self.loadbalancer_member + def set_loadbalancer_member(self, loadbalancer_member): self.loadbalancer_member = loadbalancer_member + def get_loadbalancer_healthmonitor(self): return self.loadbalancer_healthmonitor + def set_loadbalancer_healthmonitor(self, loadbalancer_healthmonitor): self.loadbalancer_healthmonitor = loadbalancer_healthmonitor + def get_virtual_ip(self): return self.virtual_ip + def set_virtual_ip(self, virtual_ip): self.virtual_ip = virtual_ip + def __eq__(self, other): + if isinstance(other, self.__class__): + return (self.defaults == other.defaults and + self.floating_ip == other.floating_ip and + self.instance_ip == other.instance_ip and + self.virtual_machine_interface == other.virtual_machine_interface and + self.virtual_network == other.virtual_network and + self.virtual_router == other.virtual_router and + self.virtual_DNS == other.virtual_DNS and + self.virtual_DNS_record == other.virtual_DNS_record and + self.bgp_router == other.bgp_router and + self.network_ipam == other.network_ipam and + self.access_control_list == other.access_control_list and + self.floating_ip_pool == other.floating_ip_pool and + self.service_template == other.service_template and + self.service_instance == other.service_instance and + self.logical_router == other.logical_router and + self.security_group == other.security_group and + self.security_group_rule == other.security_group_rule and + self.subnet == other.subnet and + self.global_vrouter_config == other.global_vrouter_config and + self.loadbalancer_pool == other.loadbalancer_pool and + self.loadbalancer_member == other.loadbalancer_member and + self.loadbalancer_healthmonitor == other.loadbalancer_healthmonitor and + self.virtual_ip == other.virtual_ip) + return NotImplemented + def __ne__(self, other): + if isinstance(other, self.__class__): + return not self.__eq__(other) + return NotImplemented + + @classmethod + def populate (cls, *a, **kwa): + obj = cls (*a, **kwa) + obj.set_defaults (obj.populate_integer ("defaults")) + obj.set_floating_ip (obj.populate_integer ("floating_ip")) + obj.set_instance_ip (obj.populate_integer ("instance_ip")) + obj.set_virtual_machine_interface (obj.populate_integer ("virtual_machine_interface")) + obj.set_virtual_network (obj.populate_integer ("virtual_network")) + obj.set_virtual_router (obj.populate_integer ("virtual_router")) + obj.set_virtual_DNS (obj.populate_integer ("virtual_DNS")) + obj.set_virtual_DNS_record (obj.populate_integer ("virtual_DNS_record")) + obj.set_bgp_router (obj.populate_integer ("bgp_router")) + obj.set_network_ipam (obj.populate_integer ("network_ipam")) + obj.set_access_control_list (obj.populate_integer ("access_control_list")) + obj.set_floating_ip_pool (obj.populate_integer ("floating_ip_pool")) + obj.set_service_template (obj.populate_integer ("service_template")) + obj.set_service_instance (obj.populate_integer ("service_instance")) + obj.set_logical_router (obj.populate_integer ("logical_router")) + obj.set_security_group (obj.populate_integer ("security_group")) + obj.set_security_group_rule (obj.populate_integer ("security_group_rule")) + obj.set_subnet (obj.populate_integer ("subnet")) + obj.set_global_vrouter_config (obj.populate_integer ("global_vrouter_config")) + obj.set_loadbalancer_pool (obj.populate_integer ("loadbalancer_pool")) + obj.set_loadbalancer_member (obj.populate_integer ("loadbalancer_member")) + obj.set_loadbalancer_healthmonitor (obj.populate_integer ("loadbalancer_healthmonitor")) + obj.set_virtual_ip (obj.populate_integer ("virtual_ip")) + return obj + def export(self, outfile, level=1, namespace_='', name_='QuotaType', namespacedef_='', pretty_print=True): + if pretty_print: + eol_ = '\n' + else: + eol_ = '' + showIndent(outfile, level, pretty_print) + outfile.write('<%s%s%s' % (namespace_, name_, namespacedef_ and ' ' + namespacedef_ or '', )) + already_processed = [] + self.exportAttributes(outfile, level, already_processed, namespace_, name_='QuotaType') + if self.hasContent_(): + outfile.write('>%s' % (eol_, )) + self.exportChildren(outfile, level + 1, namespace_, name_, pretty_print=pretty_print) + showIndent(outfile, level, pretty_print) + outfile.write('</%s%s>%s' % (namespace_, name_, eol_)) + else: + outfile.write('/>%s' % (eol_, )) + def exportAttributes(self, outfile, level, already_processed, namespace_='', name_='QuotaType'): + pass + def exportChildren(self, outfile, level, namespace_='', name_='QuotaType', fromsubclass_=False, pretty_print=True): + if pretty_print: + eol_ = '\n' + else: + eol_ = '' + if self.defaults is not None: + showIndent(outfile, level, pretty_print) + outfile.write('<%sdefaults>%s</%sdefaults>%s' % (namespace_, self.gds_format_integer(self.defaults, input_name='defaults'), namespace_, eol_)) + if self.floating_ip is not None: + showIndent(outfile, level, pretty_print) + outfile.write('<%sfloating-ip>%s</%sfloating-ip>%s' % (namespace_, self.gds_format_integer(self.floating_ip, input_name='floating-ip'), namespace_, eol_)) + if self.instance_ip is not None: + showIndent(outfile, level, pretty_print) + outfile.write('<%sinstance-ip>%s</%sinstance-ip>%s' % (namespace_, self.gds_format_integer(self.instance_ip, input_name='instance-ip'), namespace_, eol_)) + if self.virtual_machine_interface is not None: + showIndent(outfile, level, pretty_print) + outfile.write('<%svirtual-machine-interface>%s</%svirtual-machine-interface>%s' % (namespace_, self.gds_format_integer(self.virtual_machine_interface, input_name='virtual-machine-interface'), namespace_, eol_)) + if self.virtual_network is not None: + showIndent(outfile, level, pretty_print) + outfile.write('<%svirtual-network>%s</%svirtual-network>%s' % (namespace_, self.gds_format_integer(self.virtual_network, input_name='virtual-network'), namespace_, eol_)) + if self.virtual_router is not None: + showIndent(outfile, level, pretty_print) + outfile.write('<%svirtual-router>%s</%svirtual-router>%s' % (namespace_, self.gds_format_integer(self.virtual_router, input_name='virtual-router'), namespace_, eol_)) + if self.virtual_DNS is not None: + showIndent(outfile, level, pretty_print) + outfile.write('<%svirtual-DNS>%s</%svirtual-DNS>%s' % (namespace_, self.gds_format_integer(self.virtual_DNS, input_name='virtual-DNS'), namespace_, eol_)) + if self.virtual_DNS_record is not None: + showIndent(outfile, level, pretty_print) + outfile.write('<%svirtual-DNS-record>%s</%svirtual-DNS-record>%s' % (namespace_, self.gds_format_integer(self.virtual_DNS_record, input_name='virtual-DNS-record'), namespace_, eol_)) + if self.bgp_router is not None: + showIndent(outfile, level, pretty_print) + outfile.write('<%sbgp-router>%s</%sbgp-router>%s' % (namespace_, self.gds_format_integer(self.bgp_router, input_name='bgp-router'), namespace_, eol_)) + if self.network_ipam is not None: + showIndent(outfile, level, pretty_print) + outfile.write('<%snetwork-ipam>%s</%snetwork-ipam>%s' % (namespace_, self.gds_format_integer(self.network_ipam, input_name='network-ipam'), namespace_, eol_)) + if self.access_control_list is not None: + showIndent(outfile, level, pretty_print) + outfile.write('<%saccess-control-list>%s</%saccess-control-list>%s' % (namespace_, self.gds_format_integer(self.access_control_list, input_name='access-control-list'), namespace_, eol_)) + if self.floating_ip_pool is not None: + showIndent(outfile, level, pretty_print) + outfile.write('<%sfloating-ip-pool>%s</%sfloating-ip-pool>%s' % (namespace_, self.gds_format_integer(self.floating_ip_pool, input_name='floating-ip-pool'), namespace_, eol_)) + if self.service_template is not None: + showIndent(outfile, level, pretty_print) + outfile.write('<%sservice-template>%s</%sservice-template>%s' % (namespace_, self.gds_format_integer(self.service_template, input_name='service-template'), namespace_, eol_)) + if self.service_instance is not None: + showIndent(outfile, level, pretty_print) + outfile.write('<%sservice-instance>%s</%sservice-instance>%s' % (namespace_, self.gds_format_integer(self.service_instance, input_name='service-instance'), namespace_, eol_)) + if self.logical_router is not None: + showIndent(outfile, level, pretty_print) + outfile.write('<%slogical-router>%s</%slogical-router>%s' % (namespace_, self.gds_format_integer(self.logical_router, input_name='logical-router'), namespace_, eol_)) + if self.security_group is not None: + showIndent(outfile, level, pretty_print) + outfile.write('<%ssecurity-group>%s</%ssecurity-group>%s' % (namespace_, self.gds_format_integer(self.security_group, input_name='security-group'), namespace_, eol_)) + if self.security_group_rule is not None: + showIndent(outfile, level, pretty_print) + outfile.write('<%ssecurity-group-rule>%s</%ssecurity-group-rule>%s' % (namespace_, self.gds_format_integer(self.security_group_rule, input_name='security-group-rule'), namespace_, eol_)) + if self.subnet is not None: + showIndent(outfile, level, pretty_print) + outfile.write('<%ssubnet>%s</%ssubnet>%s' % (namespace_, self.gds_format_integer(self.subnet, input_name='subnet'), namespace_, eol_)) + if self.global_vrouter_config is not None: + showIndent(outfile, level, pretty_print) + outfile.write('<%sglobal-vrouter-config>%s</%sglobal-vrouter-config>%s' % (namespace_, self.gds_format_integer(self.global_vrouter_config, input_name='global-vrouter-config'), namespace_, eol_)) + if self.loadbalancer_pool is not None: + showIndent(outfile, level, pretty_print) + outfile.write('<%sloadbalancer-pool>%s</%sloadbalancer-pool>%s' % (namespace_, self.gds_format_integer(self.loadbalancer_pool, input_name='loadbalancer-pool'), namespace_, eol_)) + if self.loadbalancer_member is not None: + showIndent(outfile, level, pretty_print) + outfile.write('<%sloadbalancer-member>%s</%sloadbalancer-member>%s' % (namespace_, self.gds_format_integer(self.loadbalancer_member, input_name='loadbalancer-member'), namespace_, eol_)) + if self.loadbalancer_healthmonitor is not None: + showIndent(outfile, level, pretty_print) + outfile.write('<%sloadbalancer-healthmonitor>%s</%sloadbalancer-healthmonitor>%s' % (namespace_, self.gds_format_integer(self.loadbalancer_healthmonitor, input_name='loadbalancer-healthmonitor'), namespace_, eol_)) + if self.virtual_ip is not None: + showIndent(outfile, level, pretty_print) + outfile.write('<%svirtual-ip>%s</%svirtual-ip>%s' % (namespace_, self.gds_format_integer(self.virtual_ip, input_name='virtual-ip'), namespace_, eol_)) + def hasContent_(self): + if ( + self.defaults is not None or + self.floating_ip is not None or + self.instance_ip is not None or + self.virtual_machine_interface is not None or + self.virtual_network is not None or + self.virtual_router is not None or + self.virtual_DNS is not None or + self.virtual_DNS_record is not None or + self.bgp_router is not None or + self.network_ipam is not None or + self.access_control_list is not None or + self.floating_ip_pool is not None or + self.service_template is not None or + self.service_instance is not None or + self.logical_router is not None or + self.security_group is not None or + self.security_group_rule is not None or + self.subnet is not None or + self.global_vrouter_config is not None or + self.loadbalancer_pool is not None or + self.loadbalancer_member is not None or + self.loadbalancer_healthmonitor is not None or + self.virtual_ip is not None + ): + return True + else: + return False + def exportLiteral(self, outfile, level, name_='QuotaType'): + level += 1 + self.exportLiteralAttributes(outfile, level, [], name_) + if self.hasContent_(): + self.exportLiteralChildren(outfile, level, name_) + def exportLiteralAttributes(self, outfile, level, already_processed, name_): + pass + def exportLiteralChildren(self, outfile, level, name_): + if self.defaults is not None: + showIndent(outfile, level) + outfile.write('defaults=%d,\n' % self.defaults) + if self.floating_ip is not None: + showIndent(outfile, level) + outfile.write('floating_ip=%d,\n' % self.floating_ip) + if self.instance_ip is not None: + showIndent(outfile, level) + outfile.write('instance_ip=%d,\n' % self.instance_ip) + if self.virtual_machine_interface is not None: + showIndent(outfile, level) + outfile.write('virtual_machine_interface=%d,\n' % self.virtual_machine_interface) + if self.virtual_network is not None: + showIndent(outfile, level) + outfile.write('virtual_network=%d,\n' % self.virtual_network) + if self.virtual_router is not None: + showIndent(outfile, level) + outfile.write('virtual_router=%d,\n' % self.virtual_router) + if self.virtual_DNS is not None: + showIndent(outfile, level) + outfile.write('virtual_DNS=%d,\n' % self.virtual_DNS) + if self.virtual_DNS_record is not None: + showIndent(outfile, level) + outfile.write('virtual_DNS_record=%d,\n' % self.virtual_DNS_record) + if self.bgp_router is not None: + showIndent(outfile, level) + outfile.write('bgp_router=%d,\n' % self.bgp_router) + if self.network_ipam is not None: + showIndent(outfile, level) + outfile.write('network_ipam=%d,\n' % self.network_ipam) + if self.access_control_list is not None: + showIndent(outfile, level) + outfile.write('access_control_list=%d,\n' % self.access_control_list) + if self.floating_ip_pool is not None: + showIndent(outfile, level) + outfile.write('floating_ip_pool=%d,\n' % self.floating_ip_pool) + if self.service_template is not None: + showIndent(outfile, level) + outfile.write('service_template=%d,\n' % self.service_template) + if self.service_instance is not None: + showIndent(outfile, level) + outfile.write('service_instance=%d,\n' % self.service_instance) + if self.logical_router is not None: + showIndent(outfile, level) + outfile.write('logical_router=%d,\n' % self.logical_router) + if self.security_group is not None: + showIndent(outfile, level) + outfile.write('security_group=%d,\n' % self.security_group) + if self.security_group_rule is not None: + showIndent(outfile, level) + outfile.write('security_group_rule=%d,\n' % self.security_group_rule) + if self.subnet is not None: + showIndent(outfile, level) + outfile.write('subnet=%d,\n' % self.subnet) + if self.global_vrouter_config is not None: + showIndent(outfile, level) + outfile.write('global_vrouter_config=%d,\n' % self.global_vrouter_config) + if self.loadbalancer_pool is not None: + showIndent(outfile, level) + outfile.write('loadbalancer_pool=%d,\n' % self.loadbalancer_pool) + if self.loadbalancer_member is not None: + showIndent(outfile, level) + outfile.write('loadbalancer_member=%d,\n' % self.loadbalancer_member) + if self.loadbalancer_healthmonitor is not None: + showIndent(outfile, level) + outfile.write('loadbalancer_healthmonitor=%d,\n' % self.loadbalancer_healthmonitor) + if self.virtual_ip is not None: + showIndent(outfile, level) + outfile.write('virtual_ip=%d,\n' % self.virtual_ip) + def exportDict(self, name_='QuotaType'): + obj_json = json.dumps(self, default=lambda o: dict((k, v) for k, v in o.__dict__.iteritems())) + obj_dict = json.loads(obj_json) + return {name_: obj_dict} + def build(self, node): + self.buildAttributes(node, node.attrib, []) + for child in node: + nodeName_ = Tag_pattern_.match(child.tag).groups()[-1] + self.buildChildren(child, node, nodeName_) + def buildAttributes(self, node, attrs, already_processed): + pass + def buildChildren(self, child_, node, nodeName_, fromsubclass_=False): + if nodeName_ == 'defaults': + sval_ = child_.text + try: + ival_ = int(sval_) + except (TypeError, ValueError), exp: + raise_parse_error(child_, 'requires integer: %s' % exp) + ival_ = self.gds_validate_integer(ival_, node, 'defaults') + self.defaults = ival_ + elif nodeName_ == 'floating-ip': + sval_ = child_.text + try: + ival_ = int(sval_) + except (TypeError, ValueError), exp: + raise_parse_error(child_, 'requires integer: %s' % exp) + ival_ = self.gds_validate_integer(ival_, node, 'floating_ip') + self.floating_ip = ival_ + elif nodeName_ == 'instance-ip': + sval_ = child_.text + try: + ival_ = int(sval_) + except (TypeError, ValueError), exp: + raise_parse_error(child_, 'requires integer: %s' % exp) + ival_ = self.gds_validate_integer(ival_, node, 'instance_ip') + self.instance_ip = ival_ + elif nodeName_ == 'virtual-machine-interface': + sval_ = child_.text + try: + ival_ = int(sval_) + except (TypeError, ValueError), exp: + raise_parse_error(child_, 'requires integer: %s' % exp) + ival_ = self.gds_validate_integer(ival_, node, 'virtual_machine_interface') + self.virtual_machine_interface = ival_ + elif nodeName_ == 'virtual-network': + sval_ = child_.text + try: + ival_ = int(sval_) + except (TypeError, ValueError), exp: + raise_parse_error(child_, 'requires integer: %s' % exp) + ival_ = self.gds_validate_integer(ival_, node, 'virtual_network') + self.virtual_network = ival_ + elif nodeName_ == 'virtual-router': + sval_ = child_.text + try: + ival_ = int(sval_) + except (TypeError, ValueError), exp: + raise_parse_error(child_, 'requires integer: %s' % exp) + ival_ = self.gds_validate_integer(ival_, node, 'virtual_router') + self.virtual_router = ival_ + elif nodeName_ == 'virtual-DNS': + sval_ = child_.text + try: + ival_ = int(sval_) + except (TypeError, ValueError), exp: + raise_parse_error(child_, 'requires integer: %s' % exp) + ival_ = self.gds_validate_integer(ival_, node, 'virtual_DNS') + self.virtual_DNS = ival_ + elif nodeName_ == 'virtual-DNS-record': + sval_ = child_.text + try: + ival_ = int(sval_) + except (TypeError, ValueError), exp: + raise_parse_error(child_, 'requires integer: %s' % exp) + ival_ = self.gds_validate_integer(ival_, node, 'virtual_DNS_record') + self.virtual_DNS_record = ival_ + elif nodeName_ == 'bgp-router': + sval_ = child_.text + try: + ival_ = int(sval_) + except (TypeError, ValueError), exp: + raise_parse_error(child_, 'requires integer: %s' % exp) + ival_ = self.gds_validate_integer(ival_, node, 'bgp_router') + self.bgp_router = ival_ + elif nodeName_ == 'network-ipam': + sval_ = child_.text + try: + ival_ = int(sval_) + except (TypeError, ValueError), exp: + raise_parse_error(child_, 'requires integer: %s' % exp) + ival_ = self.gds_validate_integer(ival_, node, 'network_ipam') + self.network_ipam = ival_ + elif nodeName_ == 'access-control-list': + sval_ = child_.text + try: + ival_ = int(sval_) + except (TypeError, ValueError), exp: + raise_parse_error(child_, 'requires integer: %s' % exp) + ival_ = self.gds_validate_integer(ival_, node, 'access_control_list') + self.access_control_list = ival_ + elif nodeName_ == 'floating-ip-pool': + sval_ = child_.text + try: + ival_ = int(sval_) + except (TypeError, ValueError), exp: + raise_parse_error(child_, 'requires integer: %s' % exp) + ival_ = self.gds_validate_integer(ival_, node, 'floating_ip_pool') + self.floating_ip_pool = ival_ + elif nodeName_ == 'service-template': + sval_ = child_.text + try: + ival_ = int(sval_) + except (TypeError, ValueError), exp: + raise_parse_error(child_, 'requires integer: %s' % exp) + ival_ = self.gds_validate_integer(ival_, node, 'service_template') + self.service_template = ival_ + elif nodeName_ == 'service-instance': + sval_ = child_.text + try: + ival_ = int(sval_) + except (TypeError, ValueError), exp: + raise_parse_error(child_, 'requires integer: %s' % exp) + ival_ = self.gds_validate_integer(ival_, node, 'service_instance') + self.service_instance = ival_ + elif nodeName_ == 'logical-router': + sval_ = child_.text + try: + ival_ = int(sval_) + except (TypeError, ValueError), exp: + raise_parse_error(child_, 'requires integer: %s' % exp) + ival_ = self.gds_validate_integer(ival_, node, 'logical_router') + self.logical_router = ival_ + elif nodeName_ == 'security-group': + sval_ = child_.text + try: + ival_ = int(sval_) + except (TypeError, ValueError), exp: + raise_parse_error(child_, 'requires integer: %s' % exp) + ival_ = self.gds_validate_integer(ival_, node, 'security_group') + self.security_group = ival_ + elif nodeName_ == 'security-group-rule': + sval_ = child_.text + try: + ival_ = int(sval_) + except (TypeError, ValueError), exp: + raise_parse_error(child_, 'requires integer: %s' % exp) + ival_ = self.gds_validate_integer(ival_, node, 'security_group_rule') + self.security_group_rule = ival_ + elif nodeName_ == 'subnet': + sval_ = child_.text + try: + ival_ = int(sval_) + except (TypeError, ValueError), exp: + raise_parse_error(child_, 'requires integer: %s' % exp) + ival_ = self.gds_validate_integer(ival_, node, 'subnet') + self.subnet = ival_ + elif nodeName_ == 'global-vrouter-config': + sval_ = child_.text + try: + ival_ = int(sval_) + except (TypeError, ValueError), exp: + raise_parse_error(child_, 'requires integer: %s' % exp) + ival_ = self.gds_validate_integer(ival_, node, 'global_vrouter_config') + self.global_vrouter_config = ival_ + elif nodeName_ == 'loadbalancer-pool': + sval_ = child_.text + try: + ival_ = int(sval_) + except (TypeError, ValueError), exp: + raise_parse_error(child_, 'requires integer: %s' % exp) + ival_ = self.gds_validate_integer(ival_, node, 'loadbalancer_pool') + self.loadbalancer_pool = ival_ + elif nodeName_ == 'loadbalancer-member': + sval_ = child_.text + try: + ival_ = int(sval_) + except (TypeError, ValueError), exp: + raise_parse_error(child_, 'requires integer: %s' % exp) + ival_ = self.gds_validate_integer(ival_, node, 'loadbalancer_member') + self.loadbalancer_member = ival_ + elif nodeName_ == 'loadbalancer-healthmonitor': + sval_ = child_.text + try: + ival_ = int(sval_) + except (TypeError, ValueError), exp: + raise_parse_error(child_, 'requires integer: %s' % exp) + ival_ = self.gds_validate_integer(ival_, node, 'loadbalancer_healthmonitor') + self.loadbalancer_healthmonitor = ival_ + elif nodeName_ == 'virtual-ip': + sval_ = child_.text + try: + ival_ = int(sval_) + except (TypeError, ValueError), exp: + raise_parse_error(child_, 'requires integer: %s' % exp) + ival_ = self.gds_validate_integer(ival_, node, 'virtual_ip') + self.virtual_ip = ival_ +# end class QuotaType + + +class config_root_global_system_config(GeneratedsSuper): + """ + config_root_global_system_config class definition from :doc:`vnc_cfg.xsd` + """ + subclass = None + superclass = None + def __init__(self, **kwargs): + pass + def factory(*args_, **kwargs_): + if config_root_global_system_config.subclass: + return config_root_global_system_config.subclass(*args_, **kwargs_) + else: + return config_root_global_system_config(*args_, **kwargs_) + factory = staticmethod(factory) + def __eq__(self, other): return True + def __ne__(self, other): return False + @classmethod + def populate (cls, *a, **kwa): + obj = cls (*a, **kwa) + return obj + def export(self, outfile, level=1, namespace_='', name_='config-root-global-system-config', namespacedef_='', pretty_print=True): + if pretty_print: + eol_ = '\n' + else: + eol_ = '' + showIndent(outfile, level, pretty_print) + outfile.write('<%s%s%s' % (namespace_, name_, namespacedef_ and ' ' + namespacedef_ or '', )) + already_processed = [] + self.exportAttributes(outfile, level, already_processed, namespace_, name_='config-root-global-system-config') + if self.hasContent_(): + outfile.write('>%s' % (eol_, )) + self.exportChildren(outfile, level + 1, namespace_, name_, pretty_print=pretty_print) + outfile.write('</%s%s>%s' % (namespace_, name_, eol_)) + else: + outfile.write('/>%s' % (eol_, )) + def exportAttributes(self, outfile, level, already_processed, namespace_='', name_='config-root-global-system-config'): + pass + def exportChildren(self, outfile, level, namespace_='', name_='config-root-global-system-config', fromsubclass_=False, pretty_print=True): + pass + def hasContent_(self): + if ( + + ): + return True + else: + return False + def exportLiteral(self, outfile, level, name_='config-root-global-system-config'): + level += 1 + self.exportLiteralAttributes(outfile, level, [], name_) + if self.hasContent_(): + self.exportLiteralChildren(outfile, level, name_) + def exportLiteralAttributes(self, outfile, level, already_processed, name_): + pass + def exportLiteralChildren(self, outfile, level, name_): + pass + def exportDict(self, name_='config-root-global-system-config'): + obj_json = json.dumps(self, default=lambda o: dict((k, v) for k, v in o.__dict__.iteritems())) + obj_dict = json.loads(obj_json) + return {name_: obj_dict} + def build(self, node): + self.buildAttributes(node, node.attrib, []) + for child in node: + nodeName_ = Tag_pattern_.match(child.tag).groups()[-1] + self.buildChildren(child, node, nodeName_) + def buildAttributes(self, node, attrs, already_processed): + pass + def buildChildren(self, child_, node, nodeName_, fromsubclass_=False): + pass +# end class config_root_global_system_config + + +class global_system_config_bgp_router(GeneratedsSuper): + """ + global_system_config_bgp_router class definition from :doc:`vnc_cfg.xsd` + """ + subclass = None + superclass = None + def __init__(self, **kwargs): + pass + def factory(*args_, **kwargs_): + if global_system_config_bgp_router.subclass: + return global_system_config_bgp_router.subclass(*args_, **kwargs_) + else: + return global_system_config_bgp_router(*args_, **kwargs_) + factory = staticmethod(factory) + def __eq__(self, other): return True + def __ne__(self, other): return False + @classmethod + def populate (cls, *a, **kwa): + obj = cls (*a, **kwa) + return obj + def export(self, outfile, level=1, namespace_='', name_='global-system-config-bgp-router', namespacedef_='', pretty_print=True): + if pretty_print: + eol_ = '\n' + else: + eol_ = '' + showIndent(outfile, level, pretty_print) + outfile.write('<%s%s%s' % (namespace_, name_, namespacedef_ and ' ' + namespacedef_ or '', )) + already_processed = [] + self.exportAttributes(outfile, level, already_processed, namespace_, name_='global-system-config-bgp-router') + if self.hasContent_(): + outfile.write('>%s' % (eol_, )) + self.exportChildren(outfile, level + 1, namespace_, name_, pretty_print=pretty_print) + outfile.write('</%s%s>%s' % (namespace_, name_, eol_)) + else: + outfile.write('/>%s' % (eol_, )) + def exportAttributes(self, outfile, level, already_processed, namespace_='', name_='global-system-config-bgp-router'): + pass + def exportChildren(self, outfile, level, namespace_='', name_='global-system-config-bgp-router', fromsubclass_=False, pretty_print=True): + pass + def hasContent_(self): + if ( + + ): + return True + else: + return False + def exportLiteral(self, outfile, level, name_='global-system-config-bgp-router'): + level += 1 + self.exportLiteralAttributes(outfile, level, [], name_) + if self.hasContent_(): + self.exportLiteralChildren(outfile, level, name_) + def exportLiteralAttributes(self, outfile, level, already_processed, name_): + pass + def exportLiteralChildren(self, outfile, level, name_): + pass + def exportDict(self, name_='global-system-config-bgp-router'): + obj_json = json.dumps(self, default=lambda o: dict((k, v) for k, v in o.__dict__.iteritems())) + obj_dict = json.loads(obj_json) + return {name_: obj_dict} + def build(self, node): + self.buildAttributes(node, node.attrib, []) + for child in node: + nodeName_ = Tag_pattern_.match(child.tag).groups()[-1] + self.buildChildren(child, node, nodeName_) + def buildAttributes(self, node, attrs, already_processed): + pass + def buildChildren(self, child_, node, nodeName_, fromsubclass_=False): + pass +# end class global_system_config_bgp_router + + +class global_system_config_global_vrouter_config(GeneratedsSuper): + """ + global_system_config_global_vrouter_config class definition from :doc:`vnc_cfg.xsd` + """ + subclass = None + superclass = None + def __init__(self, **kwargs): + pass + def factory(*args_, **kwargs_): + if global_system_config_global_vrouter_config.subclass: + return global_system_config_global_vrouter_config.subclass(*args_, **kwargs_) + else: + return global_system_config_global_vrouter_config(*args_, **kwargs_) + factory = staticmethod(factory) + def __eq__(self, other): return True + def __ne__(self, other): return False + @classmethod + def populate (cls, *a, **kwa): + obj = cls (*a, **kwa) + return obj + def export(self, outfile, level=1, namespace_='', name_='global-system-config-global-vrouter-config', namespacedef_='', pretty_print=True): + if pretty_print: + eol_ = '\n' + else: + eol_ = '' + showIndent(outfile, level, pretty_print) + outfile.write('<%s%s%s' % (namespace_, name_, namespacedef_ and ' ' + namespacedef_ or '', )) + already_processed = [] + self.exportAttributes(outfile, level, already_processed, namespace_, name_='global-system-config-global-vrouter-config') + if self.hasContent_(): + outfile.write('>%s' % (eol_, )) + self.exportChildren(outfile, level + 1, namespace_, name_, pretty_print=pretty_print) + outfile.write('</%s%s>%s' % (namespace_, name_, eol_)) + else: + outfile.write('/>%s' % (eol_, )) + def exportAttributes(self, outfile, level, already_processed, namespace_='', name_='global-system-config-global-vrouter-config'): + pass + def exportChildren(self, outfile, level, namespace_='', name_='global-system-config-global-vrouter-config', fromsubclass_=False, pretty_print=True): + pass + def hasContent_(self): + if ( + + ): + return True + else: + return False + def exportLiteral(self, outfile, level, name_='global-system-config-global-vrouter-config'): + level += 1 + self.exportLiteralAttributes(outfile, level, [], name_) + if self.hasContent_(): + self.exportLiteralChildren(outfile, level, name_) + def exportLiteralAttributes(self, outfile, level, already_processed, name_): + pass + def exportLiteralChildren(self, outfile, level, name_): + pass + def exportDict(self, name_='global-system-config-global-vrouter-config'): + obj_json = json.dumps(self, default=lambda o: dict((k, v) for k, v in o.__dict__.iteritems())) + obj_dict = json.loads(obj_json) + return {name_: obj_dict} + def build(self, node): + self.buildAttributes(node, node.attrib, []) + for child in node: + nodeName_ = Tag_pattern_.match(child.tag).groups()[-1] + self.buildChildren(child, node, nodeName_) + def buildAttributes(self, node, attrs, already_processed): + pass + def buildChildren(self, child_, node, nodeName_, fromsubclass_=False): + pass +# end class global_system_config_global_vrouter_config + + +class config_root_domain(GeneratedsSuper): + """ + config_root_domain class definition from :doc:`vnc_cfg.xsd` + """ + subclass = None + superclass = None + def __init__(self, **kwargs): + pass + def factory(*args_, **kwargs_): + if config_root_domain.subclass: + return config_root_domain.subclass(*args_, **kwargs_) + else: + return config_root_domain(*args_, **kwargs_) + factory = staticmethod(factory) + def __eq__(self, other): return True + def __ne__(self, other): return False + @classmethod + def populate (cls, *a, **kwa): + obj = cls (*a, **kwa) + return obj + def export(self, outfile, level=1, namespace_='', name_='config-root-domain', namespacedef_='', pretty_print=True): + if pretty_print: + eol_ = '\n' + else: + eol_ = '' + showIndent(outfile, level, pretty_print) + outfile.write('<%s%s%s' % (namespace_, name_, namespacedef_ and ' ' + namespacedef_ or '', )) + already_processed = [] + self.exportAttributes(outfile, level, already_processed, namespace_, name_='config-root-domain') + if self.hasContent_(): + outfile.write('>%s' % (eol_, )) + self.exportChildren(outfile, level + 1, namespace_, name_, pretty_print=pretty_print) + outfile.write('</%s%s>%s' % (namespace_, name_, eol_)) + else: + outfile.write('/>%s' % (eol_, )) + def exportAttributes(self, outfile, level, already_processed, namespace_='', name_='config-root-domain'): + pass + def exportChildren(self, outfile, level, namespace_='', name_='config-root-domain', fromsubclass_=False, pretty_print=True): + pass + def hasContent_(self): + if ( + + ): + return True + else: + return False + def exportLiteral(self, outfile, level, name_='config-root-domain'): + level += 1 + self.exportLiteralAttributes(outfile, level, [], name_) + if self.hasContent_(): + self.exportLiteralChildren(outfile, level, name_) + def exportLiteralAttributes(self, outfile, level, already_processed, name_): + pass + def exportLiteralChildren(self, outfile, level, name_): + pass + def exportDict(self, name_='config-root-domain'): + obj_json = json.dumps(self, default=lambda o: dict((k, v) for k, v in o.__dict__.iteritems())) + obj_dict = json.loads(obj_json) + return {name_: obj_dict} + def build(self, node): + self.buildAttributes(node, node.attrib, []) + for child in node: + nodeName_ = Tag_pattern_.match(child.tag).groups()[-1] + self.buildChildren(child, node, nodeName_) + def buildAttributes(self, node, attrs, already_processed): + pass + def buildChildren(self, child_, node, nodeName_, fromsubclass_=False): + pass +# end class config_root_domain + + +class domain_project(GeneratedsSuper): + """ + domain_project class definition from :doc:`vnc_cfg.xsd` + """ + subclass = None + superclass = None + def __init__(self, **kwargs): + pass + def factory(*args_, **kwargs_): + if domain_project.subclass: + return domain_project.subclass(*args_, **kwargs_) + else: + return domain_project(*args_, **kwargs_) + factory = staticmethod(factory) + def __eq__(self, other): return True + def __ne__(self, other): return False + @classmethod + def populate (cls, *a, **kwa): + obj = cls (*a, **kwa) + return obj + def export(self, outfile, level=1, namespace_='', name_='domain-project', namespacedef_='', pretty_print=True): + if pretty_print: + eol_ = '\n' + else: + eol_ = '' + showIndent(outfile, level, pretty_print) + outfile.write('<%s%s%s' % (namespace_, name_, namespacedef_ and ' ' + namespacedef_ or '', )) + already_processed = [] + self.exportAttributes(outfile, level, already_processed, namespace_, name_='domain-project') + if self.hasContent_(): + outfile.write('>%s' % (eol_, )) + self.exportChildren(outfile, level + 1, namespace_, name_, pretty_print=pretty_print) + outfile.write('</%s%s>%s' % (namespace_, name_, eol_)) + else: + outfile.write('/>%s' % (eol_, )) + def exportAttributes(self, outfile, level, already_processed, namespace_='', name_='domain-project'): + pass + def exportChildren(self, outfile, level, namespace_='', name_='domain-project', fromsubclass_=False, pretty_print=True): + pass + def hasContent_(self): + if ( + + ): + return True + else: + return False + def exportLiteral(self, outfile, level, name_='domain-project'): + level += 1 + self.exportLiteralAttributes(outfile, level, [], name_) + if self.hasContent_(): + self.exportLiteralChildren(outfile, level, name_) + def exportLiteralAttributes(self, outfile, level, already_processed, name_): + pass + def exportLiteralChildren(self, outfile, level, name_): + pass + def exportDict(self, name_='domain-project'): + obj_json = json.dumps(self, default=lambda o: dict((k, v) for k, v in o.__dict__.iteritems())) + obj_dict = json.loads(obj_json) + return {name_: obj_dict} + def build(self, node): + self.buildAttributes(node, node.attrib, []) + for child in node: + nodeName_ = Tag_pattern_.match(child.tag).groups()[-1] + self.buildChildren(child, node, nodeName_) + def buildAttributes(self, node, attrs, already_processed): + pass + def buildChildren(self, child_, node, nodeName_, fromsubclass_=False): + pass +# end class domain_project + + +class domain_namespace(GeneratedsSuper): + """ + domain_namespace class definition from :doc:`vnc_cfg.xsd` + """ + subclass = None + superclass = None + def __init__(self, **kwargs): + pass + def factory(*args_, **kwargs_): + if domain_namespace.subclass: + return domain_namespace.subclass(*args_, **kwargs_) + else: + return domain_namespace(*args_, **kwargs_) + factory = staticmethod(factory) + def __eq__(self, other): return True + def __ne__(self, other): return False + @classmethod + def populate (cls, *a, **kwa): + obj = cls (*a, **kwa) + return obj + def export(self, outfile, level=1, namespace_='', name_='domain-namespace', namespacedef_='', pretty_print=True): + if pretty_print: + eol_ = '\n' + else: + eol_ = '' + showIndent(outfile, level, pretty_print) + outfile.write('<%s%s%s' % (namespace_, name_, namespacedef_ and ' ' + namespacedef_ or '', )) + already_processed = [] + self.exportAttributes(outfile, level, already_processed, namespace_, name_='domain-namespace') + if self.hasContent_(): + outfile.write('>%s' % (eol_, )) + self.exportChildren(outfile, level + 1, namespace_, name_, pretty_print=pretty_print) + outfile.write('</%s%s>%s' % (namespace_, name_, eol_)) + else: + outfile.write('/>%s' % (eol_, )) + def exportAttributes(self, outfile, level, already_processed, namespace_='', name_='domain-namespace'): + pass + def exportChildren(self, outfile, level, namespace_='', name_='domain-namespace', fromsubclass_=False, pretty_print=True): + pass + def hasContent_(self): + if ( + + ): + return True + else: + return False + def exportLiteral(self, outfile, level, name_='domain-namespace'): + level += 1 + self.exportLiteralAttributes(outfile, level, [], name_) + if self.hasContent_(): + self.exportLiteralChildren(outfile, level, name_) + def exportLiteralAttributes(self, outfile, level, already_processed, name_): + pass + def exportLiteralChildren(self, outfile, level, name_): + pass + def exportDict(self, name_='domain-namespace'): + obj_json = json.dumps(self, default=lambda o: dict((k, v) for k, v in o.__dict__.iteritems())) + obj_dict = json.loads(obj_json) + return {name_: obj_dict} + def build(self, node): + self.buildAttributes(node, node.attrib, []) + for child in node: + nodeName_ = Tag_pattern_.match(child.tag).groups()[-1] + self.buildChildren(child, node, nodeName_) + def buildAttributes(self, node, attrs, already_processed): + pass + def buildChildren(self, child_, node, nodeName_, fromsubclass_=False): + pass +# end class domain_namespace + + +class project_security_group(GeneratedsSuper): + """ + project_security_group class definition from :doc:`vnc_cfg.xsd` + """ + subclass = None + superclass = None + def __init__(self, **kwargs): + pass + def factory(*args_, **kwargs_): + if project_security_group.subclass: + return project_security_group.subclass(*args_, **kwargs_) + else: + return project_security_group(*args_, **kwargs_) + factory = staticmethod(factory) + def __eq__(self, other): return True + def __ne__(self, other): return False + @classmethod + def populate (cls, *a, **kwa): + obj = cls (*a, **kwa) + return obj + def export(self, outfile, level=1, namespace_='', name_='project-security-group', namespacedef_='', pretty_print=True): + if pretty_print: + eol_ = '\n' + else: + eol_ = '' + showIndent(outfile, level, pretty_print) + outfile.write('<%s%s%s' % (namespace_, name_, namespacedef_ and ' ' + namespacedef_ or '', )) + already_processed = [] + self.exportAttributes(outfile, level, already_processed, namespace_, name_='project-security-group') + if self.hasContent_(): + outfile.write('>%s' % (eol_, )) + self.exportChildren(outfile, level + 1, namespace_, name_, pretty_print=pretty_print) + outfile.write('</%s%s>%s' % (namespace_, name_, eol_)) + else: + outfile.write('/>%s' % (eol_, )) + def exportAttributes(self, outfile, level, already_processed, namespace_='', name_='project-security-group'): + pass + def exportChildren(self, outfile, level, namespace_='', name_='project-security-group', fromsubclass_=False, pretty_print=True): + pass + def hasContent_(self): + if ( + + ): + return True + else: + return False + def exportLiteral(self, outfile, level, name_='project-security-group'): + level += 1 + self.exportLiteralAttributes(outfile, level, [], name_) + if self.hasContent_(): + self.exportLiteralChildren(outfile, level, name_) + def exportLiteralAttributes(self, outfile, level, already_processed, name_): + pass + def exportLiteralChildren(self, outfile, level, name_): + pass + def exportDict(self, name_='project-security-group'): + obj_json = json.dumps(self, default=lambda o: dict((k, v) for k, v in o.__dict__.iteritems())) + obj_dict = json.loads(obj_json) + return {name_: obj_dict} + def build(self, node): + self.buildAttributes(node, node.attrib, []) + for child in node: + nodeName_ = Tag_pattern_.match(child.tag).groups()[-1] + self.buildChildren(child, node, nodeName_) + def buildAttributes(self, node, attrs, already_processed): + pass + def buildChildren(self, child_, node, nodeName_, fromsubclass_=False): + pass +# end class project_security_group + + +class project_virtual_network(GeneratedsSuper): + """ + project_virtual_network class definition from :doc:`vnc_cfg.xsd` + """ + subclass = None + superclass = None + def __init__(self, **kwargs): + pass + def factory(*args_, **kwargs_): + if project_virtual_network.subclass: + return project_virtual_network.subclass(*args_, **kwargs_) + else: + return project_virtual_network(*args_, **kwargs_) + factory = staticmethod(factory) + def __eq__(self, other): return True + def __ne__(self, other): return False + @classmethod + def populate (cls, *a, **kwa): + obj = cls (*a, **kwa) + return obj + def export(self, outfile, level=1, namespace_='', name_='project-virtual-network', namespacedef_='', pretty_print=True): + if pretty_print: + eol_ = '\n' + else: + eol_ = '' + showIndent(outfile, level, pretty_print) + outfile.write('<%s%s%s' % (namespace_, name_, namespacedef_ and ' ' + namespacedef_ or '', )) + already_processed = [] + self.exportAttributes(outfile, level, already_processed, namespace_, name_='project-virtual-network') + if self.hasContent_(): + outfile.write('>%s' % (eol_, )) + self.exportChildren(outfile, level + 1, namespace_, name_, pretty_print=pretty_print) + outfile.write('</%s%s>%s' % (namespace_, name_, eol_)) + else: + outfile.write('/>%s' % (eol_, )) + def exportAttributes(self, outfile, level, already_processed, namespace_='', name_='project-virtual-network'): + pass + def exportChildren(self, outfile, level, namespace_='', name_='project-virtual-network', fromsubclass_=False, pretty_print=True): + pass + def hasContent_(self): + if ( + + ): + return True + else: + return False + def exportLiteral(self, outfile, level, name_='project-virtual-network'): + level += 1 + self.exportLiteralAttributes(outfile, level, [], name_) + if self.hasContent_(): + self.exportLiteralChildren(outfile, level, name_) + def exportLiteralAttributes(self, outfile, level, already_processed, name_): + pass + def exportLiteralChildren(self, outfile, level, name_): + pass + def exportDict(self, name_='project-virtual-network'): + obj_json = json.dumps(self, default=lambda o: dict((k, v) for k, v in o.__dict__.iteritems())) + obj_dict = json.loads(obj_json) + return {name_: obj_dict} + def build(self, node): + self.buildAttributes(node, node.attrib, []) + for child in node: + nodeName_ = Tag_pattern_.match(child.tag).groups()[-1] + self.buildChildren(child, node, nodeName_) + def buildAttributes(self, node, attrs, already_processed): + pass + def buildChildren(self, child_, node, nodeName_, fromsubclass_=False): + pass +# end class project_virtual_network + + +class project_qos_queue(GeneratedsSuper): + """ + project_qos_queue class definition from :doc:`vnc_cfg.xsd` + """ + subclass = None + superclass = None + def __init__(self, **kwargs): + pass + def factory(*args_, **kwargs_): + if project_qos_queue.subclass: + return project_qos_queue.subclass(*args_, **kwargs_) + else: + return project_qos_queue(*args_, **kwargs_) + factory = staticmethod(factory) + def __eq__(self, other): return True + def __ne__(self, other): return False + @classmethod + def populate (cls, *a, **kwa): + obj = cls (*a, **kwa) + return obj + def export(self, outfile, level=1, namespace_='', name_='project-qos-queue', namespacedef_='', pretty_print=True): + if pretty_print: + eol_ = '\n' + else: + eol_ = '' + showIndent(outfile, level, pretty_print) + outfile.write('<%s%s%s' % (namespace_, name_, namespacedef_ and ' ' + namespacedef_ or '', )) + already_processed = [] + self.exportAttributes(outfile, level, already_processed, namespace_, name_='project-qos-queue') + if self.hasContent_(): + outfile.write('>%s' % (eol_, )) + self.exportChildren(outfile, level + 1, namespace_, name_, pretty_print=pretty_print) + outfile.write('</%s%s>%s' % (namespace_, name_, eol_)) + else: + outfile.write('/>%s' % (eol_, )) + def exportAttributes(self, outfile, level, already_processed, namespace_='', name_='project-qos-queue'): + pass + def exportChildren(self, outfile, level, namespace_='', name_='project-qos-queue', fromsubclass_=False, pretty_print=True): + pass + def hasContent_(self): + if ( + + ): + return True + else: + return False + def exportLiteral(self, outfile, level, name_='project-qos-queue'): + level += 1 + self.exportLiteralAttributes(outfile, level, [], name_) + if self.hasContent_(): + self.exportLiteralChildren(outfile, level, name_) + def exportLiteralAttributes(self, outfile, level, already_processed, name_): + pass + def exportLiteralChildren(self, outfile, level, name_): + pass + def exportDict(self, name_='project-qos-queue'): + obj_json = json.dumps(self, default=lambda o: dict((k, v) for k, v in o.__dict__.iteritems())) + obj_dict = json.loads(obj_json) + return {name_: obj_dict} + def build(self, node): + self.buildAttributes(node, node.attrib, []) + for child in node: + nodeName_ = Tag_pattern_.match(child.tag).groups()[-1] + self.buildChildren(child, node, nodeName_) + def buildAttributes(self, node, attrs, already_processed): + pass + def buildChildren(self, child_, node, nodeName_, fromsubclass_=False): + pass +# end class project_qos_queue + + +class project_qos_forwarding_class(GeneratedsSuper): + """ + project_qos_forwarding_class class definition from :doc:`vnc_cfg.xsd` + """ + subclass = None + superclass = None + def __init__(self, **kwargs): + pass + def factory(*args_, **kwargs_): + if project_qos_forwarding_class.subclass: + return project_qos_forwarding_class.subclass(*args_, **kwargs_) + else: + return project_qos_forwarding_class(*args_, **kwargs_) + factory = staticmethod(factory) + def __eq__(self, other): return True + def __ne__(self, other): return False + @classmethod + def populate (cls, *a, **kwa): + obj = cls (*a, **kwa) + return obj + def export(self, outfile, level=1, namespace_='', name_='project-qos-forwarding-class', namespacedef_='', pretty_print=True): + if pretty_print: + eol_ = '\n' + else: + eol_ = '' + showIndent(outfile, level, pretty_print) + outfile.write('<%s%s%s' % (namespace_, name_, namespacedef_ and ' ' + namespacedef_ or '', )) + already_processed = [] + self.exportAttributes(outfile, level, already_processed, namespace_, name_='project-qos-forwarding-class') + if self.hasContent_(): + outfile.write('>%s' % (eol_, )) + self.exportChildren(outfile, level + 1, namespace_, name_, pretty_print=pretty_print) + outfile.write('</%s%s>%s' % (namespace_, name_, eol_)) + else: + outfile.write('/>%s' % (eol_, )) + def exportAttributes(self, outfile, level, already_processed, namespace_='', name_='project-qos-forwarding-class'): + pass + def exportChildren(self, outfile, level, namespace_='', name_='project-qos-forwarding-class', fromsubclass_=False, pretty_print=True): + pass + def hasContent_(self): + if ( + + ): + return True + else: + return False + def exportLiteral(self, outfile, level, name_='project-qos-forwarding-class'): + level += 1 + self.exportLiteralAttributes(outfile, level, [], name_) + if self.hasContent_(): + self.exportLiteralChildren(outfile, level, name_) + def exportLiteralAttributes(self, outfile, level, already_processed, name_): + pass + def exportLiteralChildren(self, outfile, level, name_): + pass + def exportDict(self, name_='project-qos-forwarding-class'): + obj_json = json.dumps(self, default=lambda o: dict((k, v) for k, v in o.__dict__.iteritems())) + obj_dict = json.loads(obj_json) + return {name_: obj_dict} + def build(self, node): + self.buildAttributes(node, node.attrib, []) + for child in node: + nodeName_ = Tag_pattern_.match(child.tag).groups()[-1] + self.buildChildren(child, node, nodeName_) + def buildAttributes(self, node, attrs, already_processed): + pass + def buildChildren(self, child_, node, nodeName_, fromsubclass_=False): + pass +# end class project_qos_forwarding_class + + +class qos_forwarding_class_qos_queue(GeneratedsSuper): + """ + qos_forwarding_class_qos_queue class definition from :doc:`vnc_cfg.xsd` + """ + subclass = None + superclass = None + def __init__(self, **kwargs): + pass + def factory(*args_, **kwargs_): + if qos_forwarding_class_qos_queue.subclass: + return qos_forwarding_class_qos_queue.subclass(*args_, **kwargs_) + else: + return qos_forwarding_class_qos_queue(*args_, **kwargs_) + factory = staticmethod(factory) + def __eq__(self, other): return True + def __ne__(self, other): return False + @classmethod + def populate (cls, *a, **kwa): + obj = cls (*a, **kwa) + return obj + def export(self, outfile, level=1, namespace_='', name_='qos-forwarding-class-qos-queue', namespacedef_='', pretty_print=True): + if pretty_print: + eol_ = '\n' + else: + eol_ = '' + showIndent(outfile, level, pretty_print) + outfile.write('<%s%s%s' % (namespace_, name_, namespacedef_ and ' ' + namespacedef_ or '', )) + already_processed = [] + self.exportAttributes(outfile, level, already_processed, namespace_, name_='qos-forwarding-class-qos-queue') + if self.hasContent_(): + outfile.write('>%s' % (eol_, )) + self.exportChildren(outfile, level + 1, namespace_, name_, pretty_print=pretty_print) + outfile.write('</%s%s>%s' % (namespace_, name_, eol_)) + else: + outfile.write('/>%s' % (eol_, )) + def exportAttributes(self, outfile, level, already_processed, namespace_='', name_='qos-forwarding-class-qos-queue'): + pass + def exportChildren(self, outfile, level, namespace_='', name_='qos-forwarding-class-qos-queue', fromsubclass_=False, pretty_print=True): + pass + def hasContent_(self): + if ( + + ): + return True + else: + return False + def exportLiteral(self, outfile, level, name_='qos-forwarding-class-qos-queue'): + level += 1 + self.exportLiteralAttributes(outfile, level, [], name_) + if self.hasContent_(): + self.exportLiteralChildren(outfile, level, name_) + def exportLiteralAttributes(self, outfile, level, already_processed, name_): + pass + def exportLiteralChildren(self, outfile, level, name_): + pass + def exportDict(self, name_='qos-forwarding-class-qos-queue'): + obj_json = json.dumps(self, default=lambda o: dict((k, v) for k, v in o.__dict__.iteritems())) + obj_dict = json.loads(obj_json) + return {name_: obj_dict} + def build(self, node): + self.buildAttributes(node, node.attrib, []) + for child in node: + nodeName_ = Tag_pattern_.match(child.tag).groups()[-1] + self.buildChildren(child, node, nodeName_) + def buildAttributes(self, node, attrs, already_processed): + pass + def buildChildren(self, child_, node, nodeName_, fromsubclass_=False): + pass +# end class qos_forwarding_class_qos_queue + + +class virtual_network_qos_forwarding_class(GeneratedsSuper): + """ + virtual_network_qos_forwarding_class class definition from :doc:`vnc_cfg.xsd` + """ + subclass = None + superclass = None + def __init__(self, **kwargs): + pass + def factory(*args_, **kwargs_): + if virtual_network_qos_forwarding_class.subclass: + return virtual_network_qos_forwarding_class.subclass(*args_, **kwargs_) + else: + return virtual_network_qos_forwarding_class(*args_, **kwargs_) + factory = staticmethod(factory) + def __eq__(self, other): return True + def __ne__(self, other): return False + @classmethod + def populate (cls, *a, **kwa): + obj = cls (*a, **kwa) + return obj + def export(self, outfile, level=1, namespace_='', name_='virtual-network-qos-forwarding-class', namespacedef_='', pretty_print=True): + if pretty_print: + eol_ = '\n' + else: + eol_ = '' + showIndent(outfile, level, pretty_print) + outfile.write('<%s%s%s' % (namespace_, name_, namespacedef_ and ' ' + namespacedef_ or '', )) + already_processed = [] + self.exportAttributes(outfile, level, already_processed, namespace_, name_='virtual-network-qos-forwarding-class') + if self.hasContent_(): + outfile.write('>%s' % (eol_, )) + self.exportChildren(outfile, level + 1, namespace_, name_, pretty_print=pretty_print) + outfile.write('</%s%s>%s' % (namespace_, name_, eol_)) + else: + outfile.write('/>%s' % (eol_, )) + def exportAttributes(self, outfile, level, already_processed, namespace_='', name_='virtual-network-qos-forwarding-class'): + pass + def exportChildren(self, outfile, level, namespace_='', name_='virtual-network-qos-forwarding-class', fromsubclass_=False, pretty_print=True): + pass + def hasContent_(self): + if ( + + ): + return True + else: + return False + def exportLiteral(self, outfile, level, name_='virtual-network-qos-forwarding-class'): + level += 1 + self.exportLiteralAttributes(outfile, level, [], name_) + if self.hasContent_(): + self.exportLiteralChildren(outfile, level, name_) + def exportLiteralAttributes(self, outfile, level, already_processed, name_): + pass + def exportLiteralChildren(self, outfile, level, name_): + pass + def exportDict(self, name_='virtual-network-qos-forwarding-class'): + obj_json = json.dumps(self, default=lambda o: dict((k, v) for k, v in o.__dict__.iteritems())) + obj_dict = json.loads(obj_json) + return {name_: obj_dict} + def build(self, node): + self.buildAttributes(node, node.attrib, []) + for child in node: + nodeName_ = Tag_pattern_.match(child.tag).groups()[-1] + self.buildChildren(child, node, nodeName_) + def buildAttributes(self, node, attrs, already_processed): + pass + def buildChildren(self, child_, node, nodeName_, fromsubclass_=False): + pass +# end class virtual_network_qos_forwarding_class + + +class virtual_machine_interface_qos_forwarding_class(GeneratedsSuper): + """ + virtual_machine_interface_qos_forwarding_class class definition from :doc:`vnc_cfg.xsd` + """ + subclass = None + superclass = None + def __init__(self, **kwargs): + pass + def factory(*args_, **kwargs_): + if virtual_machine_interface_qos_forwarding_class.subclass: + return virtual_machine_interface_qos_forwarding_class.subclass(*args_, **kwargs_) + else: + return virtual_machine_interface_qos_forwarding_class(*args_, **kwargs_) + factory = staticmethod(factory) + def __eq__(self, other): return True + def __ne__(self, other): return False + @classmethod + def populate (cls, *a, **kwa): + obj = cls (*a, **kwa) + return obj + def export(self, outfile, level=1, namespace_='', name_='virtual-machine-interface-qos-forwarding-class', namespacedef_='', pretty_print=True): + if pretty_print: + eol_ = '\n' + else: + eol_ = '' + showIndent(outfile, level, pretty_print) + outfile.write('<%s%s%s' % (namespace_, name_, namespacedef_ and ' ' + namespacedef_ or '', )) + already_processed = [] + self.exportAttributes(outfile, level, already_processed, namespace_, name_='virtual-machine-interface-qos-forwarding-class') + if self.hasContent_(): + outfile.write('>%s' % (eol_, )) + self.exportChildren(outfile, level + 1, namespace_, name_, pretty_print=pretty_print) + outfile.write('</%s%s>%s' % (namespace_, name_, eol_)) + else: + outfile.write('/>%s' % (eol_, )) + def exportAttributes(self, outfile, level, already_processed, namespace_='', name_='virtual-machine-interface-qos-forwarding-class'): + pass + def exportChildren(self, outfile, level, namespace_='', name_='virtual-machine-interface-qos-forwarding-class', fromsubclass_=False, pretty_print=True): + pass + def hasContent_(self): + if ( + + ): + return True + else: + return False + def exportLiteral(self, outfile, level, name_='virtual-machine-interface-qos-forwarding-class'): + level += 1 + self.exportLiteralAttributes(outfile, level, [], name_) + if self.hasContent_(): + self.exportLiteralChildren(outfile, level, name_) + def exportLiteralAttributes(self, outfile, level, already_processed, name_): + pass + def exportLiteralChildren(self, outfile, level, name_): + pass + def exportDict(self, name_='virtual-machine-interface-qos-forwarding-class'): + obj_json = json.dumps(self, default=lambda o: dict((k, v) for k, v in o.__dict__.iteritems())) + obj_dict = json.loads(obj_json) + return {name_: obj_dict} + def build(self, node): + self.buildAttributes(node, node.attrib, []) + for child in node: + nodeName_ = Tag_pattern_.match(child.tag).groups()[-1] + self.buildChildren(child, node, nodeName_) + def buildAttributes(self, node, attrs, already_processed): + pass + def buildChildren(self, child_, node, nodeName_, fromsubclass_=False): + pass +# end class virtual_machine_interface_qos_forwarding_class + + +class VirtualNetworkType(GeneratedsSuper): + """ + VirtualNetworkType class definition from :doc:`vnc_cfg.xsd` + """ + subclass = None + superclass = None + def __init__(self, allow_transit=None, network_id=None, vxlan_network_identifier=None, forwarding_mode=None, rpf=None, **kwargs): + self.allow_transit = allow_transit + self.network_id = network_id + self.vxlan_network_identifier = vxlan_network_identifier + self.forwarding_mode = forwarding_mode + self.rpf = rpf + def factory(*args_, **kwargs_): + if VirtualNetworkType.subclass: + return VirtualNetworkType.subclass(*args_, **kwargs_) + else: + return VirtualNetworkType(*args_, **kwargs_) + factory = staticmethod(factory) + def get_allow_transit(self): return self.allow_transit + def set_allow_transit(self, allow_transit): self.allow_transit = allow_transit + def get_network_id(self): return self.network_id + def set_network_id(self, network_id): self.network_id = network_id + def get_vxlan_network_identifier(self): return self.vxlan_network_identifier + def set_vxlan_network_identifier(self, vxlan_network_identifier): self.vxlan_network_identifier = vxlan_network_identifier + def validate_VxlanNetworkIdentifierType(self, value): + # Validate type VxlanNetworkIdentifierType, a restriction on xsd:integer. + error = False + if isinstance(value, list): + v_int = map(int, value) + v1, v2 = min(v_int), max(v_int) + else: + v1, v2 = int(value), int(value) + error = (1 > v1) + error |= (v2 > 1048575) + if error: + raise ValueError("VxlanNetworkIdentifierType must be in the range 1-1048575") + def get_forwarding_mode(self): return self.forwarding_mode + def set_forwarding_mode(self, forwarding_mode): self.forwarding_mode = forwarding_mode + def validate_ForwardingModeType(self, value): + # Validate type ForwardingModeType, a restriction on xsd:string. + error = False + if isinstance(value, list): + error = set(value) - set([u'l2_l3', u'l2']) + else: + error = value not in [u'l2_l3', u'l2'] + if error: + raise ValueError("ForwardingModeType must be one of [u'l2_l3', u'l2']") + def get_rpf(self): return self.rpf + def set_rpf(self, rpf): self.rpf = rpf + def validate_RpfModeType(self, value): + # Validate type RpfModeType, a restriction on xsd:string. + error = False + if isinstance(value, list): + error = set(value) - set([u'enable', u'disable']) + else: + error = value not in [u'enable', u'disable'] + if error: + raise ValueError("RpfModeType must be one of [u'enable', u'disable']") + def __eq__(self, other): + if isinstance(other, self.__class__): + return (self.allow_transit == other.allow_transit and + self.network_id == other.network_id and + self.vxlan_network_identifier == other.vxlan_network_identifier and + self.forwarding_mode == other.forwarding_mode and + self.rpf == other.rpf) + return NotImplemented + def __ne__(self, other): + if isinstance(other, self.__class__): + return not self.__eq__(other) + return NotImplemented + + @classmethod + def populate (cls, *a, **kwa): + obj = cls (*a, **kwa) + obj.set_allow_transit (obj.populate_boolean ("allow_transit")) + obj.set_network_id (obj.populate_integer ("network_id")) + obj.set_vxlan_network_identifier (obj.populate_integer ("vxlan_network_identifier")) + obj.set_forwarding_mode (obj.populate_string ("forwarding_mode")) + obj.set_rpf (obj.populate_string ("rpf")) + return obj + def export(self, outfile, level=1, namespace_='', name_='VirtualNetworkType', namespacedef_='', pretty_print=True): + if pretty_print: + eol_ = '\n' + else: + eol_ = '' + showIndent(outfile, level, pretty_print) + outfile.write('<%s%s%s' % (namespace_, name_, namespacedef_ and ' ' + namespacedef_ or '', )) + already_processed = [] + self.exportAttributes(outfile, level, already_processed, namespace_, name_='VirtualNetworkType') + if self.hasContent_(): + outfile.write('>%s' % (eol_, )) + self.exportChildren(outfile, level + 1, namespace_, name_, pretty_print=pretty_print) + showIndent(outfile, level, pretty_print) + outfile.write('</%s%s>%s' % (namespace_, name_, eol_)) + else: + outfile.write('/>%s' % (eol_, )) + def exportAttributes(self, outfile, level, already_processed, namespace_='', name_='VirtualNetworkType'): + pass + def exportChildren(self, outfile, level, namespace_='', name_='VirtualNetworkType', fromsubclass_=False, pretty_print=True): + if pretty_print: + eol_ = '\n' + else: + eol_ = '' + if self.allow_transit is not None: + showIndent(outfile, level, pretty_print) + outfile.write('<%sallow-transit>%s</%sallow-transit>%s' % (namespace_, self.gds_format_boolean(self.gds_str_lower(str(self.allow_transit)), input_name='allow-transit'), namespace_, eol_)) + if self.network_id is not None: + showIndent(outfile, level, pretty_print) + outfile.write('<%snetwork-id>%s</%snetwork-id>%s' % (namespace_, self.gds_format_integer(self.network_id, input_name='network-id'), namespace_, eol_)) + if self.vxlan_network_identifier is not None: + showIndent(outfile, level, pretty_print) + outfile.write('<%svxlan-network-identifier>%s</%svxlan-network-identifier>%s' % (namespace_, self.gds_format_integer(self.vxlan_network_identifier, input_name='vxlan-network-identifier'), namespace_, eol_)) + if self.forwarding_mode is not None: + showIndent(outfile, level, pretty_print) + outfile.write('<%sforwarding-mode>%s</%sforwarding-mode>%s' % (namespace_, self.gds_format_string(quote_xml(self.forwarding_mode).encode(ExternalEncoding), input_name='forwarding-mode'), namespace_, eol_)) + if self.rpf is not None: + showIndent(outfile, level, pretty_print) + outfile.write('<%srpf>%s</%srpf>%s' % (namespace_, self.gds_format_string(quote_xml(self.rpf).encode(ExternalEncoding), input_name='rpf'), namespace_, eol_)) + def hasContent_(self): + if ( + self.allow_transit is not None or + self.network_id is not None or + self.vxlan_network_identifier is not None or + self.forwarding_mode is not None or + self.rpf is not None + ): + return True + else: + return False + def exportLiteral(self, outfile, level, name_='VirtualNetworkType'): + level += 1 + self.exportLiteralAttributes(outfile, level, [], name_) + if self.hasContent_(): + self.exportLiteralChildren(outfile, level, name_) + def exportLiteralAttributes(self, outfile, level, already_processed, name_): + pass + def exportLiteralChildren(self, outfile, level, name_): + if self.allow_transit is not None: + showIndent(outfile, level) + outfile.write('allow_transit=%s,\n' % self.allow_transit) + if self.network_id is not None: + showIndent(outfile, level) + outfile.write('network_id=%d,\n' % self.network_id) + if self.vxlan_network_identifier is not None: + showIndent(outfile, level) + outfile.write('vxlan_network_identifier=%d,\n' % self.vxlan_network_identifier) + if self.forwarding_mode is not None: + showIndent(outfile, level) + outfile.write('forwarding_mode=%s,\n' % quote_python(self.forwarding_mode).encode(ExternalEncoding)) + if self.rpf is not None: + showIndent(outfile, level) + outfile.write('rpf=%s,\n' % quote_python(self.rpf).encode(ExternalEncoding)) + def exportDict(self, name_='VirtualNetworkType'): + obj_json = json.dumps(self, default=lambda o: dict((k, v) for k, v in o.__dict__.iteritems())) + obj_dict = json.loads(obj_json) + return {name_: obj_dict} + def build(self, node): + self.buildAttributes(node, node.attrib, []) + for child in node: + nodeName_ = Tag_pattern_.match(child.tag).groups()[-1] + self.buildChildren(child, node, nodeName_) + def buildAttributes(self, node, attrs, already_processed): + pass + def buildChildren(self, child_, node, nodeName_, fromsubclass_=False): + if nodeName_ == 'allow-transit': + sval_ = child_.text + if sval_ in ('true', '1'): + ival_ = True + elif sval_ in ('false', '0'): + ival_ = False + else: + raise_parse_error(child_, 'requires boolean') + ival_ = self.gds_validate_boolean(ival_, node, 'allow_transit') + self.allow_transit = ival_ + elif nodeName_ == 'network-id': + sval_ = child_.text + try: + ival_ = int(sval_) + except (TypeError, ValueError), exp: + raise_parse_error(child_, 'requires integer: %s' % exp) + ival_ = self.gds_validate_integer(ival_, node, 'network_id') + self.network_id = ival_ + elif nodeName_ == 'vxlan-network-identifier': + sval_ = child_.text + try: + ival_ = int(sval_) + except (TypeError, ValueError), exp: + raise_parse_error(child_, 'requires integer: %s' % exp) + ival_ = self.gds_validate_integer(ival_, node, 'vxlan_network_identifier') + self.vxlan_network_identifier = ival_ + self.validate_VxlanNetworkIdentifierType(self.vxlan_network_identifier) # validate type VxlanNetworkIdentifierType + elif nodeName_ == 'forwarding-mode': + forwarding_mode_ = child_.text + forwarding_mode_ = self.gds_validate_string(forwarding_mode_, node, 'forwarding_mode') + self.forwarding_mode = forwarding_mode_ + self.validate_ForwardingModeType(self.forwarding_mode) # validate type ForwardingModeType + elif nodeName_ == 'rpf': + rpf_ = child_.text + rpf_ = self.gds_validate_string(rpf_, node, 'rpf') + self.rpf = rpf_ + self.validate_RpfModeType(self.rpf) # validate type RpfModeType +# end class VirtualNetworkType + + +class RouteTargetList(GeneratedsSuper): + """ + RouteTargetList class definition from :doc:`vnc_cfg.xsd` + """ + subclass = None + superclass = None + def __init__(self, route_target=None, **kwargs): + if (route_target is None) or (route_target == []): + self.route_target = [] + else: + self.route_target = route_target + def factory(*args_, **kwargs_): + if RouteTargetList.subclass: + return RouteTargetList.subclass(*args_, **kwargs_) + else: + return RouteTargetList(*args_, **kwargs_) + factory = staticmethod(factory) + def get_route_target(self): return self.route_target + def set_route_target(self, route_target): self.route_target = route_target + def add_route_target(self, value): self.route_target.append(value) + def insert_route_target(self, index, value): self.route_target[index] = value + def delete_route_target(self, value): self.route_target.remove(value) + def __eq__(self, other): + if isinstance(other, self.__class__): + return (self.route_target == other.route_target) + return NotImplemented + def __ne__(self, other): + if isinstance(other, self.__class__): + return not self.__eq__(other) + return NotImplemented + + @classmethod + def populate (cls, *a, **kwa): + obj = cls (*a, **kwa) + obj.set_route_target ([obj.populate_string ("route_target")]) + return obj + def export(self, outfile, level=1, namespace_='', name_='RouteTargetList', namespacedef_='', pretty_print=True): + if pretty_print: + eol_ = '\n' + else: + eol_ = '' + showIndent(outfile, level, pretty_print) + outfile.write('<%s%s%s' % (namespace_, name_, namespacedef_ and ' ' + namespacedef_ or '', )) + already_processed = [] + self.exportAttributes(outfile, level, already_processed, namespace_, name_='RouteTargetList') + if self.hasContent_(): + outfile.write('>%s' % (eol_, )) + self.exportChildren(outfile, level + 1, namespace_, name_, pretty_print=pretty_print) + showIndent(outfile, level, pretty_print) + outfile.write('</%s%s>%s' % (namespace_, name_, eol_)) + else: + outfile.write('/>%s' % (eol_, )) + def exportAttributes(self, outfile, level, already_processed, namespace_='', name_='RouteTargetList'): + pass + def exportChildren(self, outfile, level, namespace_='', name_='RouteTargetList', fromsubclass_=False, pretty_print=True): + if pretty_print: + eol_ = '\n' + else: + eol_ = '' + for route_target_ in self.route_target: + showIndent(outfile, level, pretty_print) + outfile.write('<%sroute-target>%s</%sroute-target>%s' % (namespace_, self.gds_format_string(quote_xml(route_target_).encode(ExternalEncoding), input_name='route-target'), namespace_, eol_)) + def hasContent_(self): + if ( + self.route_target + ): + return True + else: + return False + def exportLiteral(self, outfile, level, name_='RouteTargetList'): + level += 1 + self.exportLiteralAttributes(outfile, level, [], name_) + if self.hasContent_(): + self.exportLiteralChildren(outfile, level, name_) + def exportLiteralAttributes(self, outfile, level, already_processed, name_): + pass + def exportLiteralChildren(self, outfile, level, name_): + showIndent(outfile, level) + outfile.write('route_target=[\n') + level += 1 + for route_target_ in self.route_target: + showIndent(outfile, level) + outfile.write('%s,\n' % quote_python(route_target_).encode(ExternalEncoding)) + level -= 1 + showIndent(outfile, level) + outfile.write('],\n') + def exportDict(self, name_='RouteTargetList'): + obj_json = json.dumps(self, default=lambda o: dict((k, v) for k, v in o.__dict__.iteritems())) + obj_dict = json.loads(obj_json) + return {name_: obj_dict} + def build(self, node): + self.buildAttributes(node, node.attrib, []) + for child in node: + nodeName_ = Tag_pattern_.match(child.tag).groups()[-1] + self.buildChildren(child, node, nodeName_) + def buildAttributes(self, node, attrs, already_processed): + pass + def buildChildren(self, child_, node, nodeName_, fromsubclass_=False): + if nodeName_ == 'route-target': + route_target_ = child_.text + route_target_ = self.gds_validate_string(route_target_, node, 'route_target') + self.route_target.append(route_target_) +# end class RouteTargetList + + +class project_network_ipam(GeneratedsSuper): + """ + project_network_ipam class definition from :doc:`vnc_cfg.xsd` + """ + subclass = None + superclass = None + def __init__(self, **kwargs): + pass + def factory(*args_, **kwargs_): + if project_network_ipam.subclass: + return project_network_ipam.subclass(*args_, **kwargs_) + else: + return project_network_ipam(*args_, **kwargs_) + factory = staticmethod(factory) + def __eq__(self, other): return True + def __ne__(self, other): return False + @classmethod + def populate (cls, *a, **kwa): + obj = cls (*a, **kwa) + return obj + def export(self, outfile, level=1, namespace_='', name_='project-network-ipam', namespacedef_='', pretty_print=True): + if pretty_print: + eol_ = '\n' + else: + eol_ = '' + showIndent(outfile, level, pretty_print) + outfile.write('<%s%s%s' % (namespace_, name_, namespacedef_ and ' ' + namespacedef_ or '', )) + already_processed = [] + self.exportAttributes(outfile, level, already_processed, namespace_, name_='project-network-ipam') + if self.hasContent_(): + outfile.write('>%s' % (eol_, )) + self.exportChildren(outfile, level + 1, namespace_, name_, pretty_print=pretty_print) + outfile.write('</%s%s>%s' % (namespace_, name_, eol_)) + else: + outfile.write('/>%s' % (eol_, )) + def exportAttributes(self, outfile, level, already_processed, namespace_='', name_='project-network-ipam'): + pass + def exportChildren(self, outfile, level, namespace_='', name_='project-network-ipam', fromsubclass_=False, pretty_print=True): + pass + def hasContent_(self): + if ( + + ): + return True + else: + return False + def exportLiteral(self, outfile, level, name_='project-network-ipam'): + level += 1 + self.exportLiteralAttributes(outfile, level, [], name_) + if self.hasContent_(): + self.exportLiteralChildren(outfile, level, name_) + def exportLiteralAttributes(self, outfile, level, already_processed, name_): + pass + def exportLiteralChildren(self, outfile, level, name_): + pass + def exportDict(self, name_='project-network-ipam'): + obj_json = json.dumps(self, default=lambda o: dict((k, v) for k, v in o.__dict__.iteritems())) + obj_dict = json.loads(obj_json) + return {name_: obj_dict} + def build(self, node): + self.buildAttributes(node, node.attrib, []) + for child in node: + nodeName_ = Tag_pattern_.match(child.tag).groups()[-1] + self.buildChildren(child, node, nodeName_) + def buildAttributes(self, node, attrs, already_processed): + pass + def buildChildren(self, child_, node, nodeName_, fromsubclass_=False): + pass +# end class project_network_ipam + + +class project_network_policy(GeneratedsSuper): + """ + project_network_policy class definition from :doc:`vnc_cfg.xsd` + """ + subclass = None + superclass = None + def __init__(self, **kwargs): + pass + def factory(*args_, **kwargs_): + if project_network_policy.subclass: + return project_network_policy.subclass(*args_, **kwargs_) + else: + return project_network_policy(*args_, **kwargs_) + factory = staticmethod(factory) + def __eq__(self, other): return True + def __ne__(self, other): return False + @classmethod + def populate (cls, *a, **kwa): + obj = cls (*a, **kwa) + return obj + def export(self, outfile, level=1, namespace_='', name_='project-network-policy', namespacedef_='', pretty_print=True): + if pretty_print: + eol_ = '\n' + else: + eol_ = '' + showIndent(outfile, level, pretty_print) + outfile.write('<%s%s%s' % (namespace_, name_, namespacedef_ and ' ' + namespacedef_ or '', )) + already_processed = [] + self.exportAttributes(outfile, level, already_processed, namespace_, name_='project-network-policy') + if self.hasContent_(): + outfile.write('>%s' % (eol_, )) + self.exportChildren(outfile, level + 1, namespace_, name_, pretty_print=pretty_print) + outfile.write('</%s%s>%s' % (namespace_, name_, eol_)) + else: + outfile.write('/>%s' % (eol_, )) + def exportAttributes(self, outfile, level, already_processed, namespace_='', name_='project-network-policy'): + pass + def exportChildren(self, outfile, level, namespace_='', name_='project-network-policy', fromsubclass_=False, pretty_print=True): + pass + def hasContent_(self): + if ( + + ): + return True + else: + return False + def exportLiteral(self, outfile, level, name_='project-network-policy'): + level += 1 + self.exportLiteralAttributes(outfile, level, [], name_) + if self.hasContent_(): + self.exportLiteralChildren(outfile, level, name_) + def exportLiteralAttributes(self, outfile, level, already_processed, name_): + pass + def exportLiteralChildren(self, outfile, level, name_): + pass + def exportDict(self, name_='project-network-policy'): + obj_json = json.dumps(self, default=lambda o: dict((k, v) for k, v in o.__dict__.iteritems())) + obj_dict = json.loads(obj_json) + return {name_: obj_dict} + def build(self, node): + self.buildAttributes(node, node.attrib, []) + for child in node: + nodeName_ = Tag_pattern_.match(child.tag).groups()[-1] + self.buildChildren(child, node, nodeName_) + def buildAttributes(self, node, attrs, already_processed): + pass + def buildChildren(self, child_, node, nodeName_, fromsubclass_=False): + pass +# end class project_network_policy + + +class virtual_network_access_control_list(GeneratedsSuper): + """ + virtual_network_access_control_list class definition from :doc:`vnc_cfg.xsd` + """ + subclass = None + superclass = None + def __init__(self, **kwargs): + pass + def factory(*args_, **kwargs_): + if virtual_network_access_control_list.subclass: + return virtual_network_access_control_list.subclass(*args_, **kwargs_) + else: + return virtual_network_access_control_list(*args_, **kwargs_) + factory = staticmethod(factory) + def __eq__(self, other): return True + def __ne__(self, other): return False + @classmethod + def populate (cls, *a, **kwa): + obj = cls (*a, **kwa) + return obj + def export(self, outfile, level=1, namespace_='', name_='virtual-network-access-control-list', namespacedef_='', pretty_print=True): + if pretty_print: + eol_ = '\n' + else: + eol_ = '' + showIndent(outfile, level, pretty_print) + outfile.write('<%s%s%s' % (namespace_, name_, namespacedef_ and ' ' + namespacedef_ or '', )) + already_processed = [] + self.exportAttributes(outfile, level, already_processed, namespace_, name_='virtual-network-access-control-list') + if self.hasContent_(): + outfile.write('>%s' % (eol_, )) + self.exportChildren(outfile, level + 1, namespace_, name_, pretty_print=pretty_print) + outfile.write('</%s%s>%s' % (namespace_, name_, eol_)) + else: + outfile.write('/>%s' % (eol_, )) + def exportAttributes(self, outfile, level, already_processed, namespace_='', name_='virtual-network-access-control-list'): + pass + def exportChildren(self, outfile, level, namespace_='', name_='virtual-network-access-control-list', fromsubclass_=False, pretty_print=True): + pass + def hasContent_(self): + if ( + + ): + return True + else: + return False + def exportLiteral(self, outfile, level, name_='virtual-network-access-control-list'): + level += 1 + self.exportLiteralAttributes(outfile, level, [], name_) + if self.hasContent_(): + self.exportLiteralChildren(outfile, level, name_) + def exportLiteralAttributes(self, outfile, level, already_processed, name_): + pass + def exportLiteralChildren(self, outfile, level, name_): + pass + def exportDict(self, name_='virtual-network-access-control-list'): + obj_json = json.dumps(self, default=lambda o: dict((k, v) for k, v in o.__dict__.iteritems())) + obj_dict = json.loads(obj_json) + return {name_: obj_dict} + def build(self, node): + self.buildAttributes(node, node.attrib, []) + for child in node: + nodeName_ = Tag_pattern_.match(child.tag).groups()[-1] + self.buildChildren(child, node, nodeName_) + def buildAttributes(self, node, attrs, already_processed): + pass + def buildChildren(self, child_, node, nodeName_, fromsubclass_=False): + pass +# end class virtual_network_access_control_list + + +class security_group_access_control_list(GeneratedsSuper): + """ + security_group_access_control_list class definition from :doc:`vnc_cfg.xsd` + """ + subclass = None + superclass = None + def __init__(self, **kwargs): + pass + def factory(*args_, **kwargs_): + if security_group_access_control_list.subclass: + return security_group_access_control_list.subclass(*args_, **kwargs_) + else: + return security_group_access_control_list(*args_, **kwargs_) + factory = staticmethod(factory) + def __eq__(self, other): return True + def __ne__(self, other): return False + @classmethod + def populate (cls, *a, **kwa): + obj = cls (*a, **kwa) + return obj + def export(self, outfile, level=1, namespace_='', name_='security-group-access-control-list', namespacedef_='', pretty_print=True): + if pretty_print: + eol_ = '\n' + else: + eol_ = '' + showIndent(outfile, level, pretty_print) + outfile.write('<%s%s%s' % (namespace_, name_, namespacedef_ and ' ' + namespacedef_ or '', )) + already_processed = [] + self.exportAttributes(outfile, level, already_processed, namespace_, name_='security-group-access-control-list') + if self.hasContent_(): + outfile.write('>%s' % (eol_, )) + self.exportChildren(outfile, level + 1, namespace_, name_, pretty_print=pretty_print) + outfile.write('</%s%s>%s' % (namespace_, name_, eol_)) + else: + outfile.write('/>%s' % (eol_, )) + def exportAttributes(self, outfile, level, already_processed, namespace_='', name_='security-group-access-control-list'): + pass + def exportChildren(self, outfile, level, namespace_='', name_='security-group-access-control-list', fromsubclass_=False, pretty_print=True): + pass + def hasContent_(self): + if ( + + ): + return True + else: + return False + def exportLiteral(self, outfile, level, name_='security-group-access-control-list'): + level += 1 + self.exportLiteralAttributes(outfile, level, [], name_) + if self.hasContent_(): + self.exportLiteralChildren(outfile, level, name_) + def exportLiteralAttributes(self, outfile, level, already_processed, name_): + pass + def exportLiteralChildren(self, outfile, level, name_): + pass + def exportDict(self, name_='security-group-access-control-list'): + obj_json = json.dumps(self, default=lambda o: dict((k, v) for k, v in o.__dict__.iteritems())) + obj_dict = json.loads(obj_json) + return {name_: obj_dict} + def build(self, node): + self.buildAttributes(node, node.attrib, []) + for child in node: + nodeName_ = Tag_pattern_.match(child.tag).groups()[-1] + self.buildChildren(child, node, nodeName_) + def buildAttributes(self, node, attrs, already_processed): + pass + def buildChildren(self, child_, node, nodeName_, fromsubclass_=False): + pass +# end class security_group_access_control_list + + +class virtual_machine_interface_security_group(GeneratedsSuper): + """ + virtual_machine_interface_security_group class definition from :doc:`vnc_cfg.xsd` + """ + subclass = None + superclass = None + def __init__(self, **kwargs): + pass + def factory(*args_, **kwargs_): + if virtual_machine_interface_security_group.subclass: + return virtual_machine_interface_security_group.subclass(*args_, **kwargs_) + else: + return virtual_machine_interface_security_group(*args_, **kwargs_) + factory = staticmethod(factory) + def __eq__(self, other): return True + def __ne__(self, other): return False + @classmethod + def populate (cls, *a, **kwa): + obj = cls (*a, **kwa) + return obj + def export(self, outfile, level=1, namespace_='', name_='virtual-machine-interface-security-group', namespacedef_='', pretty_print=True): + if pretty_print: + eol_ = '\n' + else: + eol_ = '' + showIndent(outfile, level, pretty_print) + outfile.write('<%s%s%s' % (namespace_, name_, namespacedef_ and ' ' + namespacedef_ or '', )) + already_processed = [] + self.exportAttributes(outfile, level, already_processed, namespace_, name_='virtual-machine-interface-security-group') + if self.hasContent_(): + outfile.write('>%s' % (eol_, )) + self.exportChildren(outfile, level + 1, namespace_, name_, pretty_print=pretty_print) + outfile.write('</%s%s>%s' % (namespace_, name_, eol_)) + else: + outfile.write('/>%s' % (eol_, )) + def exportAttributes(self, outfile, level, already_processed, namespace_='', name_='virtual-machine-interface-security-group'): + pass + def exportChildren(self, outfile, level, namespace_='', name_='virtual-machine-interface-security-group', fromsubclass_=False, pretty_print=True): + pass + def hasContent_(self): + if ( + + ): + return True + else: + return False + def exportLiteral(self, outfile, level, name_='virtual-machine-interface-security-group'): + level += 1 + self.exportLiteralAttributes(outfile, level, [], name_) + if self.hasContent_(): + self.exportLiteralChildren(outfile, level, name_) + def exportLiteralAttributes(self, outfile, level, already_processed, name_): + pass + def exportLiteralChildren(self, outfile, level, name_): + pass + def exportDict(self, name_='virtual-machine-interface-security-group'): + obj_json = json.dumps(self, default=lambda o: dict((k, v) for k, v in o.__dict__.iteritems())) + obj_dict = json.loads(obj_json) + return {name_: obj_dict} + def build(self, node): + self.buildAttributes(node, node.attrib, []) + for child in node: + nodeName_ = Tag_pattern_.match(child.tag).groups()[-1] + self.buildChildren(child, node, nodeName_) + def buildAttributes(self, node, attrs, already_processed): + pass + def buildChildren(self, child_, node, nodeName_, fromsubclass_=False): + pass +# end class virtual_machine_interface_security_group + + +class VrfAssignRuleType(GeneratedsSuper): + """ + VrfAssignRuleType class definition from :doc:`vnc_cfg.xsd` + """ + subclass = None + superclass = None + def __init__(self, match_condition=None, vlan_tag=None, routing_instance=None, ignore_acl=None, **kwargs): + if isinstance(match_condition, dict): + obj = MatchConditionType(**match_condition) + self.match_condition = obj + else: + self.match_condition = match_condition + self.vlan_tag = vlan_tag + self.routing_instance = routing_instance + self.ignore_acl = ignore_acl + def factory(*args_, **kwargs_): + if VrfAssignRuleType.subclass: + return VrfAssignRuleType.subclass(*args_, **kwargs_) + else: + return VrfAssignRuleType(*args_, **kwargs_) + factory = staticmethod(factory) + def get_match_condition(self): return self.match_condition + def set_match_condition(self, match_condition): self.match_condition = match_condition + def get_vlan_tag(self): return self.vlan_tag + def set_vlan_tag(self, vlan_tag): self.vlan_tag = vlan_tag + def get_routing_instance(self): return self.routing_instance + def set_routing_instance(self, routing_instance): self.routing_instance = routing_instance + def get_ignore_acl(self): return self.ignore_acl + def set_ignore_acl(self, ignore_acl): self.ignore_acl = ignore_acl + def __eq__(self, other): + if isinstance(other, self.__class__): + return (self.match_condition == other.match_condition and + self.vlan_tag == other.vlan_tag and + self.routing_instance == other.routing_instance and + self.ignore_acl == other.ignore_acl) + return NotImplemented + def __ne__(self, other): + if isinstance(other, self.__class__): + return not self.__eq__(other) + return NotImplemented + + @classmethod + def populate (cls, *a, **kwa): + obj = cls (*a, **kwa) + obj.set_match_condition (MatchConditionType.populate ()) + obj.set_vlan_tag (obj.populate_integer ("vlan_tag")) + obj.set_routing_instance (obj.populate_string ("routing_instance")) + obj.set_ignore_acl (obj.populate_boolean ("ignore_acl")) + return obj + def export(self, outfile, level=1, namespace_='', name_='VrfAssignRuleType', namespacedef_='', pretty_print=True): + if pretty_print: + eol_ = '\n' + else: + eol_ = '' + showIndent(outfile, level, pretty_print) + outfile.write('<%s%s%s' % (namespace_, name_, namespacedef_ and ' ' + namespacedef_ or '', )) + already_processed = [] + self.exportAttributes(outfile, level, already_processed, namespace_, name_='VrfAssignRuleType') + if self.hasContent_(): + outfile.write('>%s' % (eol_, )) + self.exportChildren(outfile, level + 1, namespace_, name_, pretty_print=pretty_print) + showIndent(outfile, level, pretty_print) + outfile.write('</%s%s>%s' % (namespace_, name_, eol_)) + else: + outfile.write('/>%s' % (eol_, )) + def exportAttributes(self, outfile, level, already_processed, namespace_='', name_='VrfAssignRuleType'): + pass + def exportChildren(self, outfile, level, namespace_='', name_='VrfAssignRuleType', fromsubclass_=False, pretty_print=True): + if pretty_print: + eol_ = '\n' + else: + eol_ = '' + if self.match_condition is not None: + self.match_condition.export(outfile, level, namespace_, name_='match-condition', pretty_print=pretty_print) + if self.vlan_tag is not None: + showIndent(outfile, level, pretty_print) + outfile.write('<%svlan-tag>%s</%svlan-tag>%s' % (namespace_, self.gds_format_integer(self.vlan_tag, input_name='vlan-tag'), namespace_, eol_)) + if self.routing_instance is not None: + showIndent(outfile, level, pretty_print) + outfile.write('<%srouting-instance>%s</%srouting-instance>%s' % (namespace_, self.gds_format_string(quote_xml(self.routing_instance).encode(ExternalEncoding), input_name='routing-instance'), namespace_, eol_)) + if self.ignore_acl is not None: + showIndent(outfile, level, pretty_print) + outfile.write('<%signore-acl>%s</%signore-acl>%s' % (namespace_, self.gds_format_boolean(self.gds_str_lower(str(self.ignore_acl)), input_name='ignore-acl'), namespace_, eol_)) + def hasContent_(self): + if ( + self.match_condition is not None or + self.vlan_tag is not None or + self.routing_instance is not None or + self.ignore_acl is not None + ): + return True + else: + return False + def exportLiteral(self, outfile, level, name_='VrfAssignRuleType'): + level += 1 + self.exportLiteralAttributes(outfile, level, [], name_) + if self.hasContent_(): + self.exportLiteralChildren(outfile, level, name_) + def exportLiteralAttributes(self, outfile, level, already_processed, name_): + pass + def exportLiteralChildren(self, outfile, level, name_): + if self.match_condition is not None: + showIndent(outfile, level) + outfile.write('match_condition=model_.MatchConditionType(\n') + self.match_condition.exportLiteral(outfile, level, name_='match_condition') + showIndent(outfile, level) + outfile.write('),\n') + if self.vlan_tag is not None: + showIndent(outfile, level) + outfile.write('vlan_tag=%d,\n' % self.vlan_tag) + if self.routing_instance is not None: + showIndent(outfile, level) + outfile.write('routing_instance=%s,\n' % quote_python(self.routing_instance).encode(ExternalEncoding)) + if self.ignore_acl is not None: + showIndent(outfile, level) + outfile.write('ignore_acl=%s,\n' % self.ignore_acl) + def exportDict(self, name_='VrfAssignRuleType'): + obj_json = json.dumps(self, default=lambda o: dict((k, v) for k, v in o.__dict__.iteritems())) + obj_dict = json.loads(obj_json) + return {name_: obj_dict} + def build(self, node): + self.buildAttributes(node, node.attrib, []) + for child in node: + nodeName_ = Tag_pattern_.match(child.tag).groups()[-1] + self.buildChildren(child, node, nodeName_) + def buildAttributes(self, node, attrs, already_processed): + pass + def buildChildren(self, child_, node, nodeName_, fromsubclass_=False): + if nodeName_ == 'match-condition': + obj_ = MatchConditionType.factory() + obj_.build(child_) + self.set_match_condition(obj_) + elif nodeName_ == 'vlan-tag': + sval_ = child_.text + try: + ival_ = int(sval_) + except (TypeError, ValueError), exp: + raise_parse_error(child_, 'requires integer: %s' % exp) + ival_ = self.gds_validate_integer(ival_, node, 'vlan_tag') + self.vlan_tag = ival_ + elif nodeName_ == 'routing-instance': + routing_instance_ = child_.text + routing_instance_ = self.gds_validate_string(routing_instance_, node, 'routing_instance') + self.routing_instance = routing_instance_ + elif nodeName_ == 'ignore-acl': + sval_ = child_.text + if sval_ in ('true', '1'): + ival_ = True + elif sval_ in ('false', '0'): + ival_ = False + else: + raise_parse_error(child_, 'requires boolean') + ival_ = self.gds_validate_boolean(ival_, node, 'ignore_acl') + self.ignore_acl = ival_ +# end class VrfAssignRuleType + + +class VrfAssignTableType(GeneratedsSuper): + """ + VrfAssignTableType class definition from :doc:`vnc_cfg.xsd` + """ + subclass = None + superclass = None + def __init__(self, vrf_assign_rule=None, **kwargs): + if (vrf_assign_rule is None) or (vrf_assign_rule == []): + self.vrf_assign_rule = [] + else: + if isinstance(vrf_assign_rule[0], dict): + objs = [VrfAssignRuleType(**elem) for elem in vrf_assign_rule] + self.vrf_assign_rule = objs + else: + self.vrf_assign_rule = vrf_assign_rule + def factory(*args_, **kwargs_): + if VrfAssignTableType.subclass: + return VrfAssignTableType.subclass(*args_, **kwargs_) + else: + return VrfAssignTableType(*args_, **kwargs_) + factory = staticmethod(factory) + def get_vrf_assign_rule(self): return self.vrf_assign_rule + def set_vrf_assign_rule(self, vrf_assign_rule): self.vrf_assign_rule = vrf_assign_rule + def add_vrf_assign_rule(self, value): self.vrf_assign_rule.append(value) + def insert_vrf_assign_rule(self, index, value): self.vrf_assign_rule[index] = value + def delete_vrf_assign_rule(self, value): self.vrf_assign_rule.remove(value) + def __eq__(self, other): + if isinstance(other, self.__class__): + return (self.vrf_assign_rule == other.vrf_assign_rule) + return NotImplemented + def __ne__(self, other): + if isinstance(other, self.__class__): + return not self.__eq__(other) + return NotImplemented + + @classmethod + def populate (cls, *a, **kwa): + obj = cls (*a, **kwa) + obj.set_vrf_assign_rule ([VrfAssignRuleType.populate ()]) + return obj + def export(self, outfile, level=1, namespace_='', name_='VrfAssignTableType', namespacedef_='', pretty_print=True): + if pretty_print: + eol_ = '\n' + else: + eol_ = '' + showIndent(outfile, level, pretty_print) + outfile.write('<%s%s%s' % (namespace_, name_, namespacedef_ and ' ' + namespacedef_ or '', )) + already_processed = [] + self.exportAttributes(outfile, level, already_processed, namespace_, name_='VrfAssignTableType') + if self.hasContent_(): + outfile.write('>%s' % (eol_, )) + self.exportChildren(outfile, level + 1, namespace_, name_, pretty_print=pretty_print) + showIndent(outfile, level, pretty_print) + outfile.write('</%s%s>%s' % (namespace_, name_, eol_)) + else: + outfile.write('/>%s' % (eol_, )) + def exportAttributes(self, outfile, level, already_processed, namespace_='', name_='VrfAssignTableType'): + pass + def exportChildren(self, outfile, level, namespace_='', name_='VrfAssignTableType', fromsubclass_=False, pretty_print=True): + if pretty_print: + eol_ = '\n' + else: + eol_ = '' + for vrf_assign_rule_ in self.vrf_assign_rule: + if isinstance(vrf_assign_rule_, dict): + vrf_assign_rule_ = VrfAssignRuleType(**vrf_assign_rule_) + vrf_assign_rule_.export(outfile, level, namespace_, name_='vrf-assign-rule', pretty_print=pretty_print) + def hasContent_(self): + if ( + self.vrf_assign_rule + ): + return True + else: + return False + def exportLiteral(self, outfile, level, name_='VrfAssignTableType'): + level += 1 + self.exportLiteralAttributes(outfile, level, [], name_) + if self.hasContent_(): + self.exportLiteralChildren(outfile, level, name_) + def exportLiteralAttributes(self, outfile, level, already_processed, name_): + pass + def exportLiteralChildren(self, outfile, level, name_): + showIndent(outfile, level) + outfile.write('vrf_assign_rule=[\n') + level += 1 + for vrf_assign_rule_ in self.vrf_assign_rule: + showIndent(outfile, level) + outfile.write('model_.VrfAssignRuleType(\n') + vrf_assign_rule_.exportLiteral(outfile, level, name_='VrfAssignRuleType') + showIndent(outfile, level) + outfile.write('),\n') + level -= 1 + showIndent(outfile, level) + outfile.write('],\n') + def exportDict(self, name_='VrfAssignTableType'): + obj_json = json.dumps(self, default=lambda o: dict((k, v) for k, v in o.__dict__.iteritems())) + obj_dict = json.loads(obj_json) + return {name_: obj_dict} + def build(self, node): + self.buildAttributes(node, node.attrib, []) + for child in node: + nodeName_ = Tag_pattern_.match(child.tag).groups()[-1] + self.buildChildren(child, node, nodeName_) + def buildAttributes(self, node, attrs, already_processed): + pass + def buildChildren(self, child_, node, nodeName_, fromsubclass_=False): + if nodeName_ == 'vrf-assign-rule': + obj_ = VrfAssignRuleType.factory() + obj_.build(child_) + self.vrf_assign_rule.append(obj_) +# end class VrfAssignTableType + + +class InterfaceMirrorType(GeneratedsSuper): + """ + InterfaceMirrorType class definition from :doc:`vnc_cfg.xsd` + """ + subclass = None + superclass = None + def __init__(self, traffic_direction=None, mirror_to=None, **kwargs): + self.traffic_direction = traffic_direction + if isinstance(mirror_to, dict): + obj = MirrorActionType(**mirror_to) + self.mirror_to = obj + else: + self.mirror_to = mirror_to + def factory(*args_, **kwargs_): + if InterfaceMirrorType.subclass: + return InterfaceMirrorType.subclass(*args_, **kwargs_) + else: + return InterfaceMirrorType(*args_, **kwargs_) + factory = staticmethod(factory) + def get_traffic_direction(self): return self.traffic_direction + def set_traffic_direction(self, traffic_direction): self.traffic_direction = traffic_direction + def validate_TrafficDirectionType(self, value): + # Validate type TrafficDirectionType, a restriction on xsd:string. + error = False + if isinstance(value, list): + error = set(value) - set([u'ingress', u'egress', u'both']) + else: + error = value not in [u'ingress', u'egress', u'both'] + if error: + raise ValueError("TrafficDirectionType must be one of [u'ingress', u'egress', u'both']") + def get_mirror_to(self): return self.mirror_to + def set_mirror_to(self, mirror_to): self.mirror_to = mirror_to + def __eq__(self, other): + if isinstance(other, self.__class__): + return (self.traffic_direction == other.traffic_direction and + self.mirror_to == other.mirror_to) + return NotImplemented + def __ne__(self, other): + if isinstance(other, self.__class__): + return not self.__eq__(other) + return NotImplemented + + @classmethod + def populate (cls, *a, **kwa): + obj = cls (*a, **kwa) + obj.set_traffic_direction (obj.populate_string ("traffic_direction")) + obj.set_mirror_to (MirrorActionType.populate ()) + return obj + def export(self, outfile, level=1, namespace_='', name_='InterfaceMirrorType', namespacedef_='', pretty_print=True): + if pretty_print: + eol_ = '\n' + else: + eol_ = '' + showIndent(outfile, level, pretty_print) + outfile.write('<%s%s%s' % (namespace_, name_, namespacedef_ and ' ' + namespacedef_ or '', )) + already_processed = [] + self.exportAttributes(outfile, level, already_processed, namespace_, name_='InterfaceMirrorType') + if self.hasContent_(): + outfile.write('>%s' % (eol_, )) + self.exportChildren(outfile, level + 1, namespace_, name_, pretty_print=pretty_print) + showIndent(outfile, level, pretty_print) + outfile.write('</%s%s>%s' % (namespace_, name_, eol_)) + else: + outfile.write('/>%s' % (eol_, )) + def exportAttributes(self, outfile, level, already_processed, namespace_='', name_='InterfaceMirrorType'): + pass + def exportChildren(self, outfile, level, namespace_='', name_='InterfaceMirrorType', fromsubclass_=False, pretty_print=True): + if pretty_print: + eol_ = '\n' + else: + eol_ = '' + if self.traffic_direction is not None: + showIndent(outfile, level, pretty_print) + outfile.write('<%straffic-direction>%s</%straffic-direction>%s' % (namespace_, self.gds_format_string(quote_xml(self.traffic_direction).encode(ExternalEncoding), input_name='traffic-direction'), namespace_, eol_)) + if self.mirror_to is not None: + self.mirror_to.export(outfile, level, namespace_, name_='mirror-to', pretty_print=pretty_print) + def hasContent_(self): + if ( + self.traffic_direction is not None or + self.mirror_to is not None + ): + return True + else: + return False + def exportLiteral(self, outfile, level, name_='InterfaceMirrorType'): + level += 1 + self.exportLiteralAttributes(outfile, level, [], name_) + if self.hasContent_(): + self.exportLiteralChildren(outfile, level, name_) + def exportLiteralAttributes(self, outfile, level, already_processed, name_): + pass + def exportLiteralChildren(self, outfile, level, name_): + if self.traffic_direction is not None: + showIndent(outfile, level) + outfile.write('traffic_direction=%s,\n' % quote_python(self.traffic_direction).encode(ExternalEncoding)) + if self.mirror_to is not None: + showIndent(outfile, level) + outfile.write('mirror_to=model_.MirrorActionType(\n') + self.mirror_to.exportLiteral(outfile, level, name_='mirror_to') + showIndent(outfile, level) + outfile.write('),\n') + def exportDict(self, name_='InterfaceMirrorType'): + obj_json = json.dumps(self, default=lambda o: dict((k, v) for k, v in o.__dict__.iteritems())) + obj_dict = json.loads(obj_json) + return {name_: obj_dict} + def build(self, node): + self.buildAttributes(node, node.attrib, []) + for child in node: + nodeName_ = Tag_pattern_.match(child.tag).groups()[-1] + self.buildChildren(child, node, nodeName_) + def buildAttributes(self, node, attrs, already_processed): + pass + def buildChildren(self, child_, node, nodeName_, fromsubclass_=False): + if nodeName_ == 'traffic-direction': + traffic_direction_ = child_.text + traffic_direction_ = self.gds_validate_string(traffic_direction_, node, 'traffic_direction') + self.traffic_direction = traffic_direction_ + self.validate_TrafficDirectionType(self.traffic_direction) # validate type TrafficDirectionType + elif nodeName_ == 'mirror-to': + obj_ = MirrorActionType.factory() + obj_.build(child_) + self.set_mirror_to(obj_) +# end class InterfaceMirrorType + + +class VirtualMachineInterfacePropertiesType(GeneratedsSuper): + """ + VirtualMachineInterfacePropertiesType class definition from :doc:`vnc_cfg.xsd` + """ + subclass = None + superclass = None + def __init__(self, service_interface_type=None, interface_mirror=None, local_preference=None, sub_interface_vlan_tag=None, **kwargs): + self.service_interface_type = service_interface_type + if isinstance(interface_mirror, dict): + obj = InterfaceMirrorType(**interface_mirror) + self.interface_mirror = obj + else: + self.interface_mirror = interface_mirror + self.local_preference = local_preference + self.sub_interface_vlan_tag = sub_interface_vlan_tag + def factory(*args_, **kwargs_): + if VirtualMachineInterfacePropertiesType.subclass: + return VirtualMachineInterfacePropertiesType.subclass(*args_, **kwargs_) + else: + return VirtualMachineInterfacePropertiesType(*args_, **kwargs_) + factory = staticmethod(factory) + def get_service_interface_type(self): return self.service_interface_type + def set_service_interface_type(self, service_interface_type): self.service_interface_type = service_interface_type + def validate_ServiceInterfaceType(self, value): + # Validate type ServiceInterfaceType, a restriction on xsd:string. + error = False + if isinstance(value, list): + error = set(value) - set([u'management', u'left', u'right', u'other']) + else: + error = value not in [u'management', u'left', u'right', u'other'] + if error: + raise ValueError("ServiceInterfaceType must be one of [u'management', u'left', u'right', u'other']") + def get_interface_mirror(self): return self.interface_mirror + def set_interface_mirror(self, interface_mirror): self.interface_mirror = interface_mirror + def get_local_preference(self): return self.local_preference + def set_local_preference(self, local_preference): self.local_preference = local_preference + def get_sub_interface_vlan_tag(self): return self.sub_interface_vlan_tag + def set_sub_interface_vlan_tag(self, sub_interface_vlan_tag): self.sub_interface_vlan_tag = sub_interface_vlan_tag + def __eq__(self, other): + if isinstance(other, self.__class__): + return (self.service_interface_type == other.service_interface_type and + self.interface_mirror == other.interface_mirror and + self.local_preference == other.local_preference and + self.sub_interface_vlan_tag == other.sub_interface_vlan_tag) + return NotImplemented + def __ne__(self, other): + if isinstance(other, self.__class__): + return not self.__eq__(other) + return NotImplemented + + @classmethod + def populate (cls, *a, **kwa): + obj = cls (*a, **kwa) + obj.set_service_interface_type (obj.populate_string ("service_interface_type")) + obj.set_interface_mirror (InterfaceMirrorType.populate ()) + obj.set_local_preference (obj.populate_integer ("local_preference")) + obj.set_sub_interface_vlan_tag (obj.populate_integer ("sub_interface_vlan_tag")) + return obj + def export(self, outfile, level=1, namespace_='', name_='VirtualMachineInterfacePropertiesType', namespacedef_='', pretty_print=True): + if pretty_print: + eol_ = '\n' + else: + eol_ = '' + showIndent(outfile, level, pretty_print) + outfile.write('<%s%s%s' % (namespace_, name_, namespacedef_ and ' ' + namespacedef_ or '', )) + already_processed = [] + self.exportAttributes(outfile, level, already_processed, namespace_, name_='VirtualMachineInterfacePropertiesType') + if self.hasContent_(): + outfile.write('>%s' % (eol_, )) + self.exportChildren(outfile, level + 1, namespace_, name_, pretty_print=pretty_print) + showIndent(outfile, level, pretty_print) + outfile.write('</%s%s>%s' % (namespace_, name_, eol_)) + else: + outfile.write('/>%s' % (eol_, )) + def exportAttributes(self, outfile, level, already_processed, namespace_='', name_='VirtualMachineInterfacePropertiesType'): + pass + def exportChildren(self, outfile, level, namespace_='', name_='VirtualMachineInterfacePropertiesType', fromsubclass_=False, pretty_print=True): + if pretty_print: + eol_ = '\n' + else: + eol_ = '' + if self.service_interface_type is not None: + showIndent(outfile, level, pretty_print) + outfile.write('<%sservice-interface-type>%s</%sservice-interface-type>%s' % (namespace_, self.gds_format_string(quote_xml(self.service_interface_type).encode(ExternalEncoding), input_name='service-interface-type'), namespace_, eol_)) + if self.interface_mirror is not None: + self.interface_mirror.export(outfile, level, namespace_, name_='interface-mirror', pretty_print=pretty_print) + if self.local_preference is not None: + showIndent(outfile, level, pretty_print) + outfile.write('<%slocal-preference>%s</%slocal-preference>%s' % (namespace_, self.gds_format_integer(self.local_preference, input_name='local-preference'), namespace_, eol_)) + if self.sub_interface_vlan_tag is not None: + showIndent(outfile, level, pretty_print) + outfile.write('<%ssub-interface-vlan-tag>%s</%ssub-interface-vlan-tag>%s' % (namespace_, self.gds_format_integer(self.sub_interface_vlan_tag, input_name='sub-interface-vlan-tag'), namespace_, eol_)) + def hasContent_(self): + if ( + self.service_interface_type is not None or + self.interface_mirror is not None or + self.local_preference is not None or + self.sub_interface_vlan_tag is not None + ): + return True + else: + return False + def exportLiteral(self, outfile, level, name_='VirtualMachineInterfacePropertiesType'): + level += 1 + self.exportLiteralAttributes(outfile, level, [], name_) + if self.hasContent_(): + self.exportLiteralChildren(outfile, level, name_) + def exportLiteralAttributes(self, outfile, level, already_processed, name_): + pass + def exportLiteralChildren(self, outfile, level, name_): + if self.service_interface_type is not None: + showIndent(outfile, level) + outfile.write('service_interface_type=%s,\n' % quote_python(self.service_interface_type).encode(ExternalEncoding)) + if self.interface_mirror is not None: + showIndent(outfile, level) + outfile.write('interface_mirror=model_.InterfaceMirrorType(\n') + self.interface_mirror.exportLiteral(outfile, level, name_='interface_mirror') + showIndent(outfile, level) + outfile.write('),\n') + if self.local_preference is not None: + showIndent(outfile, level) + outfile.write('local_preference=%d,\n' % self.local_preference) + if self.sub_interface_vlan_tag is not None: + showIndent(outfile, level) + outfile.write('sub_interface_vlan_tag=%d,\n' % self.sub_interface_vlan_tag) + def exportDict(self, name_='VirtualMachineInterfacePropertiesType'): + obj_json = json.dumps(self, default=lambda o: dict((k, v) for k, v in o.__dict__.iteritems())) + obj_dict = json.loads(obj_json) + return {name_: obj_dict} + def build(self, node): + self.buildAttributes(node, node.attrib, []) + for child in node: + nodeName_ = Tag_pattern_.match(child.tag).groups()[-1] + self.buildChildren(child, node, nodeName_) + def buildAttributes(self, node, attrs, already_processed): + pass + def buildChildren(self, child_, node, nodeName_, fromsubclass_=False): + if nodeName_ == 'service-interface-type': + service_interface_type_ = child_.text + service_interface_type_ = self.gds_validate_string(service_interface_type_, node, 'service_interface_type') + self.service_interface_type = service_interface_type_ + self.validate_ServiceInterfaceType(self.service_interface_type) # validate type ServiceInterfaceType + elif nodeName_ == 'interface-mirror': + obj_ = InterfaceMirrorType.factory() + obj_.build(child_) + self.set_interface_mirror(obj_) + elif nodeName_ == 'local-preference': + sval_ = child_.text + try: + ival_ = int(sval_) + except (TypeError, ValueError), exp: + raise_parse_error(child_, 'requires integer: %s' % exp) + ival_ = self.gds_validate_integer(ival_, node, 'local_preference') + self.local_preference = ival_ + elif nodeName_ == 'sub-interface-vlan-tag': + sval_ = child_.text + try: + ival_ = int(sval_) + except (TypeError, ValueError), exp: + raise_parse_error(child_, 'requires integer: %s' % exp) + ival_ = self.gds_validate_integer(ival_, node, 'sub_interface_vlan_tag') + self.sub_interface_vlan_tag = ival_ +# end class VirtualMachineInterfacePropertiesType + + +class ServiceTemplateInterfaceType(GeneratedsSuper): + """ + ServiceTemplateInterfaceType class definition from :doc:`vnc_cfg.xsd` + """ + subclass = None + superclass = None + def __init__(self, service_interface_type=None, shared_ip=False, static_route_enable=False, **kwargs): + self.service_interface_type = service_interface_type + self.shared_ip = shared_ip + self.static_route_enable = static_route_enable + def factory(*args_, **kwargs_): + if ServiceTemplateInterfaceType.subclass: + return ServiceTemplateInterfaceType.subclass(*args_, **kwargs_) + else: + return ServiceTemplateInterfaceType(*args_, **kwargs_) + factory = staticmethod(factory) + def get_service_interface_type(self): return self.service_interface_type + def set_service_interface_type(self, service_interface_type): self.service_interface_type = service_interface_type + def validate_ServiceInterfaceType(self, value): + # Validate type ServiceInterfaceType, a restriction on xsd:string. + error = False + if isinstance(value, list): + error = set(value) - set([u'management', u'left', u'right', u'other']) + else: + error = value not in [u'management', u'left', u'right', u'other'] + if error: + raise ValueError("ServiceInterfaceType must be one of [u'management', u'left', u'right', u'other']") + def get_shared_ip(self): return self.shared_ip + def set_shared_ip(self, shared_ip): self.shared_ip = shared_ip + def get_static_route_enable(self): return self.static_route_enable + def set_static_route_enable(self, static_route_enable): self.static_route_enable = static_route_enable + def __eq__(self, other): + if isinstance(other, self.__class__): + return (self.service_interface_type == other.service_interface_type and + self.shared_ip == other.shared_ip and + self.static_route_enable == other.static_route_enable) + return NotImplemented + def __ne__(self, other): + if isinstance(other, self.__class__): + return not self.__eq__(other) + return NotImplemented + + @classmethod + def populate (cls, *a, **kwa): + obj = cls (*a, **kwa) + obj.set_service_interface_type (obj.populate_string ("service_interface_type")) + obj.set_shared_ip (obj.populate_boolean ("shared_ip")) + obj.set_static_route_enable (obj.populate_boolean ("static_route_enable")) + return obj + def export(self, outfile, level=1, namespace_='', name_='ServiceTemplateInterfaceType', namespacedef_='', pretty_print=True): + if pretty_print: + eol_ = '\n' + else: + eol_ = '' + showIndent(outfile, level, pretty_print) + outfile.write('<%s%s%s' % (namespace_, name_, namespacedef_ and ' ' + namespacedef_ or '', )) + already_processed = [] + self.exportAttributes(outfile, level, already_processed, namespace_, name_='ServiceTemplateInterfaceType') + if self.hasContent_(): + outfile.write('>%s' % (eol_, )) + self.exportChildren(outfile, level + 1, namespace_, name_, pretty_print=pretty_print) + showIndent(outfile, level, pretty_print) + outfile.write('</%s%s>%s' % (namespace_, name_, eol_)) + else: + outfile.write('/>%s' % (eol_, )) + def exportAttributes(self, outfile, level, already_processed, namespace_='', name_='ServiceTemplateInterfaceType'): + pass + def exportChildren(self, outfile, level, namespace_='', name_='ServiceTemplateInterfaceType', fromsubclass_=False, pretty_print=True): + if pretty_print: + eol_ = '\n' + else: + eol_ = '' + if self.service_interface_type is not None: + showIndent(outfile, level, pretty_print) + outfile.write('<%sservice-interface-type>%s</%sservice-interface-type>%s' % (namespace_, self.gds_format_string(quote_xml(self.service_interface_type).encode(ExternalEncoding), input_name='service-interface-type'), namespace_, eol_)) + if self.shared_ip is not None: + showIndent(outfile, level, pretty_print) + outfile.write('<%sshared-ip>%s</%sshared-ip>%s' % (namespace_, self.gds_format_boolean(self.gds_str_lower(str(self.shared_ip)), input_name='shared-ip'), namespace_, eol_)) + if self.static_route_enable is not None: + showIndent(outfile, level, pretty_print) + outfile.write('<%sstatic-route-enable>%s</%sstatic-route-enable>%s' % (namespace_, self.gds_format_boolean(self.gds_str_lower(str(self.static_route_enable)), input_name='static-route-enable'), namespace_, eol_)) + def hasContent_(self): + if ( + self.service_interface_type is not None or + self.shared_ip is not None or + self.static_route_enable is not None + ): + return True + else: + return False + def exportLiteral(self, outfile, level, name_='ServiceTemplateInterfaceType'): + level += 1 + self.exportLiteralAttributes(outfile, level, [], name_) + if self.hasContent_(): + self.exportLiteralChildren(outfile, level, name_) + def exportLiteralAttributes(self, outfile, level, already_processed, name_): + pass + def exportLiteralChildren(self, outfile, level, name_): + if self.service_interface_type is not None: + showIndent(outfile, level) + outfile.write('service_interface_type=%s,\n' % quote_python(self.service_interface_type).encode(ExternalEncoding)) + if self.shared_ip is not None: + showIndent(outfile, level) + outfile.write('shared_ip=%s,\n' % self.shared_ip) + if self.static_route_enable is not None: + showIndent(outfile, level) + outfile.write('static_route_enable=%s,\n' % self.static_route_enable) + def exportDict(self, name_='ServiceTemplateInterfaceType'): + obj_json = json.dumps(self, default=lambda o: dict((k, v) for k, v in o.__dict__.iteritems())) + obj_dict = json.loads(obj_json) + return {name_: obj_dict} + def build(self, node): + self.buildAttributes(node, node.attrib, []) + for child in node: + nodeName_ = Tag_pattern_.match(child.tag).groups()[-1] + self.buildChildren(child, node, nodeName_) + def buildAttributes(self, node, attrs, already_processed): + pass + def buildChildren(self, child_, node, nodeName_, fromsubclass_=False): + if nodeName_ == 'service-interface-type': + service_interface_type_ = child_.text + service_interface_type_ = self.gds_validate_string(service_interface_type_, node, 'service_interface_type') + self.service_interface_type = service_interface_type_ + self.validate_ServiceInterfaceType(self.service_interface_type) # validate type ServiceInterfaceType + elif nodeName_ == 'shared-ip': + sval_ = child_.text + if sval_ in ('true', '1'): + ival_ = True + elif sval_ in ('false', '0'): + ival_ = False + else: + raise_parse_error(child_, 'requires boolean') + ival_ = self.gds_validate_boolean(ival_, node, 'shared_ip') + self.shared_ip = ival_ + elif nodeName_ == 'static-route-enable': + sval_ = child_.text + if sval_ in ('true', '1'): + ival_ = True + elif sval_ in ('false', '0'): + ival_ = False + else: + raise_parse_error(child_, 'requires boolean') + ival_ = self.gds_validate_boolean(ival_, node, 'static_route_enable') + self.static_route_enable = ival_ +# end class ServiceTemplateInterfaceType + + +class ServiceInstanceInterfaceType(GeneratedsSuper): + """ + ServiceInstanceInterfaceType class definition from :doc:`vnc_cfg.xsd` + """ + subclass = None + superclass = None + def __init__(self, virtual_network=None, ip_address=None, static_routes=None, **kwargs): + self.virtual_network = virtual_network + self.ip_address = ip_address + if isinstance(static_routes, dict): + obj = RouteTableType(**static_routes) + self.static_routes = obj + else: + self.static_routes = static_routes + def factory(*args_, **kwargs_): + if ServiceInstanceInterfaceType.subclass: + return ServiceInstanceInterfaceType.subclass(*args_, **kwargs_) + else: + return ServiceInstanceInterfaceType(*args_, **kwargs_) + factory = staticmethod(factory) + def get_virtual_network(self): return self.virtual_network + def set_virtual_network(self, virtual_network): self.virtual_network = virtual_network + def get_ip_address(self): return self.ip_address + def set_ip_address(self, ip_address): self.ip_address = ip_address + def validate_IpAddressType(self, value): + # Validate type IpAddressType, a restriction on xsd:string. + pass + def get_static_routes(self): return self.static_routes + def set_static_routes(self, static_routes): self.static_routes = static_routes + def __eq__(self, other): + if isinstance(other, self.__class__): + return (self.virtual_network == other.virtual_network and + self.ip_address == other.ip_address and + self.static_routes == other.static_routes) + return NotImplemented + def __ne__(self, other): + if isinstance(other, self.__class__): + return not self.__eq__(other) + return NotImplemented + + @classmethod + def populate (cls, *a, **kwa): + obj = cls (*a, **kwa) + obj.set_virtual_network (obj.populate_string ("virtual_network")) + obj.set_ip_address (obj.populate_string ("ip_address")) + obj.set_static_routes (RouteTableType.populate ()) + return obj + def export(self, outfile, level=1, namespace_='', name_='ServiceInstanceInterfaceType', namespacedef_='', pretty_print=True): + if pretty_print: + eol_ = '\n' + else: + eol_ = '' + showIndent(outfile, level, pretty_print) + outfile.write('<%s%s%s' % (namespace_, name_, namespacedef_ and ' ' + namespacedef_ or '', )) + already_processed = [] + self.exportAttributes(outfile, level, already_processed, namespace_, name_='ServiceInstanceInterfaceType') + if self.hasContent_(): + outfile.write('>%s' % (eol_, )) + self.exportChildren(outfile, level + 1, namespace_, name_, pretty_print=pretty_print) + showIndent(outfile, level, pretty_print) + outfile.write('</%s%s>%s' % (namespace_, name_, eol_)) + else: + outfile.write('/>%s' % (eol_, )) + def exportAttributes(self, outfile, level, already_processed, namespace_='', name_='ServiceInstanceInterfaceType'): + pass + def exportChildren(self, outfile, level, namespace_='', name_='ServiceInstanceInterfaceType', fromsubclass_=False, pretty_print=True): + if pretty_print: + eol_ = '\n' + else: + eol_ = '' + if self.virtual_network is not None: + showIndent(outfile, level, pretty_print) + outfile.write('<%svirtual-network>%s</%svirtual-network>%s' % (namespace_, self.gds_format_string(quote_xml(self.virtual_network).encode(ExternalEncoding), input_name='virtual-network'), namespace_, eol_)) + if self.ip_address is not None: + showIndent(outfile, level, pretty_print) + outfile.write('<%sip-address>%s</%sip-address>%s' % (namespace_, self.gds_format_string(quote_xml(self.ip_address).encode(ExternalEncoding), input_name='ip-address'), namespace_, eol_)) + if self.static_routes is not None: + self.static_routes.export(outfile, level, namespace_, name_='static-routes', pretty_print=pretty_print) + def hasContent_(self): + if ( + self.virtual_network is not None or + self.ip_address is not None or + self.static_routes is not None + ): + return True + else: + return False + def exportLiteral(self, outfile, level, name_='ServiceInstanceInterfaceType'): + level += 1 + self.exportLiteralAttributes(outfile, level, [], name_) + if self.hasContent_(): + self.exportLiteralChildren(outfile, level, name_) + def exportLiteralAttributes(self, outfile, level, already_processed, name_): + pass + def exportLiteralChildren(self, outfile, level, name_): + if self.virtual_network is not None: + showIndent(outfile, level) + outfile.write('virtual_network=%s,\n' % quote_python(self.virtual_network).encode(ExternalEncoding)) + if self.ip_address is not None: + showIndent(outfile, level) + outfile.write('ip_address=%s,\n' % quote_python(self.ip_address).encode(ExternalEncoding)) + if self.static_routes is not None: + showIndent(outfile, level) + outfile.write('static_routes=model_.RouteTableType(\n') + self.static_routes.exportLiteral(outfile, level, name_='static_routes') + showIndent(outfile, level) + outfile.write('),\n') + def exportDict(self, name_='ServiceInstanceInterfaceType'): + obj_json = json.dumps(self, default=lambda o: dict((k, v) for k, v in o.__dict__.iteritems())) + obj_dict = json.loads(obj_json) + return {name_: obj_dict} + def build(self, node): + self.buildAttributes(node, node.attrib, []) + for child in node: + nodeName_ = Tag_pattern_.match(child.tag).groups()[-1] + self.buildChildren(child, node, nodeName_) + def buildAttributes(self, node, attrs, already_processed): + pass + def buildChildren(self, child_, node, nodeName_, fromsubclass_=False): + if nodeName_ == 'virtual-network': + virtual_network_ = child_.text + virtual_network_ = self.gds_validate_string(virtual_network_, node, 'virtual_network') + self.virtual_network = virtual_network_ + elif nodeName_ == 'ip-address': + ip_address_ = child_.text + ip_address_ = self.gds_validate_string(ip_address_, node, 'ip_address') + self.ip_address = ip_address_ + self.validate_IpAddressType(self.ip_address) # validate type IpAddressType + elif nodeName_ == 'static-routes': + obj_ = RouteTableType.factory() + obj_.build(child_) + self.set_static_routes(obj_) +# end class ServiceInstanceInterfaceType + + +class virtual_machine_interface_sub_interface(GeneratedsSuper): + """ + virtual_machine_interface_sub_interface class definition from :doc:`vnc_cfg.xsd` + """ + subclass = None + superclass = None + def __init__(self, **kwargs): + pass + def factory(*args_, **kwargs_): + if virtual_machine_interface_sub_interface.subclass: + return virtual_machine_interface_sub_interface.subclass(*args_, **kwargs_) + else: + return virtual_machine_interface_sub_interface(*args_, **kwargs_) + factory = staticmethod(factory) + def __eq__(self, other): return True + def __ne__(self, other): return False + @classmethod + def populate (cls, *a, **kwa): + obj = cls (*a, **kwa) + return obj + def export(self, outfile, level=1, namespace_='', name_='virtual-machine-interface-sub-interface', namespacedef_='', pretty_print=True): + if pretty_print: + eol_ = '\n' + else: + eol_ = '' + showIndent(outfile, level, pretty_print) + outfile.write('<%s%s%s' % (namespace_, name_, namespacedef_ and ' ' + namespacedef_ or '', )) + already_processed = [] + self.exportAttributes(outfile, level, already_processed, namespace_, name_='virtual-machine-interface-sub-interface') + if self.hasContent_(): + outfile.write('>%s' % (eol_, )) + self.exportChildren(outfile, level + 1, namespace_, name_, pretty_print=pretty_print) + outfile.write('</%s%s>%s' % (namespace_, name_, eol_)) + else: + outfile.write('/>%s' % (eol_, )) + def exportAttributes(self, outfile, level, already_processed, namespace_='', name_='virtual-machine-interface-sub-interface'): + pass + def exportChildren(self, outfile, level, namespace_='', name_='virtual-machine-interface-sub-interface', fromsubclass_=False, pretty_print=True): + pass + def hasContent_(self): + if ( + + ): + return True + else: + return False + def exportLiteral(self, outfile, level, name_='virtual-machine-interface-sub-interface'): + level += 1 + self.exportLiteralAttributes(outfile, level, [], name_) + if self.hasContent_(): + self.exportLiteralChildren(outfile, level, name_) + def exportLiteralAttributes(self, outfile, level, already_processed, name_): + pass + def exportLiteralChildren(self, outfile, level, name_): + pass + def exportDict(self, name_='virtual-machine-interface-sub-interface'): + obj_json = json.dumps(self, default=lambda o: dict((k, v) for k, v in o.__dict__.iteritems())) + obj_dict = json.loads(obj_json) + return {name_: obj_dict} + def build(self, node): + self.buildAttributes(node, node.attrib, []) + for child in node: + nodeName_ = Tag_pattern_.match(child.tag).groups()[-1] + self.buildChildren(child, node, nodeName_) + def buildAttributes(self, node, attrs, already_processed): + pass + def buildChildren(self, child_, node, nodeName_, fromsubclass_=False): + pass +# end class virtual_machine_interface_sub_interface + + +class virtual_machine_virtual_machine_interface(GeneratedsSuper): + """ + virtual_machine_virtual_machine_interface class definition from :doc:`vnc_cfg.xsd` + """ + subclass = None + superclass = None + def __init__(self, **kwargs): + pass + def factory(*args_, **kwargs_): + if virtual_machine_virtual_machine_interface.subclass: + return virtual_machine_virtual_machine_interface.subclass(*args_, **kwargs_) + else: + return virtual_machine_virtual_machine_interface(*args_, **kwargs_) + factory = staticmethod(factory) + def __eq__(self, other): return True + def __ne__(self, other): return False + @classmethod + def populate (cls, *a, **kwa): + obj = cls (*a, **kwa) + return obj + def export(self, outfile, level=1, namespace_='', name_='virtual-machine-virtual-machine-interface', namespacedef_='', pretty_print=True): + if pretty_print: + eol_ = '\n' + else: + eol_ = '' + showIndent(outfile, level, pretty_print) + outfile.write('<%s%s%s' % (namespace_, name_, namespacedef_ and ' ' + namespacedef_ or '', )) + already_processed = [] + self.exportAttributes(outfile, level, already_processed, namespace_, name_='virtual-machine-virtual-machine-interface') + if self.hasContent_(): + outfile.write('>%s' % (eol_, )) + self.exportChildren(outfile, level + 1, namespace_, name_, pretty_print=pretty_print) + outfile.write('</%s%s>%s' % (namespace_, name_, eol_)) + else: + outfile.write('/>%s' % (eol_, )) + def exportAttributes(self, outfile, level, already_processed, namespace_='', name_='virtual-machine-virtual-machine-interface'): + pass + def exportChildren(self, outfile, level, namespace_='', name_='virtual-machine-virtual-machine-interface', fromsubclass_=False, pretty_print=True): + pass + def hasContent_(self): + if ( + + ): + return True + else: + return False + def exportLiteral(self, outfile, level, name_='virtual-machine-virtual-machine-interface'): + level += 1 + self.exportLiteralAttributes(outfile, level, [], name_) + if self.hasContent_(): + self.exportLiteralChildren(outfile, level, name_) + def exportLiteralAttributes(self, outfile, level, already_processed, name_): + pass + def exportLiteralChildren(self, outfile, level, name_): + pass + def exportDict(self, name_='virtual-machine-virtual-machine-interface'): + obj_json = json.dumps(self, default=lambda o: dict((k, v) for k, v in o.__dict__.iteritems())) + obj_dict = json.loads(obj_json) + return {name_: obj_dict} + def build(self, node): + self.buildAttributes(node, node.attrib, []) + for child in node: + nodeName_ = Tag_pattern_.match(child.tag).groups()[-1] + self.buildChildren(child, node, nodeName_) + def buildAttributes(self, node, attrs, already_processed): + pass + def buildChildren(self, child_, node, nodeName_, fromsubclass_=False): + pass +# end class virtual_machine_virtual_machine_interface + + +class project_virtual_machine_interface(GeneratedsSuper): + """ + project_virtual_machine_interface class definition from :doc:`vnc_cfg.xsd` + """ + subclass = None + superclass = None + def __init__(self, **kwargs): + pass + def factory(*args_, **kwargs_): + if project_virtual_machine_interface.subclass: + return project_virtual_machine_interface.subclass(*args_, **kwargs_) + else: + return project_virtual_machine_interface(*args_, **kwargs_) + factory = staticmethod(factory) + def __eq__(self, other): return True + def __ne__(self, other): return False + @classmethod + def populate (cls, *a, **kwa): + obj = cls (*a, **kwa) + return obj + def export(self, outfile, level=1, namespace_='', name_='project-virtual-machine-interface', namespacedef_='', pretty_print=True): + if pretty_print: + eol_ = '\n' + else: + eol_ = '' + showIndent(outfile, level, pretty_print) + outfile.write('<%s%s%s' % (namespace_, name_, namespacedef_ and ' ' + namespacedef_ or '', )) + already_processed = [] + self.exportAttributes(outfile, level, already_processed, namespace_, name_='project-virtual-machine-interface') + if self.hasContent_(): + outfile.write('>%s' % (eol_, )) + self.exportChildren(outfile, level + 1, namespace_, name_, pretty_print=pretty_print) + outfile.write('</%s%s>%s' % (namespace_, name_, eol_)) + else: + outfile.write('/>%s' % (eol_, )) + def exportAttributes(self, outfile, level, already_processed, namespace_='', name_='project-virtual-machine-interface'): + pass + def exportChildren(self, outfile, level, namespace_='', name_='project-virtual-machine-interface', fromsubclass_=False, pretty_print=True): + pass + def hasContent_(self): + if ( + + ): + return True + else: + return False + def exportLiteral(self, outfile, level, name_='project-virtual-machine-interface'): + level += 1 + self.exportLiteralAttributes(outfile, level, [], name_) + if self.hasContent_(): + self.exportLiteralChildren(outfile, level, name_) + def exportLiteralAttributes(self, outfile, level, already_processed, name_): + pass + def exportLiteralChildren(self, outfile, level, name_): + pass + def exportDict(self, name_='project-virtual-machine-interface'): + obj_json = json.dumps(self, default=lambda o: dict((k, v) for k, v in o.__dict__.iteritems())) + obj_dict = json.loads(obj_json) + return {name_: obj_dict} + def build(self, node): + self.buildAttributes(node, node.attrib, []) + for child in node: + nodeName_ = Tag_pattern_.match(child.tag).groups()[-1] + self.buildChildren(child, node, nodeName_) + def buildAttributes(self, node, attrs, already_processed): + pass + def buildChildren(self, child_, node, nodeName_, fromsubclass_=False): + pass +# end class project_virtual_machine_interface + + +class virtual_machine_interface_virtual_machine(GeneratedsSuper): + """ + virtual_machine_interface_virtual_machine class definition from :doc:`vnc_cfg.xsd` + """ + subclass = None + superclass = None + def __init__(self, **kwargs): + pass + def factory(*args_, **kwargs_): + if virtual_machine_interface_virtual_machine.subclass: + return virtual_machine_interface_virtual_machine.subclass(*args_, **kwargs_) + else: + return virtual_machine_interface_virtual_machine(*args_, **kwargs_) + factory = staticmethod(factory) + def __eq__(self, other): return True + def __ne__(self, other): return False + @classmethod + def populate (cls, *a, **kwa): + obj = cls (*a, **kwa) + return obj + def export(self, outfile, level=1, namespace_='', name_='virtual-machine-interface-virtual-machine', namespacedef_='', pretty_print=True): + if pretty_print: + eol_ = '\n' + else: + eol_ = '' + showIndent(outfile, level, pretty_print) + outfile.write('<%s%s%s' % (namespace_, name_, namespacedef_ and ' ' + namespacedef_ or '', )) + already_processed = [] + self.exportAttributes(outfile, level, already_processed, namespace_, name_='virtual-machine-interface-virtual-machine') + if self.hasContent_(): + outfile.write('>%s' % (eol_, )) + self.exportChildren(outfile, level + 1, namespace_, name_, pretty_print=pretty_print) + outfile.write('</%s%s>%s' % (namespace_, name_, eol_)) + else: + outfile.write('/>%s' % (eol_, )) + def exportAttributes(self, outfile, level, already_processed, namespace_='', name_='virtual-machine-interface-virtual-machine'): + pass + def exportChildren(self, outfile, level, namespace_='', name_='virtual-machine-interface-virtual-machine', fromsubclass_=False, pretty_print=True): + pass + def hasContent_(self): + if ( + + ): + return True + else: + return False + def exportLiteral(self, outfile, level, name_='virtual-machine-interface-virtual-machine'): + level += 1 + self.exportLiteralAttributes(outfile, level, [], name_) + if self.hasContent_(): + self.exportLiteralChildren(outfile, level, name_) + def exportLiteralAttributes(self, outfile, level, already_processed, name_): + pass + def exportLiteralChildren(self, outfile, level, name_): + pass + def exportDict(self, name_='virtual-machine-interface-virtual-machine'): + obj_json = json.dumps(self, default=lambda o: dict((k, v) for k, v in o.__dict__.iteritems())) + obj_dict = json.loads(obj_json) + return {name_: obj_dict} + def build(self, node): + self.buildAttributes(node, node.attrib, []) + for child in node: + nodeName_ = Tag_pattern_.match(child.tag).groups()[-1] + self.buildChildren(child, node, nodeName_) + def buildAttributes(self, node, attrs, already_processed): + pass + def buildChildren(self, child_, node, nodeName_, fromsubclass_=False): + pass +# end class virtual_machine_interface_virtual_machine + + +class virtual_machine_interface_virtual_network(GeneratedsSuper): + """ + virtual_machine_interface_virtual_network class definition from :doc:`vnc_cfg.xsd` + """ + subclass = None + superclass = None + def __init__(self, **kwargs): + pass + def factory(*args_, **kwargs_): + if virtual_machine_interface_virtual_network.subclass: + return virtual_machine_interface_virtual_network.subclass(*args_, **kwargs_) + else: + return virtual_machine_interface_virtual_network(*args_, **kwargs_) + factory = staticmethod(factory) + def __eq__(self, other): return True + def __ne__(self, other): return False + @classmethod + def populate (cls, *a, **kwa): + obj = cls (*a, **kwa) + return obj + def export(self, outfile, level=1, namespace_='', name_='virtual-machine-interface-virtual-network', namespacedef_='', pretty_print=True): + if pretty_print: + eol_ = '\n' + else: + eol_ = '' + showIndent(outfile, level, pretty_print) + outfile.write('<%s%s%s' % (namespace_, name_, namespacedef_ and ' ' + namespacedef_ or '', )) + already_processed = [] + self.exportAttributes(outfile, level, already_processed, namespace_, name_='virtual-machine-interface-virtual-network') + if self.hasContent_(): + outfile.write('>%s' % (eol_, )) + self.exportChildren(outfile, level + 1, namespace_, name_, pretty_print=pretty_print) + outfile.write('</%s%s>%s' % (namespace_, name_, eol_)) + else: + outfile.write('/>%s' % (eol_, )) + def exportAttributes(self, outfile, level, already_processed, namespace_='', name_='virtual-machine-interface-virtual-network'): + pass + def exportChildren(self, outfile, level, namespace_='', name_='virtual-machine-interface-virtual-network', fromsubclass_=False, pretty_print=True): + pass + def hasContent_(self): + if ( + + ): + return True + else: + return False + def exportLiteral(self, outfile, level, name_='virtual-machine-interface-virtual-network'): + level += 1 + self.exportLiteralAttributes(outfile, level, [], name_) + if self.hasContent_(): + self.exportLiteralChildren(outfile, level, name_) + def exportLiteralAttributes(self, outfile, level, already_processed, name_): + pass + def exportLiteralChildren(self, outfile, level, name_): + pass + def exportDict(self, name_='virtual-machine-interface-virtual-network'): + obj_json = json.dumps(self, default=lambda o: dict((k, v) for k, v in o.__dict__.iteritems())) + obj_dict = json.loads(obj_json) + return {name_: obj_dict} + def build(self, node): + self.buildAttributes(node, node.attrib, []) + for child in node: + nodeName_ = Tag_pattern_.match(child.tag).groups()[-1] + self.buildChildren(child, node, nodeName_) + def buildAttributes(self, node, attrs, already_processed): + pass + def buildChildren(self, child_, node, nodeName_, fromsubclass_=False): + pass +# end class virtual_machine_interface_virtual_network + + +class PolicyBasedForwardingRuleType(GeneratedsSuper): + """ + PolicyBasedForwardingRuleType class definition from :doc:`vnc_cfg.xsd` + """ + subclass = None + superclass = None + def __init__(self, direction=None, vlan_tag=None, src_mac=None, dst_mac=None, mpls_label=None, service_chain_address=None, protocol=None, **kwargs): + self.direction = direction + self.vlan_tag = vlan_tag + self.src_mac = src_mac + self.dst_mac = dst_mac + self.mpls_label = mpls_label + self.service_chain_address = service_chain_address + self.protocol = protocol + def factory(*args_, **kwargs_): + if PolicyBasedForwardingRuleType.subclass: + return PolicyBasedForwardingRuleType.subclass(*args_, **kwargs_) + else: + return PolicyBasedForwardingRuleType(*args_, **kwargs_) + factory = staticmethod(factory) + def get_direction(self): return self.direction + def set_direction(self, direction): self.direction = direction + def validate_TrafficDirectionType(self, value): + # Validate type TrafficDirectionType, a restriction on xsd:string. + error = False + if isinstance(value, list): + error = set(value) - set([u'ingress', u'egress', u'both']) + else: + error = value not in [u'ingress', u'egress', u'both'] + if error: + raise ValueError("TrafficDirectionType must be one of [u'ingress', u'egress', u'both']") + def get_vlan_tag(self): return self.vlan_tag + def set_vlan_tag(self, vlan_tag): self.vlan_tag = vlan_tag + def get_src_mac(self): return self.src_mac + def set_src_mac(self, src_mac): self.src_mac = src_mac + def get_dst_mac(self): return self.dst_mac + def set_dst_mac(self, dst_mac): self.dst_mac = dst_mac + def get_mpls_label(self): return self.mpls_label + def set_mpls_label(self, mpls_label): self.mpls_label = mpls_label + def get_service_chain_address(self): return self.service_chain_address + def set_service_chain_address(self, service_chain_address): self.service_chain_address = service_chain_address + def validate_IpAddress(self, value): + # Validate type IpAddress, a restriction on xsd:string. + pass + def get_protocol(self): return self.protocol + def set_protocol(self, protocol): self.protocol = protocol + def __eq__(self, other): + if isinstance(other, self.__class__): + return (self.direction == other.direction and + self.vlan_tag == other.vlan_tag and + self.src_mac == other.src_mac and + self.dst_mac == other.dst_mac and + self.mpls_label == other.mpls_label and + self.service_chain_address == other.service_chain_address and + self.protocol == other.protocol) + return NotImplemented + def __ne__(self, other): + if isinstance(other, self.__class__): + return not self.__eq__(other) + return NotImplemented + + @classmethod + def populate (cls, *a, **kwa): + obj = cls (*a, **kwa) + obj.set_direction (obj.populate_string ("direction")) + obj.set_vlan_tag (obj.populate_integer ("vlan_tag")) + obj.set_src_mac (obj.populate_string ("src_mac")) + obj.set_dst_mac (obj.populate_string ("dst_mac")) + obj.set_mpls_label (obj.populate_integer ("mpls_label")) + obj.set_service_chain_address (obj.populate_string ("service_chain_address")) + obj.set_protocol (obj.populate_string ("protocol")) + return obj + def export(self, outfile, level=1, namespace_='', name_='PolicyBasedForwardingRuleType', namespacedef_='', pretty_print=True): + if pretty_print: + eol_ = '\n' + else: + eol_ = '' + showIndent(outfile, level, pretty_print) + outfile.write('<%s%s%s' % (namespace_, name_, namespacedef_ and ' ' + namespacedef_ or '', )) + already_processed = [] + self.exportAttributes(outfile, level, already_processed, namespace_, name_='PolicyBasedForwardingRuleType') + if self.hasContent_(): + outfile.write('>%s' % (eol_, )) + self.exportChildren(outfile, level + 1, namespace_, name_, pretty_print=pretty_print) + showIndent(outfile, level, pretty_print) + outfile.write('</%s%s>%s' % (namespace_, name_, eol_)) + else: + outfile.write('/>%s' % (eol_, )) + def exportAttributes(self, outfile, level, already_processed, namespace_='', name_='PolicyBasedForwardingRuleType'): + pass + def exportChildren(self, outfile, level, namespace_='', name_='PolicyBasedForwardingRuleType', fromsubclass_=False, pretty_print=True): + if pretty_print: + eol_ = '\n' + else: + eol_ = '' + if self.direction is not None: + showIndent(outfile, level, pretty_print) + outfile.write('<%sdirection>%s</%sdirection>%s' % (namespace_, self.gds_format_string(quote_xml(self.direction).encode(ExternalEncoding), input_name='direction'), namespace_, eol_)) + if self.vlan_tag is not None: + showIndent(outfile, level, pretty_print) + outfile.write('<%svlan-tag>%s</%svlan-tag>%s' % (namespace_, self.gds_format_integer(self.vlan_tag, input_name='vlan-tag'), namespace_, eol_)) + if self.src_mac is not None: + showIndent(outfile, level, pretty_print) + outfile.write('<%ssrc-mac>%s</%ssrc-mac>%s' % (namespace_, self.gds_format_string(quote_xml(self.src_mac).encode(ExternalEncoding), input_name='src-mac'), namespace_, eol_)) + if self.dst_mac is not None: + showIndent(outfile, level, pretty_print) + outfile.write('<%sdst-mac>%s</%sdst-mac>%s' % (namespace_, self.gds_format_string(quote_xml(self.dst_mac).encode(ExternalEncoding), input_name='dst-mac'), namespace_, eol_)) + if self.mpls_label is not None: + showIndent(outfile, level, pretty_print) + outfile.write('<%smpls-label>%s</%smpls-label>%s' % (namespace_, self.gds_format_integer(self.mpls_label, input_name='mpls-label'), namespace_, eol_)) + if self.service_chain_address is not None: + showIndent(outfile, level, pretty_print) + outfile.write('<%sservice-chain-address>%s</%sservice-chain-address>%s' % (namespace_, self.gds_format_string(quote_xml(self.service_chain_address).encode(ExternalEncoding), input_name='service-chain-address'), namespace_, eol_)) + if self.protocol is not None: + showIndent(outfile, level, pretty_print) + outfile.write('<%sprotocol>%s</%sprotocol>%s' % (namespace_, self.gds_format_string(quote_xml(self.protocol).encode(ExternalEncoding), input_name='protocol'), namespace_, eol_)) + def hasContent_(self): + if ( + self.direction is not None or + self.vlan_tag is not None or + self.src_mac is not None or + self.dst_mac is not None or + self.mpls_label is not None or + self.service_chain_address is not None or + self.protocol is not None + ): + return True + else: + return False + def exportLiteral(self, outfile, level, name_='PolicyBasedForwardingRuleType'): + level += 1 + self.exportLiteralAttributes(outfile, level, [], name_) + if self.hasContent_(): + self.exportLiteralChildren(outfile, level, name_) + def exportLiteralAttributes(self, outfile, level, already_processed, name_): + pass + def exportLiteralChildren(self, outfile, level, name_): + if self.direction is not None: + showIndent(outfile, level) + outfile.write('direction=%s,\n' % quote_python(self.direction).encode(ExternalEncoding)) + if self.vlan_tag is not None: + showIndent(outfile, level) + outfile.write('vlan_tag=%d,\n' % self.vlan_tag) + if self.src_mac is not None: + showIndent(outfile, level) + outfile.write('src_mac=%s,\n' % quote_python(self.src_mac).encode(ExternalEncoding)) + if self.dst_mac is not None: + showIndent(outfile, level) + outfile.write('dst_mac=%s,\n' % quote_python(self.dst_mac).encode(ExternalEncoding)) + if self.mpls_label is not None: + showIndent(outfile, level) + outfile.write('mpls_label=%d,\n' % self.mpls_label) + if self.service_chain_address is not None: + showIndent(outfile, level) + outfile.write('service_chain_address=%s,\n' % quote_python(self.service_chain_address).encode(ExternalEncoding)) + if self.protocol is not None: + showIndent(outfile, level) + outfile.write('protocol=%s,\n' % quote_python(self.protocol).encode(ExternalEncoding)) + def exportDict(self, name_='PolicyBasedForwardingRuleType'): + obj_json = json.dumps(self, default=lambda o: dict((k, v) for k, v in o.__dict__.iteritems())) + obj_dict = json.loads(obj_json) + return {name_: obj_dict} + def build(self, node): + self.buildAttributes(node, node.attrib, []) + for child in node: + nodeName_ = Tag_pattern_.match(child.tag).groups()[-1] + self.buildChildren(child, node, nodeName_) + def buildAttributes(self, node, attrs, already_processed): + pass + def buildChildren(self, child_, node, nodeName_, fromsubclass_=False): + if nodeName_ == 'direction': + direction_ = child_.text + direction_ = self.gds_validate_string(direction_, node, 'direction') + self.direction = direction_ + self.validate_TrafficDirectionType(self.direction) # validate type TrafficDirectionType + elif nodeName_ == 'vlan-tag': + sval_ = child_.text + try: + ival_ = int(sval_) + except (TypeError, ValueError), exp: + raise_parse_error(child_, 'requires integer: %s' % exp) + ival_ = self.gds_validate_integer(ival_, node, 'vlan_tag') + self.vlan_tag = ival_ + elif nodeName_ == 'src-mac': + src_mac_ = child_.text + src_mac_ = self.gds_validate_string(src_mac_, node, 'src_mac') + self.src_mac = src_mac_ + elif nodeName_ == 'dst-mac': + dst_mac_ = child_.text + dst_mac_ = self.gds_validate_string(dst_mac_, node, 'dst_mac') + self.dst_mac = dst_mac_ + elif nodeName_ == 'mpls-label': + sval_ = child_.text + try: + ival_ = int(sval_) + except (TypeError, ValueError), exp: + raise_parse_error(child_, 'requires integer: %s' % exp) + ival_ = self.gds_validate_integer(ival_, node, 'mpls_label') + self.mpls_label = ival_ + elif nodeName_ == 'service-chain-address': + service_chain_address_ = child_.text + service_chain_address_ = self.gds_validate_string(service_chain_address_, node, 'service_chain_address') + self.service_chain_address = service_chain_address_ + self.validate_IpAddress(self.service_chain_address) # validate type IpAddress + elif nodeName_ == 'protocol': + protocol_ = child_.text + protocol_ = self.gds_validate_string(protocol_, node, 'protocol') + self.protocol = protocol_ +# end class PolicyBasedForwardingRuleType + + +class instance_ip_virtual_network(GeneratedsSuper): + """ + instance_ip_virtual_network class definition from :doc:`vnc_cfg.xsd` + """ + subclass = None + superclass = None + def __init__(self, **kwargs): + pass + def factory(*args_, **kwargs_): + if instance_ip_virtual_network.subclass: + return instance_ip_virtual_network.subclass(*args_, **kwargs_) + else: + return instance_ip_virtual_network(*args_, **kwargs_) + factory = staticmethod(factory) + def __eq__(self, other): return True + def __ne__(self, other): return False + @classmethod + def populate (cls, *a, **kwa): + obj = cls (*a, **kwa) + return obj + def export(self, outfile, level=1, namespace_='', name_='instance-ip-virtual-network', namespacedef_='', pretty_print=True): + if pretty_print: + eol_ = '\n' + else: + eol_ = '' + showIndent(outfile, level, pretty_print) + outfile.write('<%s%s%s' % (namespace_, name_, namespacedef_ and ' ' + namespacedef_ or '', )) + already_processed = [] + self.exportAttributes(outfile, level, already_processed, namespace_, name_='instance-ip-virtual-network') + if self.hasContent_(): + outfile.write('>%s' % (eol_, )) + self.exportChildren(outfile, level + 1, namespace_, name_, pretty_print=pretty_print) + outfile.write('</%s%s>%s' % (namespace_, name_, eol_)) + else: + outfile.write('/>%s' % (eol_, )) + def exportAttributes(self, outfile, level, already_processed, namespace_='', name_='instance-ip-virtual-network'): + pass + def exportChildren(self, outfile, level, namespace_='', name_='instance-ip-virtual-network', fromsubclass_=False, pretty_print=True): + pass + def hasContent_(self): + if ( + + ): + return True + else: + return False + def exportLiteral(self, outfile, level, name_='instance-ip-virtual-network'): + level += 1 + self.exportLiteralAttributes(outfile, level, [], name_) + if self.hasContent_(): + self.exportLiteralChildren(outfile, level, name_) + def exportLiteralAttributes(self, outfile, level, already_processed, name_): + pass + def exportLiteralChildren(self, outfile, level, name_): + pass + def exportDict(self, name_='instance-ip-virtual-network'): + obj_json = json.dumps(self, default=lambda o: dict((k, v) for k, v in o.__dict__.iteritems())) + obj_dict = json.loads(obj_json) + return {name_: obj_dict} + def build(self, node): + self.buildAttributes(node, node.attrib, []) + for child in node: + nodeName_ = Tag_pattern_.match(child.tag).groups()[-1] + self.buildChildren(child, node, nodeName_) + def buildAttributes(self, node, attrs, already_processed): + pass + def buildChildren(self, child_, node, nodeName_, fromsubclass_=False): + pass +# end class instance_ip_virtual_network + + +class instance_ip_virtual_machine_interface(GeneratedsSuper): + """ + instance_ip_virtual_machine_interface class definition from :doc:`vnc_cfg.xsd` + """ + subclass = None + superclass = None + def __init__(self, **kwargs): + pass + def factory(*args_, **kwargs_): + if instance_ip_virtual_machine_interface.subclass: + return instance_ip_virtual_machine_interface.subclass(*args_, **kwargs_) + else: + return instance_ip_virtual_machine_interface(*args_, **kwargs_) + factory = staticmethod(factory) + def __eq__(self, other): return True + def __ne__(self, other): return False + @classmethod + def populate (cls, *a, **kwa): + obj = cls (*a, **kwa) + return obj + def export(self, outfile, level=1, namespace_='', name_='instance-ip-virtual-machine-interface', namespacedef_='', pretty_print=True): + if pretty_print: + eol_ = '\n' + else: + eol_ = '' + showIndent(outfile, level, pretty_print) + outfile.write('<%s%s%s' % (namespace_, name_, namespacedef_ and ' ' + namespacedef_ or '', )) + already_processed = [] + self.exportAttributes(outfile, level, already_processed, namespace_, name_='instance-ip-virtual-machine-interface') + if self.hasContent_(): + outfile.write('>%s' % (eol_, )) + self.exportChildren(outfile, level + 1, namespace_, name_, pretty_print=pretty_print) + outfile.write('</%s%s>%s' % (namespace_, name_, eol_)) + else: + outfile.write('/>%s' % (eol_, )) + def exportAttributes(self, outfile, level, already_processed, namespace_='', name_='instance-ip-virtual-machine-interface'): + pass + def exportChildren(self, outfile, level, namespace_='', name_='instance-ip-virtual-machine-interface', fromsubclass_=False, pretty_print=True): + pass + def hasContent_(self): + if ( + + ): + return True + else: + return False + def exportLiteral(self, outfile, level, name_='instance-ip-virtual-machine-interface'): + level += 1 + self.exportLiteralAttributes(outfile, level, [], name_) + if self.hasContent_(): + self.exportLiteralChildren(outfile, level, name_) + def exportLiteralAttributes(self, outfile, level, already_processed, name_): + pass + def exportLiteralChildren(self, outfile, level, name_): + pass + def exportDict(self, name_='instance-ip-virtual-machine-interface'): + obj_json = json.dumps(self, default=lambda o: dict((k, v) for k, v in o.__dict__.iteritems())) + obj_dict = json.loads(obj_json) + return {name_: obj_dict} + def build(self, node): + self.buildAttributes(node, node.attrib, []) + for child in node: + nodeName_ = Tag_pattern_.match(child.tag).groups()[-1] + self.buildChildren(child, node, nodeName_) + def buildAttributes(self, node, attrs, already_processed): + pass + def buildChildren(self, child_, node, nodeName_, fromsubclass_=False): + pass +# end class instance_ip_virtual_machine_interface + + +class subnet_virtual_machine_interface(GeneratedsSuper): + """ + subnet_virtual_machine_interface class definition from :doc:`vnc_cfg.xsd` + """ + subclass = None + superclass = None + def __init__(self, **kwargs): + pass + def factory(*args_, **kwargs_): + if subnet_virtual_machine_interface.subclass: + return subnet_virtual_machine_interface.subclass(*args_, **kwargs_) + else: + return subnet_virtual_machine_interface(*args_, **kwargs_) + factory = staticmethod(factory) + def __eq__(self, other): return True + def __ne__(self, other): return False + @classmethod + def populate (cls, *a, **kwa): + obj = cls (*a, **kwa) + return obj + def export(self, outfile, level=1, namespace_='', name_='subnet-virtual-machine-interface', namespacedef_='', pretty_print=True): + if pretty_print: + eol_ = '\n' + else: + eol_ = '' + showIndent(outfile, level, pretty_print) + outfile.write('<%s%s%s' % (namespace_, name_, namespacedef_ and ' ' + namespacedef_ or '', )) + already_processed = [] + self.exportAttributes(outfile, level, already_processed, namespace_, name_='subnet-virtual-machine-interface') + if self.hasContent_(): + outfile.write('>%s' % (eol_, )) + self.exportChildren(outfile, level + 1, namespace_, name_, pretty_print=pretty_print) + outfile.write('</%s%s>%s' % (namespace_, name_, eol_)) + else: + outfile.write('/>%s' % (eol_, )) + def exportAttributes(self, outfile, level, already_processed, namespace_='', name_='subnet-virtual-machine-interface'): + pass + def exportChildren(self, outfile, level, namespace_='', name_='subnet-virtual-machine-interface', fromsubclass_=False, pretty_print=True): + pass + def hasContent_(self): + if ( + + ): + return True + else: + return False + def exportLiteral(self, outfile, level, name_='subnet-virtual-machine-interface'): + level += 1 + self.exportLiteralAttributes(outfile, level, [], name_) + if self.hasContent_(): + self.exportLiteralChildren(outfile, level, name_) + def exportLiteralAttributes(self, outfile, level, already_processed, name_): + pass + def exportLiteralChildren(self, outfile, level, name_): + pass + def exportDict(self, name_='subnet-virtual-machine-interface'): + obj_json = json.dumps(self, default=lambda o: dict((k, v) for k, v in o.__dict__.iteritems())) + obj_dict = json.loads(obj_json) + return {name_: obj_dict} + def build(self, node): + self.buildAttributes(node, node.attrib, []) + for child in node: + nodeName_ = Tag_pattern_.match(child.tag).groups()[-1] + self.buildChildren(child, node, nodeName_) + def buildAttributes(self, node, attrs, already_processed): + pass + def buildChildren(self, child_, node, nodeName_, fromsubclass_=False): + pass +# end class subnet_virtual_machine_interface + + +class virtual_network_floating_ip_pool(GeneratedsSuper): + """ + virtual_network_floating_ip_pool class definition from :doc:`vnc_cfg.xsd` + """ + subclass = None + superclass = None + def __init__(self, **kwargs): + pass + def factory(*args_, **kwargs_): + if virtual_network_floating_ip_pool.subclass: + return virtual_network_floating_ip_pool.subclass(*args_, **kwargs_) + else: + return virtual_network_floating_ip_pool(*args_, **kwargs_) + factory = staticmethod(factory) + def __eq__(self, other): return True + def __ne__(self, other): return False + @classmethod + def populate (cls, *a, **kwa): + obj = cls (*a, **kwa) + return obj + def export(self, outfile, level=1, namespace_='', name_='virtual-network-floating-ip-pool', namespacedef_='', pretty_print=True): + if pretty_print: + eol_ = '\n' + else: + eol_ = '' + showIndent(outfile, level, pretty_print) + outfile.write('<%s%s%s' % (namespace_, name_, namespacedef_ and ' ' + namespacedef_ or '', )) + already_processed = [] + self.exportAttributes(outfile, level, already_processed, namespace_, name_='virtual-network-floating-ip-pool') + if self.hasContent_(): + outfile.write('>%s' % (eol_, )) + self.exportChildren(outfile, level + 1, namespace_, name_, pretty_print=pretty_print) + outfile.write('</%s%s>%s' % (namespace_, name_, eol_)) + else: + outfile.write('/>%s' % (eol_, )) + def exportAttributes(self, outfile, level, already_processed, namespace_='', name_='virtual-network-floating-ip-pool'): + pass + def exportChildren(self, outfile, level, namespace_='', name_='virtual-network-floating-ip-pool', fromsubclass_=False, pretty_print=True): + pass + def hasContent_(self): + if ( + + ): + return True + else: + return False + def exportLiteral(self, outfile, level, name_='virtual-network-floating-ip-pool'): + level += 1 + self.exportLiteralAttributes(outfile, level, [], name_) + if self.hasContent_(): + self.exportLiteralChildren(outfile, level, name_) + def exportLiteralAttributes(self, outfile, level, already_processed, name_): + pass + def exportLiteralChildren(self, outfile, level, name_): + pass + def exportDict(self, name_='virtual-network-floating-ip-pool'): + obj_json = json.dumps(self, default=lambda o: dict((k, v) for k, v in o.__dict__.iteritems())) + obj_dict = json.loads(obj_json) + return {name_: obj_dict} + def build(self, node): + self.buildAttributes(node, node.attrib, []) + for child in node: + nodeName_ = Tag_pattern_.match(child.tag).groups()[-1] + self.buildChildren(child, node, nodeName_) + def buildAttributes(self, node, attrs, already_processed): + pass + def buildChildren(self, child_, node, nodeName_, fromsubclass_=False): + pass +# end class virtual_network_floating_ip_pool + + +class project_floating_ip_pool(GeneratedsSuper): + """ + project_floating_ip_pool class definition from :doc:`vnc_cfg.xsd` + """ + subclass = None + superclass = None + def __init__(self, **kwargs): + pass + def factory(*args_, **kwargs_): + if project_floating_ip_pool.subclass: + return project_floating_ip_pool.subclass(*args_, **kwargs_) + else: + return project_floating_ip_pool(*args_, **kwargs_) + factory = staticmethod(factory) + def __eq__(self, other): return True + def __ne__(self, other): return False + @classmethod + def populate (cls, *a, **kwa): + obj = cls (*a, **kwa) + return obj + def export(self, outfile, level=1, namespace_='', name_='project-floating-ip-pool', namespacedef_='', pretty_print=True): + if pretty_print: + eol_ = '\n' + else: + eol_ = '' + showIndent(outfile, level, pretty_print) + outfile.write('<%s%s%s' % (namespace_, name_, namespacedef_ and ' ' + namespacedef_ or '', )) + already_processed = [] + self.exportAttributes(outfile, level, already_processed, namespace_, name_='project-floating-ip-pool') + if self.hasContent_(): + outfile.write('>%s' % (eol_, )) + self.exportChildren(outfile, level + 1, namespace_, name_, pretty_print=pretty_print) + outfile.write('</%s%s>%s' % (namespace_, name_, eol_)) + else: + outfile.write('/>%s' % (eol_, )) + def exportAttributes(self, outfile, level, already_processed, namespace_='', name_='project-floating-ip-pool'): + pass + def exportChildren(self, outfile, level, namespace_='', name_='project-floating-ip-pool', fromsubclass_=False, pretty_print=True): + pass + def hasContent_(self): + if ( + + ): + return True + else: + return False + def exportLiteral(self, outfile, level, name_='project-floating-ip-pool'): + level += 1 + self.exportLiteralAttributes(outfile, level, [], name_) + if self.hasContent_(): + self.exportLiteralChildren(outfile, level, name_) + def exportLiteralAttributes(self, outfile, level, already_processed, name_): + pass + def exportLiteralChildren(self, outfile, level, name_): + pass + def exportDict(self, name_='project-floating-ip-pool'): + obj_json = json.dumps(self, default=lambda o: dict((k, v) for k, v in o.__dict__.iteritems())) + obj_dict = json.loads(obj_json) + return {name_: obj_dict} + def build(self, node): + self.buildAttributes(node, node.attrib, []) + for child in node: + nodeName_ = Tag_pattern_.match(child.tag).groups()[-1] + self.buildChildren(child, node, nodeName_) + def buildAttributes(self, node, attrs, already_processed): + pass + def buildChildren(self, child_, node, nodeName_, fromsubclass_=False): + pass +# end class project_floating_ip_pool + + +class floating_ip_project(GeneratedsSuper): + """ + floating_ip_project class definition from :doc:`vnc_cfg.xsd` + """ + subclass = None + superclass = None + def __init__(self, **kwargs): + pass + def factory(*args_, **kwargs_): + if floating_ip_project.subclass: + return floating_ip_project.subclass(*args_, **kwargs_) + else: + return floating_ip_project(*args_, **kwargs_) + factory = staticmethod(factory) + def __eq__(self, other): return True + def __ne__(self, other): return False + @classmethod + def populate (cls, *a, **kwa): + obj = cls (*a, **kwa) + return obj + def export(self, outfile, level=1, namespace_='', name_='floating-ip-project', namespacedef_='', pretty_print=True): + if pretty_print: + eol_ = '\n' + else: + eol_ = '' + showIndent(outfile, level, pretty_print) + outfile.write('<%s%s%s' % (namespace_, name_, namespacedef_ and ' ' + namespacedef_ or '', )) + already_processed = [] + self.exportAttributes(outfile, level, already_processed, namespace_, name_='floating-ip-project') + if self.hasContent_(): + outfile.write('>%s' % (eol_, )) + self.exportChildren(outfile, level + 1, namespace_, name_, pretty_print=pretty_print) + outfile.write('</%s%s>%s' % (namespace_, name_, eol_)) + else: + outfile.write('/>%s' % (eol_, )) + def exportAttributes(self, outfile, level, already_processed, namespace_='', name_='floating-ip-project'): + pass + def exportChildren(self, outfile, level, namespace_='', name_='floating-ip-project', fromsubclass_=False, pretty_print=True): + pass + def hasContent_(self): + if ( + + ): + return True + else: + return False + def exportLiteral(self, outfile, level, name_='floating-ip-project'): + level += 1 + self.exportLiteralAttributes(outfile, level, [], name_) + if self.hasContent_(): + self.exportLiteralChildren(outfile, level, name_) + def exportLiteralAttributes(self, outfile, level, already_processed, name_): + pass + def exportLiteralChildren(self, outfile, level, name_): + pass + def exportDict(self, name_='floating-ip-project'): + obj_json = json.dumps(self, default=lambda o: dict((k, v) for k, v in o.__dict__.iteritems())) + obj_dict = json.loads(obj_json) + return {name_: obj_dict} + def build(self, node): + self.buildAttributes(node, node.attrib, []) + for child in node: + nodeName_ = Tag_pattern_.match(child.tag).groups()[-1] + self.buildChildren(child, node, nodeName_) + def buildAttributes(self, node, attrs, already_processed): + pass + def buildChildren(self, child_, node, nodeName_, fromsubclass_=False): + pass +# end class floating_ip_project + + +class floating_ip_pool_floating_ip(GeneratedsSuper): + """ + floating_ip_pool_floating_ip class definition from :doc:`vnc_cfg.xsd` + """ + subclass = None + superclass = None + def __init__(self, **kwargs): + pass + def factory(*args_, **kwargs_): + if floating_ip_pool_floating_ip.subclass: + return floating_ip_pool_floating_ip.subclass(*args_, **kwargs_) + else: + return floating_ip_pool_floating_ip(*args_, **kwargs_) + factory = staticmethod(factory) + def __eq__(self, other): return True + def __ne__(self, other): return False + @classmethod + def populate (cls, *a, **kwa): + obj = cls (*a, **kwa) + return obj + def export(self, outfile, level=1, namespace_='', name_='floating-ip-pool-floating-ip', namespacedef_='', pretty_print=True): + if pretty_print: + eol_ = '\n' + else: + eol_ = '' + showIndent(outfile, level, pretty_print) + outfile.write('<%s%s%s' % (namespace_, name_, namespacedef_ and ' ' + namespacedef_ or '', )) + already_processed = [] + self.exportAttributes(outfile, level, already_processed, namespace_, name_='floating-ip-pool-floating-ip') + if self.hasContent_(): + outfile.write('>%s' % (eol_, )) + self.exportChildren(outfile, level + 1, namespace_, name_, pretty_print=pretty_print) + outfile.write('</%s%s>%s' % (namespace_, name_, eol_)) + else: + outfile.write('/>%s' % (eol_, )) + def exportAttributes(self, outfile, level, already_processed, namespace_='', name_='floating-ip-pool-floating-ip'): + pass + def exportChildren(self, outfile, level, namespace_='', name_='floating-ip-pool-floating-ip', fromsubclass_=False, pretty_print=True): + pass + def hasContent_(self): + if ( + + ): + return True + else: + return False + def exportLiteral(self, outfile, level, name_='floating-ip-pool-floating-ip'): + level += 1 + self.exportLiteralAttributes(outfile, level, [], name_) + if self.hasContent_(): + self.exportLiteralChildren(outfile, level, name_) + def exportLiteralAttributes(self, outfile, level, already_processed, name_): + pass + def exportLiteralChildren(self, outfile, level, name_): + pass + def exportDict(self, name_='floating-ip-pool-floating-ip'): + obj_json = json.dumps(self, default=lambda o: dict((k, v) for k, v in o.__dict__.iteritems())) + obj_dict = json.loads(obj_json) + return {name_: obj_dict} + def build(self, node): + self.buildAttributes(node, node.attrib, []) + for child in node: + nodeName_ = Tag_pattern_.match(child.tag).groups()[-1] + self.buildChildren(child, node, nodeName_) + def buildAttributes(self, node, attrs, already_processed): + pass + def buildChildren(self, child_, node, nodeName_, fromsubclass_=False): + pass +# end class floating_ip_pool_floating_ip + + +class floating_ip_virtual_machine_interface(GeneratedsSuper): + """ + floating_ip_virtual_machine_interface class definition from :doc:`vnc_cfg.xsd` + """ + subclass = None + superclass = None + def __init__(self, **kwargs): + pass + def factory(*args_, **kwargs_): + if floating_ip_virtual_machine_interface.subclass: + return floating_ip_virtual_machine_interface.subclass(*args_, **kwargs_) + else: + return floating_ip_virtual_machine_interface(*args_, **kwargs_) + factory = staticmethod(factory) + def __eq__(self, other): return True + def __ne__(self, other): return False + @classmethod + def populate (cls, *a, **kwa): + obj = cls (*a, **kwa) + return obj + def export(self, outfile, level=1, namespace_='', name_='floating-ip-virtual-machine-interface', namespacedef_='', pretty_print=True): + if pretty_print: + eol_ = '\n' + else: + eol_ = '' + showIndent(outfile, level, pretty_print) + outfile.write('<%s%s%s' % (namespace_, name_, namespacedef_ and ' ' + namespacedef_ or '', )) + already_processed = [] + self.exportAttributes(outfile, level, already_processed, namespace_, name_='floating-ip-virtual-machine-interface') + if self.hasContent_(): + outfile.write('>%s' % (eol_, )) + self.exportChildren(outfile, level + 1, namespace_, name_, pretty_print=pretty_print) + outfile.write('</%s%s>%s' % (namespace_, name_, eol_)) + else: + outfile.write('/>%s' % (eol_, )) + def exportAttributes(self, outfile, level, already_processed, namespace_='', name_='floating-ip-virtual-machine-interface'): + pass + def exportChildren(self, outfile, level, namespace_='', name_='floating-ip-virtual-machine-interface', fromsubclass_=False, pretty_print=True): + pass + def hasContent_(self): + if ( + + ): + return True + else: + return False + def exportLiteral(self, outfile, level, name_='floating-ip-virtual-machine-interface'): + level += 1 + self.exportLiteralAttributes(outfile, level, [], name_) + if self.hasContent_(): + self.exportLiteralChildren(outfile, level, name_) + def exportLiteralAttributes(self, outfile, level, already_processed, name_): + pass + def exportLiteralChildren(self, outfile, level, name_): + pass + def exportDict(self, name_='floating-ip-virtual-machine-interface'): + obj_json = json.dumps(self, default=lambda o: dict((k, v) for k, v in o.__dict__.iteritems())) + obj_dict = json.loads(obj_json) + return {name_: obj_dict} + def build(self, node): + self.buildAttributes(node, node.attrib, []) + for child in node: + nodeName_ = Tag_pattern_.match(child.tag).groups()[-1] + self.buildChildren(child, node, nodeName_) + def buildAttributes(self, node, attrs, already_processed): + pass + def buildChildren(self, child_, node, nodeName_, fromsubclass_=False): + pass +# end class floating_ip_virtual_machine_interface + + +class global_system_config_physical_router(GeneratedsSuper): + """ + global_system_config_physical_router class definition from :doc:`vnc_cfg.xsd` + """ + subclass = None + superclass = None + def __init__(self, **kwargs): + pass + def factory(*args_, **kwargs_): + if global_system_config_physical_router.subclass: + return global_system_config_physical_router.subclass(*args_, **kwargs_) + else: + return global_system_config_physical_router(*args_, **kwargs_) + factory = staticmethod(factory) + def __eq__(self, other): return True + def __ne__(self, other): return False + @classmethod + def populate (cls, *a, **kwa): + obj = cls (*a, **kwa) + return obj + def export(self, outfile, level=1, namespace_='', name_='global-system-config-physical-router', namespacedef_='', pretty_print=True): + if pretty_print: + eol_ = '\n' + else: + eol_ = '' + showIndent(outfile, level, pretty_print) + outfile.write('<%s%s%s' % (namespace_, name_, namespacedef_ and ' ' + namespacedef_ or '', )) + already_processed = [] + self.exportAttributes(outfile, level, already_processed, namespace_, name_='global-system-config-physical-router') + if self.hasContent_(): + outfile.write('>%s' % (eol_, )) + self.exportChildren(outfile, level + 1, namespace_, name_, pretty_print=pretty_print) + outfile.write('</%s%s>%s' % (namespace_, name_, eol_)) + else: + outfile.write('/>%s' % (eol_, )) + def exportAttributes(self, outfile, level, already_processed, namespace_='', name_='global-system-config-physical-router'): + pass + def exportChildren(self, outfile, level, namespace_='', name_='global-system-config-physical-router', fromsubclass_=False, pretty_print=True): + pass + def hasContent_(self): + if ( + + ): + return True + else: + return False + def exportLiteral(self, outfile, level, name_='global-system-config-physical-router'): + level += 1 + self.exportLiteralAttributes(outfile, level, [], name_) + if self.hasContent_(): + self.exportLiteralChildren(outfile, level, name_) + def exportLiteralAttributes(self, outfile, level, already_processed, name_): + pass + def exportLiteralChildren(self, outfile, level, name_): + pass + def exportDict(self, name_='global-system-config-physical-router'): + obj_json = json.dumps(self, default=lambda o: dict((k, v) for k, v in o.__dict__.iteritems())) + obj_dict = json.loads(obj_json) + return {name_: obj_dict} + def build(self, node): + self.buildAttributes(node, node.attrib, []) + for child in node: + nodeName_ = Tag_pattern_.match(child.tag).groups()[-1] + self.buildChildren(child, node, nodeName_) + def buildAttributes(self, node, attrs, already_processed): + pass + def buildChildren(self, child_, node, nodeName_, fromsubclass_=False): + pass +# end class global_system_config_physical_router + + +class physical_router_virtual_router(GeneratedsSuper): + """ + physical_router_virtual_router class definition from :doc:`vnc_cfg.xsd` + """ + subclass = None + superclass = None + def __init__(self, **kwargs): + pass + def factory(*args_, **kwargs_): + if physical_router_virtual_router.subclass: + return physical_router_virtual_router.subclass(*args_, **kwargs_) + else: + return physical_router_virtual_router(*args_, **kwargs_) + factory = staticmethod(factory) + def __eq__(self, other): return True + def __ne__(self, other): return False + @classmethod + def populate (cls, *a, **kwa): + obj = cls (*a, **kwa) + return obj + def export(self, outfile, level=1, namespace_='', name_='physical-router-virtual-router', namespacedef_='', pretty_print=True): + if pretty_print: + eol_ = '\n' + else: + eol_ = '' + showIndent(outfile, level, pretty_print) + outfile.write('<%s%s%s' % (namespace_, name_, namespacedef_ and ' ' + namespacedef_ or '', )) + already_processed = [] + self.exportAttributes(outfile, level, already_processed, namespace_, name_='physical-router-virtual-router') + if self.hasContent_(): + outfile.write('>%s' % (eol_, )) + self.exportChildren(outfile, level + 1, namespace_, name_, pretty_print=pretty_print) + outfile.write('</%s%s>%s' % (namespace_, name_, eol_)) + else: + outfile.write('/>%s' % (eol_, )) + def exportAttributes(self, outfile, level, already_processed, namespace_='', name_='physical-router-virtual-router'): + pass + def exportChildren(self, outfile, level, namespace_='', name_='physical-router-virtual-router', fromsubclass_=False, pretty_print=True): + pass + def hasContent_(self): + if ( + + ): + return True + else: + return False + def exportLiteral(self, outfile, level, name_='physical-router-virtual-router'): + level += 1 + self.exportLiteralAttributes(outfile, level, [], name_) + if self.hasContent_(): + self.exportLiteralChildren(outfile, level, name_) + def exportLiteralAttributes(self, outfile, level, already_processed, name_): + pass + def exportLiteralChildren(self, outfile, level, name_): + pass + def exportDict(self, name_='physical-router-virtual-router'): + obj_json = json.dumps(self, default=lambda o: dict((k, v) for k, v in o.__dict__.iteritems())) + obj_dict = json.loads(obj_json) + return {name_: obj_dict} + def build(self, node): + self.buildAttributes(node, node.attrib, []) + for child in node: + nodeName_ = Tag_pattern_.match(child.tag).groups()[-1] + self.buildChildren(child, node, nodeName_) + def buildAttributes(self, node, attrs, already_processed): + pass + def buildChildren(self, child_, node, nodeName_, fromsubclass_=False): + pass +# end class physical_router_virtual_router + + +class physical_router_bgp_router(GeneratedsSuper): + """ + physical_router_bgp_router class definition from :doc:`vnc_cfg.xsd` + """ + subclass = None + superclass = None + def __init__(self, **kwargs): + pass + def factory(*args_, **kwargs_): + if physical_router_bgp_router.subclass: + return physical_router_bgp_router.subclass(*args_, **kwargs_) + else: + return physical_router_bgp_router(*args_, **kwargs_) + factory = staticmethod(factory) + def __eq__(self, other): return True + def __ne__(self, other): return False + @classmethod + def populate (cls, *a, **kwa): + obj = cls (*a, **kwa) + return obj + def export(self, outfile, level=1, namespace_='', name_='physical-router-bgp-router', namespacedef_='', pretty_print=True): + if pretty_print: + eol_ = '\n' + else: + eol_ = '' + showIndent(outfile, level, pretty_print) + outfile.write('<%s%s%s' % (namespace_, name_, namespacedef_ and ' ' + namespacedef_ or '', )) + already_processed = [] + self.exportAttributes(outfile, level, already_processed, namespace_, name_='physical-router-bgp-router') + if self.hasContent_(): + outfile.write('>%s' % (eol_, )) + self.exportChildren(outfile, level + 1, namespace_, name_, pretty_print=pretty_print) + outfile.write('</%s%s>%s' % (namespace_, name_, eol_)) + else: + outfile.write('/>%s' % (eol_, )) + def exportAttributes(self, outfile, level, already_processed, namespace_='', name_='physical-router-bgp-router'): + pass + def exportChildren(self, outfile, level, namespace_='', name_='physical-router-bgp-router', fromsubclass_=False, pretty_print=True): + pass + def hasContent_(self): + if ( + + ): + return True + else: + return False + def exportLiteral(self, outfile, level, name_='physical-router-bgp-router'): + level += 1 + self.exportLiteralAttributes(outfile, level, [], name_) + if self.hasContent_(): + self.exportLiteralChildren(outfile, level, name_) + def exportLiteralAttributes(self, outfile, level, already_processed, name_): + pass + def exportLiteralChildren(self, outfile, level, name_): + pass + def exportDict(self, name_='physical-router-bgp-router'): + obj_json = json.dumps(self, default=lambda o: dict((k, v) for k, v in o.__dict__.iteritems())) + obj_dict = json.loads(obj_json) + return {name_: obj_dict} + def build(self, node): + self.buildAttributes(node, node.attrib, []) + for child in node: + nodeName_ = Tag_pattern_.match(child.tag).groups()[-1] + self.buildChildren(child, node, nodeName_) + def buildAttributes(self, node, attrs, already_processed): + pass + def buildChildren(self, child_, node, nodeName_, fromsubclass_=False): + pass +# end class physical_router_bgp_router + + +class physical_router_virtual_network(GeneratedsSuper): + """ + physical_router_virtual_network class definition from :doc:`vnc_cfg.xsd` + """ + subclass = None + superclass = None + def __init__(self, **kwargs): + pass + def factory(*args_, **kwargs_): + if physical_router_virtual_network.subclass: + return physical_router_virtual_network.subclass(*args_, **kwargs_) + else: + return physical_router_virtual_network(*args_, **kwargs_) + factory = staticmethod(factory) + def __eq__(self, other): return True + def __ne__(self, other): return False + @classmethod + def populate (cls, *a, **kwa): + obj = cls (*a, **kwa) + return obj + def export(self, outfile, level=1, namespace_='', name_='physical-router-virtual-network', namespacedef_='', pretty_print=True): + if pretty_print: + eol_ = '\n' + else: + eol_ = '' + showIndent(outfile, level, pretty_print) + outfile.write('<%s%s%s' % (namespace_, name_, namespacedef_ and ' ' + namespacedef_ or '', )) + already_processed = [] + self.exportAttributes(outfile, level, already_processed, namespace_, name_='physical-router-virtual-network') + if self.hasContent_(): + outfile.write('>%s' % (eol_, )) + self.exportChildren(outfile, level + 1, namespace_, name_, pretty_print=pretty_print) + outfile.write('</%s%s>%s' % (namespace_, name_, eol_)) + else: + outfile.write('/>%s' % (eol_, )) + def exportAttributes(self, outfile, level, already_processed, namespace_='', name_='physical-router-virtual-network'): + pass + def exportChildren(self, outfile, level, namespace_='', name_='physical-router-virtual-network', fromsubclass_=False, pretty_print=True): + pass + def hasContent_(self): + if ( + + ): + return True + else: + return False + def exportLiteral(self, outfile, level, name_='physical-router-virtual-network'): + level += 1 + self.exportLiteralAttributes(outfile, level, [], name_) + if self.hasContent_(): + self.exportLiteralChildren(outfile, level, name_) + def exportLiteralAttributes(self, outfile, level, already_processed, name_): + pass + def exportLiteralChildren(self, outfile, level, name_): + pass + def exportDict(self, name_='physical-router-virtual-network'): + obj_json = json.dumps(self, default=lambda o: dict((k, v) for k, v in o.__dict__.iteritems())) + obj_dict = json.loads(obj_json) + return {name_: obj_dict} + def build(self, node): + self.buildAttributes(node, node.attrib, []) + for child in node: + nodeName_ = Tag_pattern_.match(child.tag).groups()[-1] + self.buildChildren(child, node, nodeName_) + def buildAttributes(self, node, attrs, already_processed): + pass + def buildChildren(self, child_, node, nodeName_, fromsubclass_=False): + pass +# end class physical_router_virtual_network + + +class physical_router_physical_interface(GeneratedsSuper): + """ + physical_router_physical_interface class definition from :doc:`vnc_cfg.xsd` + """ + subclass = None + superclass = None + def __init__(self, **kwargs): + pass + def factory(*args_, **kwargs_): + if physical_router_physical_interface.subclass: + return physical_router_physical_interface.subclass(*args_, **kwargs_) + else: + return physical_router_physical_interface(*args_, **kwargs_) + factory = staticmethod(factory) + def __eq__(self, other): return True + def __ne__(self, other): return False + @classmethod + def populate (cls, *a, **kwa): + obj = cls (*a, **kwa) + return obj + def export(self, outfile, level=1, namespace_='', name_='physical-router-physical-interface', namespacedef_='', pretty_print=True): + if pretty_print: + eol_ = '\n' + else: + eol_ = '' + showIndent(outfile, level, pretty_print) + outfile.write('<%s%s%s' % (namespace_, name_, namespacedef_ and ' ' + namespacedef_ or '', )) + already_processed = [] + self.exportAttributes(outfile, level, already_processed, namespace_, name_='physical-router-physical-interface') + if self.hasContent_(): + outfile.write('>%s' % (eol_, )) + self.exportChildren(outfile, level + 1, namespace_, name_, pretty_print=pretty_print) + outfile.write('</%s%s>%s' % (namespace_, name_, eol_)) + else: + outfile.write('/>%s' % (eol_, )) + def exportAttributes(self, outfile, level, already_processed, namespace_='', name_='physical-router-physical-interface'): + pass + def exportChildren(self, outfile, level, namespace_='', name_='physical-router-physical-interface', fromsubclass_=False, pretty_print=True): + pass + def hasContent_(self): + if ( + + ): + return True + else: + return False + def exportLiteral(self, outfile, level, name_='physical-router-physical-interface'): + level += 1 + self.exportLiteralAttributes(outfile, level, [], name_) + if self.hasContent_(): + self.exportLiteralChildren(outfile, level, name_) + def exportLiteralAttributes(self, outfile, level, already_processed, name_): + pass + def exportLiteralChildren(self, outfile, level, name_): + pass + def exportDict(self, name_='physical-router-physical-interface'): + obj_json = json.dumps(self, default=lambda o: dict((k, v) for k, v in o.__dict__.iteritems())) + obj_dict = json.loads(obj_json) + return {name_: obj_dict} + def build(self, node): + self.buildAttributes(node, node.attrib, []) + for child in node: + nodeName_ = Tag_pattern_.match(child.tag).groups()[-1] + self.buildChildren(child, node, nodeName_) + def buildAttributes(self, node, attrs, already_processed): + pass + def buildChildren(self, child_, node, nodeName_, fromsubclass_=False): + pass +# end class physical_router_physical_interface + + +class physical_router_logical_interface(GeneratedsSuper): + """ + physical_router_logical_interface class definition from :doc:`vnc_cfg.xsd` + """ + subclass = None + superclass = None + def __init__(self, **kwargs): + pass + def factory(*args_, **kwargs_): + if physical_router_logical_interface.subclass: + return physical_router_logical_interface.subclass(*args_, **kwargs_) + else: + return physical_router_logical_interface(*args_, **kwargs_) + factory = staticmethod(factory) + def __eq__(self, other): return True + def __ne__(self, other): return False + @classmethod + def populate (cls, *a, **kwa): + obj = cls (*a, **kwa) + return obj + def export(self, outfile, level=1, namespace_='', name_='physical-router-logical-interface', namespacedef_='', pretty_print=True): + if pretty_print: + eol_ = '\n' + else: + eol_ = '' + showIndent(outfile, level, pretty_print) + outfile.write('<%s%s%s' % (namespace_, name_, namespacedef_ and ' ' + namespacedef_ or '', )) + already_processed = [] + self.exportAttributes(outfile, level, already_processed, namespace_, name_='physical-router-logical-interface') + if self.hasContent_(): + outfile.write('>%s' % (eol_, )) + self.exportChildren(outfile, level + 1, namespace_, name_, pretty_print=pretty_print) + outfile.write('</%s%s>%s' % (namespace_, name_, eol_)) + else: + outfile.write('/>%s' % (eol_, )) + def exportAttributes(self, outfile, level, already_processed, namespace_='', name_='physical-router-logical-interface'): + pass + def exportChildren(self, outfile, level, namespace_='', name_='physical-router-logical-interface', fromsubclass_=False, pretty_print=True): + pass + def hasContent_(self): + if ( + + ): + return True + else: + return False + def exportLiteral(self, outfile, level, name_='physical-router-logical-interface'): + level += 1 + self.exportLiteralAttributes(outfile, level, [], name_) + if self.hasContent_(): + self.exportLiteralChildren(outfile, level, name_) + def exportLiteralAttributes(self, outfile, level, already_processed, name_): + pass + def exportLiteralChildren(self, outfile, level, name_): + pass + def exportDict(self, name_='physical-router-logical-interface'): + obj_json = json.dumps(self, default=lambda o: dict((k, v) for k, v in o.__dict__.iteritems())) + obj_dict = json.loads(obj_json) + return {name_: obj_dict} + def build(self, node): + self.buildAttributes(node, node.attrib, []) + for child in node: + nodeName_ = Tag_pattern_.match(child.tag).groups()[-1] + self.buildChildren(child, node, nodeName_) + def buildAttributes(self, node, attrs, already_processed): + pass + def buildChildren(self, child_, node, nodeName_, fromsubclass_=False): + pass +# end class physical_router_logical_interface + + +class physical_interface_logical_interface(GeneratedsSuper): + """ + physical_interface_logical_interface class definition from :doc:`vnc_cfg.xsd` + """ + subclass = None + superclass = None + def __init__(self, **kwargs): + pass + def factory(*args_, **kwargs_): + if physical_interface_logical_interface.subclass: + return physical_interface_logical_interface.subclass(*args_, **kwargs_) + else: + return physical_interface_logical_interface(*args_, **kwargs_) + factory = staticmethod(factory) + def __eq__(self, other): return True + def __ne__(self, other): return False + @classmethod + def populate (cls, *a, **kwa): + obj = cls (*a, **kwa) + return obj + def export(self, outfile, level=1, namespace_='', name_='physical-interface-logical-interface', namespacedef_='', pretty_print=True): + if pretty_print: + eol_ = '\n' + else: + eol_ = '' + showIndent(outfile, level, pretty_print) + outfile.write('<%s%s%s' % (namespace_, name_, namespacedef_ and ' ' + namespacedef_ or '', )) + already_processed = [] + self.exportAttributes(outfile, level, already_processed, namespace_, name_='physical-interface-logical-interface') + if self.hasContent_(): + outfile.write('>%s' % (eol_, )) + self.exportChildren(outfile, level + 1, namespace_, name_, pretty_print=pretty_print) + outfile.write('</%s%s>%s' % (namespace_, name_, eol_)) + else: + outfile.write('/>%s' % (eol_, )) + def exportAttributes(self, outfile, level, already_processed, namespace_='', name_='physical-interface-logical-interface'): + pass + def exportChildren(self, outfile, level, namespace_='', name_='physical-interface-logical-interface', fromsubclass_=False, pretty_print=True): + pass + def hasContent_(self): + if ( + + ): + return True + else: + return False + def exportLiteral(self, outfile, level, name_='physical-interface-logical-interface'): + level += 1 + self.exportLiteralAttributes(outfile, level, [], name_) + if self.hasContent_(): + self.exportLiteralChildren(outfile, level, name_) + def exportLiteralAttributes(self, outfile, level, already_processed, name_): + pass + def exportLiteralChildren(self, outfile, level, name_): + pass + def exportDict(self, name_='physical-interface-logical-interface'): + obj_json = json.dumps(self, default=lambda o: dict((k, v) for k, v in o.__dict__.iteritems())) + obj_dict = json.loads(obj_json) + return {name_: obj_dict} + def build(self, node): + self.buildAttributes(node, node.attrib, []) + for child in node: + nodeName_ = Tag_pattern_.match(child.tag).groups()[-1] + self.buildChildren(child, node, nodeName_) + def buildAttributes(self, node, attrs, already_processed): + pass + def buildChildren(self, child_, node, nodeName_, fromsubclass_=False): + pass +# end class physical_interface_logical_interface + + +class UserCredentials(GeneratedsSuper): + """ + UserCredentials class definition from :doc:`vnc_cfg.xsd` + """ + subclass = None + superclass = None + def __init__(self, username=None, password=None, **kwargs): + self.username = username + self.password = password + def factory(*args_, **kwargs_): + if UserCredentials.subclass: + return UserCredentials.subclass(*args_, **kwargs_) + else: + return UserCredentials(*args_, **kwargs_) + factory = staticmethod(factory) + def get_username(self): return self.username + def set_username(self, username): self.username = username + def get_password(self): return self.password + def set_password(self, password): self.password = password + def __eq__(self, other): + if isinstance(other, self.__class__): + return (self.username == other.username and + self.password == other.password) + return NotImplemented + def __ne__(self, other): + if isinstance(other, self.__class__): + return not self.__eq__(other) + return NotImplemented + + @classmethod + def populate (cls, *a, **kwa): + obj = cls (*a, **kwa) + obj.set_username (obj.populate_string ("username")) + obj.set_password (obj.populate_string ("password")) + return obj + def export(self, outfile, level=1, namespace_='', name_='UserCredentials', namespacedef_='', pretty_print=True): + if pretty_print: + eol_ = '\n' + else: + eol_ = '' + showIndent(outfile, level, pretty_print) + outfile.write('<%s%s%s' % (namespace_, name_, namespacedef_ and ' ' + namespacedef_ or '', )) + already_processed = [] + self.exportAttributes(outfile, level, already_processed, namespace_, name_='UserCredentials') + if self.hasContent_(): + outfile.write('>%s' % (eol_, )) + self.exportChildren(outfile, level + 1, namespace_, name_, pretty_print=pretty_print) + showIndent(outfile, level, pretty_print) + outfile.write('</%s%s>%s' % (namespace_, name_, eol_)) + else: + outfile.write('/>%s' % (eol_, )) + def exportAttributes(self, outfile, level, already_processed, namespace_='', name_='UserCredentials'): + pass + def exportChildren(self, outfile, level, namespace_='', name_='UserCredentials', fromsubclass_=False, pretty_print=True): + if pretty_print: + eol_ = '\n' + else: + eol_ = '' + if self.username is not None: + showIndent(outfile, level, pretty_print) + outfile.write('<%susername>%s</%susername>%s' % (namespace_, self.gds_format_string(quote_xml(self.username).encode(ExternalEncoding), input_name='username'), namespace_, eol_)) + if self.password is not None: + showIndent(outfile, level, pretty_print) + outfile.write('<%spassword>%s</%spassword>%s' % (namespace_, self.gds_format_string(quote_xml(self.password).encode(ExternalEncoding), input_name='password'), namespace_, eol_)) + def hasContent_(self): + if ( + self.username is not None or + self.password is not None + ): + return True + else: + return False + def exportLiteral(self, outfile, level, name_='UserCredentials'): + level += 1 + self.exportLiteralAttributes(outfile, level, [], name_) + if self.hasContent_(): + self.exportLiteralChildren(outfile, level, name_) + def exportLiteralAttributes(self, outfile, level, already_processed, name_): + pass + def exportLiteralChildren(self, outfile, level, name_): + if self.username is not None: + showIndent(outfile, level) + outfile.write('username=%s,\n' % quote_python(self.username).encode(ExternalEncoding)) + if self.password is not None: + showIndent(outfile, level) + outfile.write('password=%s,\n' % quote_python(self.password).encode(ExternalEncoding)) + def exportDict(self, name_='UserCredentials'): + obj_json = json.dumps(self, default=lambda o: dict((k, v) for k, v in o.__dict__.iteritems())) + obj_dict = json.loads(obj_json) + return {name_: obj_dict} + def build(self, node): + self.buildAttributes(node, node.attrib, []) + for child in node: + nodeName_ = Tag_pattern_.match(child.tag).groups()[-1] + self.buildChildren(child, node, nodeName_) + def buildAttributes(self, node, attrs, already_processed): + pass + def buildChildren(self, child_, node, nodeName_, fromsubclass_=False): + if nodeName_ == 'username': + username_ = child_.text + username_ = self.gds_validate_string(username_, node, 'username') + self.username = username_ + elif nodeName_ == 'password': + password_ = child_.text + password_ = self.gds_validate_string(password_, node, 'password') + self.password = password_ +# end class UserCredentials + + +class SNMPCredentials(GeneratedsSuper): + """ + SNMPCredentials class definition from :doc:`vnc_cfg.xsd` + """ + subclass = None + superclass = None + def __init__(self, version=2, local_port=None, retries=None, timeout=None, v2_community=None, v3_security_name=None, v3_security_level=None, v3_security_engine_id=None, v3_context=None, v3_context_engine_id=None, v3_authentication_protocol=None, v3_authentication_password=None, v3_privacy_protocol=None, v3_privacy_password=None, v3_engine_id=None, v3_engine_boots=None, v3_engine_time=None, **kwargs): + self.version = version + self.local_port = local_port + self.retries = retries + self.timeout = timeout + self.v2_community = v2_community + self.v3_security_name = v3_security_name + self.v3_security_level = v3_security_level + self.v3_security_engine_id = v3_security_engine_id + self.v3_context = v3_context + self.v3_context_engine_id = v3_context_engine_id + self.v3_authentication_protocol = v3_authentication_protocol + self.v3_authentication_password = v3_authentication_password + self.v3_privacy_protocol = v3_privacy_protocol + self.v3_privacy_password = v3_privacy_password + self.v3_engine_id = v3_engine_id + self.v3_engine_boots = v3_engine_boots + self.v3_engine_time = v3_engine_time + def factory(*args_, **kwargs_): + if SNMPCredentials.subclass: + return SNMPCredentials.subclass(*args_, **kwargs_) + else: + return SNMPCredentials(*args_, **kwargs_) + factory = staticmethod(factory) + def get_version(self): return self.version + def set_version(self, version): self.version = version + def get_local_port(self): return self.local_port + def set_local_port(self, local_port): self.local_port = local_port + def get_retries(self): return self.retries + def set_retries(self, retries): self.retries = retries + def get_timeout(self): return self.timeout + def set_timeout(self, timeout): self.timeout = timeout + def get_v2_community(self): return self.v2_community + def set_v2_community(self, v2_community): self.v2_community = v2_community + def get_v3_security_name(self): return self.v3_security_name + def set_v3_security_name(self, v3_security_name): self.v3_security_name = v3_security_name + def get_v3_security_level(self): return self.v3_security_level + def set_v3_security_level(self, v3_security_level): self.v3_security_level = v3_security_level + def get_v3_security_engine_id(self): return self.v3_security_engine_id + def set_v3_security_engine_id(self, v3_security_engine_id): self.v3_security_engine_id = v3_security_engine_id + def get_v3_context(self): return self.v3_context + def set_v3_context(self, v3_context): self.v3_context = v3_context + def get_v3_context_engine_id(self): return self.v3_context_engine_id + def set_v3_context_engine_id(self, v3_context_engine_id): self.v3_context_engine_id = v3_context_engine_id + def get_v3_authentication_protocol(self): return self.v3_authentication_protocol + def set_v3_authentication_protocol(self, v3_authentication_protocol): self.v3_authentication_protocol = v3_authentication_protocol + def get_v3_authentication_password(self): return self.v3_authentication_password + def set_v3_authentication_password(self, v3_authentication_password): self.v3_authentication_password = v3_authentication_password + def get_v3_privacy_protocol(self): return self.v3_privacy_protocol + def set_v3_privacy_protocol(self, v3_privacy_protocol): self.v3_privacy_protocol = v3_privacy_protocol + def get_v3_privacy_password(self): return self.v3_privacy_password + def set_v3_privacy_password(self, v3_privacy_password): self.v3_privacy_password = v3_privacy_password + def get_v3_engine_id(self): return self.v3_engine_id + def set_v3_engine_id(self, v3_engine_id): self.v3_engine_id = v3_engine_id + def get_v3_engine_boots(self): return self.v3_engine_boots + def set_v3_engine_boots(self, v3_engine_boots): self.v3_engine_boots = v3_engine_boots + def get_v3_engine_time(self): return self.v3_engine_time + def set_v3_engine_time(self, v3_engine_time): self.v3_engine_time = v3_engine_time + def __eq__(self, other): + if isinstance(other, self.__class__): + return (self.version == other.version and + self.local_port == other.local_port and + self.retries == other.retries and + self.timeout == other.timeout and + self.v2_community == other.v2_community and + self.v3_security_name == other.v3_security_name and + self.v3_security_level == other.v3_security_level and + self.v3_security_engine_id == other.v3_security_engine_id and + self.v3_context == other.v3_context and + self.v3_context_engine_id == other.v3_context_engine_id and + self.v3_authentication_protocol == other.v3_authentication_protocol and + self.v3_authentication_password == other.v3_authentication_password and + self.v3_privacy_protocol == other.v3_privacy_protocol and + self.v3_privacy_password == other.v3_privacy_password and + self.v3_engine_id == other.v3_engine_id and + self.v3_engine_boots == other.v3_engine_boots and + self.v3_engine_time == other.v3_engine_time) + return NotImplemented + def __ne__(self, other): + if isinstance(other, self.__class__): + return not self.__eq__(other) + return NotImplemented + + @classmethod + def populate (cls, *a, **kwa): + obj = cls (*a, **kwa) + obj.set_version (obj.populate_integer ("version")) + obj.set_local_port (obj.populate_integer ("local_port")) + obj.set_retries (obj.populate_integer ("retries")) + obj.set_timeout (obj.populate_integer ("timeout")) + obj.set_v2_community (obj.populate_string ("v2_community")) + obj.set_v3_security_name (obj.populate_string ("v3_security_name")) + obj.set_v3_security_level (obj.populate_string ("v3_security_level")) + obj.set_v3_security_engine_id (obj.populate_string ("v3_security_engine_id")) + obj.set_v3_context (obj.populate_string ("v3_context")) + obj.set_v3_context_engine_id (obj.populate_string ("v3_context_engine_id")) + obj.set_v3_authentication_protocol (obj.populate_string ("v3_authentication_protocol")) + obj.set_v3_authentication_password (obj.populate_string ("v3_authentication_password")) + obj.set_v3_privacy_protocol (obj.populate_string ("v3_privacy_protocol")) + obj.set_v3_privacy_password (obj.populate_string ("v3_privacy_password")) + obj.set_v3_engine_id (obj.populate_string ("v3_engine_id")) + obj.set_v3_engine_boots (obj.populate_integer ("v3_engine_boots")) + obj.set_v3_engine_time (obj.populate_integer ("v3_engine_time")) + return obj + def export(self, outfile, level=1, namespace_='', name_='SNMPCredentials', namespacedef_='', pretty_print=True): + if pretty_print: + eol_ = '\n' + else: + eol_ = '' + showIndent(outfile, level, pretty_print) + outfile.write('<%s%s%s' % (namespace_, name_, namespacedef_ and ' ' + namespacedef_ or '', )) + already_processed = [] + self.exportAttributes(outfile, level, already_processed, namespace_, name_='SNMPCredentials') + if self.hasContent_(): + outfile.write('>%s' % (eol_, )) + self.exportChildren(outfile, level + 1, namespace_, name_, pretty_print=pretty_print) + showIndent(outfile, level, pretty_print) + outfile.write('</%s%s>%s' % (namespace_, name_, eol_)) + else: + outfile.write('/>%s' % (eol_, )) + def exportAttributes(self, outfile, level, already_processed, namespace_='', name_='SNMPCredentials'): + pass + def exportChildren(self, outfile, level, namespace_='', name_='SNMPCredentials', fromsubclass_=False, pretty_print=True): + if pretty_print: + eol_ = '\n' + else: + eol_ = '' + if self.version is not None: + showIndent(outfile, level, pretty_print) + outfile.write('<%sversion>%s</%sversion>%s' % (namespace_, self.gds_format_integer(self.version, input_name='version'), namespace_, eol_)) + if self.local_port is not None: + showIndent(outfile, level, pretty_print) + outfile.write('<%slocal-port>%s</%slocal-port>%s' % (namespace_, self.gds_format_integer(self.local_port, input_name='local-port'), namespace_, eol_)) + if self.retries is not None: + showIndent(outfile, level, pretty_print) + outfile.write('<%sretries>%s</%sretries>%s' % (namespace_, self.gds_format_integer(self.retries, input_name='retries'), namespace_, eol_)) + if self.timeout is not None: + showIndent(outfile, level, pretty_print) + outfile.write('<%stimeout>%s</%stimeout>%s' % (namespace_, self.gds_format_integer(self.timeout, input_name='timeout'), namespace_, eol_)) + if self.v2_community is not None: + showIndent(outfile, level, pretty_print) + outfile.write('<%sv2-community>%s</%sv2-community>%s' % (namespace_, self.gds_format_string(quote_xml(self.v2_community).encode(ExternalEncoding), input_name='v2-community'), namespace_, eol_)) + if self.v3_security_name is not None: + showIndent(outfile, level, pretty_print) + outfile.write('<%sv3-security-name>%s</%sv3-security-name>%s' % (namespace_, self.gds_format_string(quote_xml(self.v3_security_name).encode(ExternalEncoding), input_name='v3-security-name'), namespace_, eol_)) + if self.v3_security_level is not None: + showIndent(outfile, level, pretty_print) + outfile.write('<%sv3-security-level>%s</%sv3-security-level>%s' % (namespace_, self.gds_format_string(quote_xml(self.v3_security_level).encode(ExternalEncoding), input_name='v3-security-level'), namespace_, eol_)) + if self.v3_security_engine_id is not None: + showIndent(outfile, level, pretty_print) + outfile.write('<%sv3-security-engine-id>%s</%sv3-security-engine-id>%s' % (namespace_, self.gds_format_string(quote_xml(self.v3_security_engine_id).encode(ExternalEncoding), input_name='v3-security-engine-id'), namespace_, eol_)) + if self.v3_context is not None: + showIndent(outfile, level, pretty_print) + outfile.write('<%sv3-context>%s</%sv3-context>%s' % (namespace_, self.gds_format_string(quote_xml(self.v3_context).encode(ExternalEncoding), input_name='v3-context'), namespace_, eol_)) + if self.v3_context_engine_id is not None: + showIndent(outfile, level, pretty_print) + outfile.write('<%sv3-context-engine-id>%s</%sv3-context-engine-id>%s' % (namespace_, self.gds_format_string(quote_xml(self.v3_context_engine_id).encode(ExternalEncoding), input_name='v3-context-engine-id'), namespace_, eol_)) + if self.v3_authentication_protocol is not None: + showIndent(outfile, level, pretty_print) + outfile.write('<%sv3-authentication-protocol>%s</%sv3-authentication-protocol>%s' % (namespace_, self.gds_format_string(quote_xml(self.v3_authentication_protocol).encode(ExternalEncoding), input_name='v3-authentication-protocol'), namespace_, eol_)) + if self.v3_authentication_password is not None: + showIndent(outfile, level, pretty_print) + outfile.write('<%sv3-authentication-password>%s</%sv3-authentication-password>%s' % (namespace_, self.gds_format_string(quote_xml(self.v3_authentication_password).encode(ExternalEncoding), input_name='v3-authentication-password'), namespace_, eol_)) + if self.v3_privacy_protocol is not None: + showIndent(outfile, level, pretty_print) + outfile.write('<%sv3-privacy-protocol>%s</%sv3-privacy-protocol>%s' % (namespace_, self.gds_format_string(quote_xml(self.v3_privacy_protocol).encode(ExternalEncoding), input_name='v3-privacy-protocol'), namespace_, eol_)) + if self.v3_privacy_password is not None: + showIndent(outfile, level, pretty_print) + outfile.write('<%sv3-privacy-password>%s</%sv3-privacy-password>%s' % (namespace_, self.gds_format_string(quote_xml(self.v3_privacy_password).encode(ExternalEncoding), input_name='v3-privacy-password'), namespace_, eol_)) + if self.v3_engine_id is not None: + showIndent(outfile, level, pretty_print) + outfile.write('<%sv3-engine-id>%s</%sv3-engine-id>%s' % (namespace_, self.gds_format_string(quote_xml(self.v3_engine_id).encode(ExternalEncoding), input_name='v3-engine-id'), namespace_, eol_)) + if self.v3_engine_boots is not None: + showIndent(outfile, level, pretty_print) + outfile.write('<%sv3-engine-boots>%s</%sv3-engine-boots>%s' % (namespace_, self.gds_format_integer(self.v3_engine_boots, input_name='v3-engine-boots'), namespace_, eol_)) + if self.v3_engine_time is not None: + showIndent(outfile, level, pretty_print) + outfile.write('<%sv3-engine-time>%s</%sv3-engine-time>%s' % (namespace_, self.gds_format_integer(self.v3_engine_time, input_name='v3-engine-time'), namespace_, eol_)) + def hasContent_(self): + if ( + self.version is not None or + self.local_port is not None or + self.retries is not None or + self.timeout is not None or + self.v2_community is not None or + self.v3_security_name is not None or + self.v3_security_level is not None or + self.v3_security_engine_id is not None or + self.v3_context is not None or + self.v3_context_engine_id is not None or + self.v3_authentication_protocol is not None or + self.v3_authentication_password is not None or + self.v3_privacy_protocol is not None or + self.v3_privacy_password is not None or + self.v3_engine_id is not None or + self.v3_engine_boots is not None or + self.v3_engine_time is not None + ): + return True + else: + return False + def exportLiteral(self, outfile, level, name_='SNMPCredentials'): + level += 1 + self.exportLiteralAttributes(outfile, level, [], name_) + if self.hasContent_(): + self.exportLiteralChildren(outfile, level, name_) + def exportLiteralAttributes(self, outfile, level, already_processed, name_): + pass + def exportLiteralChildren(self, outfile, level, name_): + if self.version is not None: + showIndent(outfile, level) + outfile.write('version=%d,\n' % self.version) + if self.local_port is not None: + showIndent(outfile, level) + outfile.write('local_port=%d,\n' % self.local_port) + if self.retries is not None: + showIndent(outfile, level) + outfile.write('retries=%d,\n' % self.retries) + if self.timeout is not None: + showIndent(outfile, level) + outfile.write('timeout=%d,\n' % self.timeout) + if self.v2_community is not None: + showIndent(outfile, level) + outfile.write('v2_community=%s,\n' % quote_python(self.v2_community).encode(ExternalEncoding)) + if self.v3_security_name is not None: + showIndent(outfile, level) + outfile.write('v3_security_name=%s,\n' % quote_python(self.v3_security_name).encode(ExternalEncoding)) + if self.v3_security_level is not None: + showIndent(outfile, level) + outfile.write('v3_security_level=%s,\n' % quote_python(self.v3_security_level).encode(ExternalEncoding)) + if self.v3_security_engine_id is not None: + showIndent(outfile, level) + outfile.write('v3_security_engine_id=%s,\n' % quote_python(self.v3_security_engine_id).encode(ExternalEncoding)) + if self.v3_context is not None: + showIndent(outfile, level) + outfile.write('v3_context=%s,\n' % quote_python(self.v3_context).encode(ExternalEncoding)) + if self.v3_context_engine_id is not None: + showIndent(outfile, level) + outfile.write('v3_context_engine_id=%s,\n' % quote_python(self.v3_context_engine_id).encode(ExternalEncoding)) + if self.v3_authentication_protocol is not None: + showIndent(outfile, level) + outfile.write('v3_authentication_protocol=%s,\n' % quote_python(self.v3_authentication_protocol).encode(ExternalEncoding)) + if self.v3_authentication_password is not None: + showIndent(outfile, level) + outfile.write('v3_authentication_password=%s,\n' % quote_python(self.v3_authentication_password).encode(ExternalEncoding)) + if self.v3_privacy_protocol is not None: + showIndent(outfile, level) + outfile.write('v3_privacy_protocol=%s,\n' % quote_python(self.v3_privacy_protocol).encode(ExternalEncoding)) + if self.v3_privacy_password is not None: + showIndent(outfile, level) + outfile.write('v3_privacy_password=%s,\n' % quote_python(self.v3_privacy_password).encode(ExternalEncoding)) + if self.v3_engine_id is not None: + showIndent(outfile, level) + outfile.write('v3_engine_id=%s,\n' % quote_python(self.v3_engine_id).encode(ExternalEncoding)) + if self.v3_engine_boots is not None: + showIndent(outfile, level) + outfile.write('v3_engine_boots=%d,\n' % self.v3_engine_boots) + if self.v3_engine_time is not None: + showIndent(outfile, level) + outfile.write('v3_engine_time=%d,\n' % self.v3_engine_time) + def exportDict(self, name_='SNMPCredentials'): + obj_json = json.dumps(self, default=lambda o: dict((k, v) for k, v in o.__dict__.iteritems())) + obj_dict = json.loads(obj_json) + return {name_: obj_dict} + def build(self, node): + self.buildAttributes(node, node.attrib, []) + for child in node: + nodeName_ = Tag_pattern_.match(child.tag).groups()[-1] + self.buildChildren(child, node, nodeName_) + def buildAttributes(self, node, attrs, already_processed): + pass + def buildChildren(self, child_, node, nodeName_, fromsubclass_=False): + if nodeName_ == 'version': + sval_ = child_.text + try: + ival_ = int(sval_) + except (TypeError, ValueError), exp: + raise_parse_error(child_, 'requires integer: %s' % exp) + ival_ = self.gds_validate_integer(ival_, node, 'version') + self.version = ival_ + elif nodeName_ == 'local-port': + sval_ = child_.text + try: + ival_ = int(sval_) + except (TypeError, ValueError), exp: + raise_parse_error(child_, 'requires integer: %s' % exp) + ival_ = self.gds_validate_integer(ival_, node, 'local_port') + self.local_port = ival_ + elif nodeName_ == 'retries': + sval_ = child_.text + try: + ival_ = int(sval_) + except (TypeError, ValueError), exp: + raise_parse_error(child_, 'requires integer: %s' % exp) + ival_ = self.gds_validate_integer(ival_, node, 'retries') + self.retries = ival_ + elif nodeName_ == 'timeout': + sval_ = child_.text + try: + ival_ = int(sval_) + except (TypeError, ValueError), exp: + raise_parse_error(child_, 'requires integer: %s' % exp) + ival_ = self.gds_validate_integer(ival_, node, 'timeout') + self.timeout = ival_ + elif nodeName_ == 'v2-community': + v2_community_ = child_.text + v2_community_ = self.gds_validate_string(v2_community_, node, 'v2_community') + self.v2_community = v2_community_ + elif nodeName_ == 'v3-security-name': + v3_security_name_ = child_.text + v3_security_name_ = self.gds_validate_string(v3_security_name_, node, 'v3_security_name') + self.v3_security_name = v3_security_name_ + elif nodeName_ == 'v3-security-level': + v3_security_level_ = child_.text + v3_security_level_ = self.gds_validate_string(v3_security_level_, node, 'v3_security_level') + self.v3_security_level = v3_security_level_ + elif nodeName_ == 'v3-security-engine-id': + v3_security_engine_id_ = child_.text + v3_security_engine_id_ = self.gds_validate_string(v3_security_engine_id_, node, 'v3_security_engine_id') + self.v3_security_engine_id = v3_security_engine_id_ + elif nodeName_ == 'v3-context': + v3_context_ = child_.text + v3_context_ = self.gds_validate_string(v3_context_, node, 'v3_context') + self.v3_context = v3_context_ + elif nodeName_ == 'v3-context-engine-id': + v3_context_engine_id_ = child_.text + v3_context_engine_id_ = self.gds_validate_string(v3_context_engine_id_, node, 'v3_context_engine_id') + self.v3_context_engine_id = v3_context_engine_id_ + elif nodeName_ == 'v3-authentication-protocol': + v3_authentication_protocol_ = child_.text + v3_authentication_protocol_ = self.gds_validate_string(v3_authentication_protocol_, node, 'v3_authentication_protocol') + self.v3_authentication_protocol = v3_authentication_protocol_ + elif nodeName_ == 'v3-authentication-password': + v3_authentication_password_ = child_.text + v3_authentication_password_ = self.gds_validate_string(v3_authentication_password_, node, 'v3_authentication_password') + self.v3_authentication_password = v3_authentication_password_ + elif nodeName_ == 'v3-privacy-protocol': + v3_privacy_protocol_ = child_.text + v3_privacy_protocol_ = self.gds_validate_string(v3_privacy_protocol_, node, 'v3_privacy_protocol') + self.v3_privacy_protocol = v3_privacy_protocol_ + elif nodeName_ == 'v3-privacy-password': + v3_privacy_password_ = child_.text + v3_privacy_password_ = self.gds_validate_string(v3_privacy_password_, node, 'v3_privacy_password') + self.v3_privacy_password = v3_privacy_password_ + elif nodeName_ == 'v3-engine-id': + v3_engine_id_ = child_.text + v3_engine_id_ = self.gds_validate_string(v3_engine_id_, node, 'v3_engine_id') + self.v3_engine_id = v3_engine_id_ + elif nodeName_ == 'v3-engine-boots': + sval_ = child_.text + try: + ival_ = int(sval_) + except (TypeError, ValueError), exp: + raise_parse_error(child_, 'requires integer: %s' % exp) + ival_ = self.gds_validate_integer(ival_, node, 'v3_engine_boots') + self.v3_engine_boots = ival_ + elif nodeName_ == 'v3-engine-time': + sval_ = child_.text + try: + ival_ = int(sval_) + except (TypeError, ValueError), exp: + raise_parse_error(child_, 'requires integer: %s' % exp) + ival_ = self.gds_validate_integer(ival_, node, 'v3_engine_time') + self.v3_engine_time = ival_ +# end class SNMPCredentials + + +class JunosServicePorts(GeneratedsSuper): + """ + JunosServicePorts class definition from :doc:`vnc_cfg.xsd` + """ + subclass = None + superclass = None + def __init__(self, service_port=None, **kwargs): + if (service_port is None) or (service_port == []): + self.service_port = [] + else: + self.service_port = service_port + def factory(*args_, **kwargs_): + if JunosServicePorts.subclass: + return JunosServicePorts.subclass(*args_, **kwargs_) + else: + return JunosServicePorts(*args_, **kwargs_) + factory = staticmethod(factory) + def get_service_port(self): return self.service_port + def set_service_port(self, service_port): self.service_port = service_port + def add_service_port(self, value): self.service_port.append(value) + def insert_service_port(self, index, value): self.service_port[index] = value + def delete_service_port(self, value): self.service_port.remove(value) + def __eq__(self, other): + if isinstance(other, self.__class__): + return (self.service_port == other.service_port) + return NotImplemented + def __ne__(self, other): + if isinstance(other, self.__class__): + return not self.__eq__(other) + return NotImplemented + + @classmethod + def populate (cls, *a, **kwa): + obj = cls (*a, **kwa) + obj.set_service_port ([obj.populate_string ("service_port")]) + return obj + def export(self, outfile, level=1, namespace_='', name_='JunosServicePorts', namespacedef_='', pretty_print=True): + if pretty_print: + eol_ = '\n' + else: + eol_ = '' + showIndent(outfile, level, pretty_print) + outfile.write('<%s%s%s' % (namespace_, name_, namespacedef_ and ' ' + namespacedef_ or '', )) + already_processed = [] + self.exportAttributes(outfile, level, already_processed, namespace_, name_='JunosServicePorts') + if self.hasContent_(): + outfile.write('>%s' % (eol_, )) + self.exportChildren(outfile, level + 1, namespace_, name_, pretty_print=pretty_print) + showIndent(outfile, level, pretty_print) + outfile.write('</%s%s>%s' % (namespace_, name_, eol_)) + else: + outfile.write('/>%s' % (eol_, )) + def exportAttributes(self, outfile, level, already_processed, namespace_='', name_='JunosServicePorts'): + pass + def exportChildren(self, outfile, level, namespace_='', name_='JunosServicePorts', fromsubclass_=False, pretty_print=True): + if pretty_print: + eol_ = '\n' + else: + eol_ = '' + for service_port_ in self.service_port: + showIndent(outfile, level, pretty_print) + outfile.write('<%sservice-port>%s</%sservice-port>%s' % (namespace_, self.gds_format_string(quote_xml(service_port_).encode(ExternalEncoding), input_name='service-port'), namespace_, eol_)) + def hasContent_(self): + if ( + self.service_port + ): + return True + else: + return False + def exportLiteral(self, outfile, level, name_='JunosServicePorts'): + level += 1 + self.exportLiteralAttributes(outfile, level, [], name_) + if self.hasContent_(): + self.exportLiteralChildren(outfile, level, name_) + def exportLiteralAttributes(self, outfile, level, already_processed, name_): + pass + def exportLiteralChildren(self, outfile, level, name_): + showIndent(outfile, level) + outfile.write('service_port=[\n') + level += 1 + for service_port_ in self.service_port: + showIndent(outfile, level) + outfile.write('%s,\n' % quote_python(service_port_).encode(ExternalEncoding)) + level -= 1 + showIndent(outfile, level) + outfile.write('],\n') + def exportDict(self, name_='JunosServicePorts'): + obj_json = json.dumps(self, default=lambda o: dict((k, v) for k, v in o.__dict__.iteritems())) + obj_dict = json.loads(obj_json) + return {name_: obj_dict} + def build(self, node): + self.buildAttributes(node, node.attrib, []) + for child in node: + nodeName_ = Tag_pattern_.match(child.tag).groups()[-1] + self.buildChildren(child, node, nodeName_) + def buildAttributes(self, node, attrs, already_processed): + pass + def buildChildren(self, child_, node, nodeName_, fromsubclass_=False): + if nodeName_ == 'service-port': + service_port_ = child_.text + service_port_ = self.gds_validate_string(service_port_, node, 'service_port') + self.service_port.append(service_port_) +# end class JunosServicePorts + + +class logical_interface_virtual_machine_interface(GeneratedsSuper): + """ + logical_interface_virtual_machine_interface class definition from :doc:`vnc_cfg.xsd` + """ + subclass = None + superclass = None + def __init__(self, **kwargs): + pass + def factory(*args_, **kwargs_): + if logical_interface_virtual_machine_interface.subclass: + return logical_interface_virtual_machine_interface.subclass(*args_, **kwargs_) + else: + return logical_interface_virtual_machine_interface(*args_, **kwargs_) + factory = staticmethod(factory) + def __eq__(self, other): return True + def __ne__(self, other): return False + @classmethod + def populate (cls, *a, **kwa): + obj = cls (*a, **kwa) + return obj + def export(self, outfile, level=1, namespace_='', name_='logical-interface-virtual-machine-interface', namespacedef_='', pretty_print=True): + if pretty_print: + eol_ = '\n' + else: + eol_ = '' + showIndent(outfile, level, pretty_print) + outfile.write('<%s%s%s' % (namespace_, name_, namespacedef_ and ' ' + namespacedef_ or '', )) + already_processed = [] + self.exportAttributes(outfile, level, already_processed, namespace_, name_='logical-interface-virtual-machine-interface') + if self.hasContent_(): + outfile.write('>%s' % (eol_, )) + self.exportChildren(outfile, level + 1, namespace_, name_, pretty_print=pretty_print) + outfile.write('</%s%s>%s' % (namespace_, name_, eol_)) + else: + outfile.write('/>%s' % (eol_, )) + def exportAttributes(self, outfile, level, already_processed, namespace_='', name_='logical-interface-virtual-machine-interface'): + pass + def exportChildren(self, outfile, level, namespace_='', name_='logical-interface-virtual-machine-interface', fromsubclass_=False, pretty_print=True): + pass + def hasContent_(self): + if ( + + ): + return True + else: + return False + def exportLiteral(self, outfile, level, name_='logical-interface-virtual-machine-interface'): + level += 1 + self.exportLiteralAttributes(outfile, level, [], name_) + if self.hasContent_(): + self.exportLiteralChildren(outfile, level, name_) + def exportLiteralAttributes(self, outfile, level, already_processed, name_): + pass + def exportLiteralChildren(self, outfile, level, name_): + pass + def exportDict(self, name_='logical-interface-virtual-machine-interface'): + obj_json = json.dumps(self, default=lambda o: dict((k, v) for k, v in o.__dict__.iteritems())) + obj_dict = json.loads(obj_json) + return {name_: obj_dict} + def build(self, node): + self.buildAttributes(node, node.attrib, []) + for child in node: + nodeName_ = Tag_pattern_.match(child.tag).groups()[-1] + self.buildChildren(child, node, nodeName_) + def buildAttributes(self, node, attrs, already_processed): + pass + def buildChildren(self, child_, node, nodeName_, fromsubclass_=False): + pass +# end class logical_interface_virtual_machine_interface + + +class global_system_config_virtual_router(GeneratedsSuper): + """ + global_system_config_virtual_router class definition from :doc:`vnc_cfg.xsd` + """ + subclass = None + superclass = None + def __init__(self, **kwargs): + pass + def factory(*args_, **kwargs_): + if global_system_config_virtual_router.subclass: + return global_system_config_virtual_router.subclass(*args_, **kwargs_) + else: + return global_system_config_virtual_router(*args_, **kwargs_) + factory = staticmethod(factory) + def __eq__(self, other): return True + def __ne__(self, other): return False + @classmethod + def populate (cls, *a, **kwa): + obj = cls (*a, **kwa) + return obj + def export(self, outfile, level=1, namespace_='', name_='global-system-config-virtual-router', namespacedef_='', pretty_print=True): + if pretty_print: + eol_ = '\n' + else: + eol_ = '' + showIndent(outfile, level, pretty_print) + outfile.write('<%s%s%s' % (namespace_, name_, namespacedef_ and ' ' + namespacedef_ or '', )) + already_processed = [] + self.exportAttributes(outfile, level, already_processed, namespace_, name_='global-system-config-virtual-router') + if self.hasContent_(): + outfile.write('>%s' % (eol_, )) + self.exportChildren(outfile, level + 1, namespace_, name_, pretty_print=pretty_print) + outfile.write('</%s%s>%s' % (namespace_, name_, eol_)) + else: + outfile.write('/>%s' % (eol_, )) + def exportAttributes(self, outfile, level, already_processed, namespace_='', name_='global-system-config-virtual-router'): + pass + def exportChildren(self, outfile, level, namespace_='', name_='global-system-config-virtual-router', fromsubclass_=False, pretty_print=True): + pass + def hasContent_(self): + if ( + + ): + return True + else: + return False + def exportLiteral(self, outfile, level, name_='global-system-config-virtual-router'): + level += 1 + self.exportLiteralAttributes(outfile, level, [], name_) + if self.hasContent_(): + self.exportLiteralChildren(outfile, level, name_) + def exportLiteralAttributes(self, outfile, level, already_processed, name_): + pass + def exportLiteralChildren(self, outfile, level, name_): + pass + def exportDict(self, name_='global-system-config-virtual-router'): + obj_json = json.dumps(self, default=lambda o: dict((k, v) for k, v in o.__dict__.iteritems())) + obj_dict = json.loads(obj_json) + return {name_: obj_dict} + def build(self, node): + self.buildAttributes(node, node.attrib, []) + for child in node: + nodeName_ = Tag_pattern_.match(child.tag).groups()[-1] + self.buildChildren(child, node, nodeName_) + def buildAttributes(self, node, attrs, already_processed): + pass + def buildChildren(self, child_, node, nodeName_, fromsubclass_=False): + pass +# end class global_system_config_virtual_router + + +class virtual_router_bgp_router(GeneratedsSuper): + """ + virtual_router_bgp_router class definition from :doc:`vnc_cfg.xsd` + """ + subclass = None + superclass = None + def __init__(self, **kwargs): + pass + def factory(*args_, **kwargs_): + if virtual_router_bgp_router.subclass: + return virtual_router_bgp_router.subclass(*args_, **kwargs_) + else: + return virtual_router_bgp_router(*args_, **kwargs_) + factory = staticmethod(factory) + def __eq__(self, other): return True + def __ne__(self, other): return False + @classmethod + def populate (cls, *a, **kwa): + obj = cls (*a, **kwa) + return obj + def export(self, outfile, level=1, namespace_='', name_='virtual-router-bgp-router', namespacedef_='', pretty_print=True): + if pretty_print: + eol_ = '\n' + else: + eol_ = '' + showIndent(outfile, level, pretty_print) + outfile.write('<%s%s%s' % (namespace_, name_, namespacedef_ and ' ' + namespacedef_ or '', )) + already_processed = [] + self.exportAttributes(outfile, level, already_processed, namespace_, name_='virtual-router-bgp-router') + if self.hasContent_(): + outfile.write('>%s' % (eol_, )) + self.exportChildren(outfile, level + 1, namespace_, name_, pretty_print=pretty_print) + outfile.write('</%s%s>%s' % (namespace_, name_, eol_)) + else: + outfile.write('/>%s' % (eol_, )) + def exportAttributes(self, outfile, level, already_processed, namespace_='', name_='virtual-router-bgp-router'): + pass + def exportChildren(self, outfile, level, namespace_='', name_='virtual-router-bgp-router', fromsubclass_=False, pretty_print=True): + pass + def hasContent_(self): + if ( + + ): + return True + else: + return False + def exportLiteral(self, outfile, level, name_='virtual-router-bgp-router'): + level += 1 + self.exportLiteralAttributes(outfile, level, [], name_) + if self.hasContent_(): + self.exportLiteralChildren(outfile, level, name_) + def exportLiteralAttributes(self, outfile, level, already_processed, name_): + pass + def exportLiteralChildren(self, outfile, level, name_): + pass + def exportDict(self, name_='virtual-router-bgp-router'): + obj_json = json.dumps(self, default=lambda o: dict((k, v) for k, v in o.__dict__.iteritems())) + obj_dict = json.loads(obj_json) + return {name_: obj_dict} + def build(self, node): + self.buildAttributes(node, node.attrib, []) + for child in node: + nodeName_ = Tag_pattern_.match(child.tag).groups()[-1] + self.buildChildren(child, node, nodeName_) + def buildAttributes(self, node, attrs, already_processed): + pass + def buildChildren(self, child_, node, nodeName_, fromsubclass_=False): + pass +# end class virtual_router_bgp_router + + +class virtual_router_virtual_machine(GeneratedsSuper): + """ + virtual_router_virtual_machine class definition from :doc:`vnc_cfg.xsd` + """ + subclass = None + superclass = None + def __init__(self, **kwargs): + pass + def factory(*args_, **kwargs_): + if virtual_router_virtual_machine.subclass: + return virtual_router_virtual_machine.subclass(*args_, **kwargs_) + else: + return virtual_router_virtual_machine(*args_, **kwargs_) + factory = staticmethod(factory) + def __eq__(self, other): return True + def __ne__(self, other): return False + @classmethod + def populate (cls, *a, **kwa): + obj = cls (*a, **kwa) + return obj + def export(self, outfile, level=1, namespace_='', name_='virtual-router-virtual-machine', namespacedef_='', pretty_print=True): + if pretty_print: + eol_ = '\n' + else: + eol_ = '' + showIndent(outfile, level, pretty_print) + outfile.write('<%s%s%s' % (namespace_, name_, namespacedef_ and ' ' + namespacedef_ or '', )) + already_processed = [] + self.exportAttributes(outfile, level, already_processed, namespace_, name_='virtual-router-virtual-machine') + if self.hasContent_(): + outfile.write('>%s' % (eol_, )) + self.exportChildren(outfile, level + 1, namespace_, name_, pretty_print=pretty_print) + outfile.write('</%s%s>%s' % (namespace_, name_, eol_)) + else: + outfile.write('/>%s' % (eol_, )) + def exportAttributes(self, outfile, level, already_processed, namespace_='', name_='virtual-router-virtual-machine'): + pass + def exportChildren(self, outfile, level, namespace_='', name_='virtual-router-virtual-machine', fromsubclass_=False, pretty_print=True): + pass + def hasContent_(self): + if ( + + ): + return True + else: + return False + def exportLiteral(self, outfile, level, name_='virtual-router-virtual-machine'): + level += 1 + self.exportLiteralAttributes(outfile, level, [], name_) + if self.hasContent_(): + self.exportLiteralChildren(outfile, level, name_) + def exportLiteralAttributes(self, outfile, level, already_processed, name_): + pass + def exportLiteralChildren(self, outfile, level, name_): + pass + def exportDict(self, name_='virtual-router-virtual-machine'): + obj_json = json.dumps(self, default=lambda o: dict((k, v) for k, v in o.__dict__.iteritems())) + obj_dict = json.loads(obj_json) + return {name_: obj_dict} + def build(self, node): + self.buildAttributes(node, node.attrib, []) + for child in node: + nodeName_ = Tag_pattern_.match(child.tag).groups()[-1] + self.buildChildren(child, node, nodeName_) + def buildAttributes(self, node, attrs, already_processed): + pass + def buildChildren(self, child_, node, nodeName_, fromsubclass_=False): + pass +# end class virtual_router_virtual_machine + + +class virtual_network_routing_instance(GeneratedsSuper): + """ + virtual_network_routing_instance class definition from :doc:`vnc_cfg.xsd` + """ + subclass = None + superclass = None + def __init__(self, **kwargs): + pass + def factory(*args_, **kwargs_): + if virtual_network_routing_instance.subclass: + return virtual_network_routing_instance.subclass(*args_, **kwargs_) + else: + return virtual_network_routing_instance(*args_, **kwargs_) + factory = staticmethod(factory) + def __eq__(self, other): return True + def __ne__(self, other): return False + @classmethod + def populate (cls, *a, **kwa): + obj = cls (*a, **kwa) + return obj + def export(self, outfile, level=1, namespace_='', name_='virtual-network-routing-instance', namespacedef_='', pretty_print=True): + if pretty_print: + eol_ = '\n' + else: + eol_ = '' + showIndent(outfile, level, pretty_print) + outfile.write('<%s%s%s' % (namespace_, name_, namespacedef_ and ' ' + namespacedef_ or '', )) + already_processed = [] + self.exportAttributes(outfile, level, already_processed, namespace_, name_='virtual-network-routing-instance') + if self.hasContent_(): + outfile.write('>%s' % (eol_, )) + self.exportChildren(outfile, level + 1, namespace_, name_, pretty_print=pretty_print) + outfile.write('</%s%s>%s' % (namespace_, name_, eol_)) + else: + outfile.write('/>%s' % (eol_, )) + def exportAttributes(self, outfile, level, already_processed, namespace_='', name_='virtual-network-routing-instance'): + pass + def exportChildren(self, outfile, level, namespace_='', name_='virtual-network-routing-instance', fromsubclass_=False, pretty_print=True): + pass + def hasContent_(self): + if ( + + ): + return True + else: + return False + def exportLiteral(self, outfile, level, name_='virtual-network-routing-instance'): + level += 1 + self.exportLiteralAttributes(outfile, level, [], name_) + if self.hasContent_(): + self.exportLiteralChildren(outfile, level, name_) + def exportLiteralAttributes(self, outfile, level, already_processed, name_): + pass + def exportLiteralChildren(self, outfile, level, name_): + pass + def exportDict(self, name_='virtual-network-routing-instance'): + obj_json = json.dumps(self, default=lambda o: dict((k, v) for k, v in o.__dict__.iteritems())) + obj_dict = json.loads(obj_json) + return {name_: obj_dict} + def build(self, node): + self.buildAttributes(node, node.attrib, []) + for child in node: + nodeName_ = Tag_pattern_.match(child.tag).groups()[-1] + self.buildChildren(child, node, nodeName_) + def buildAttributes(self, node, attrs, already_processed): + pass + def buildChildren(self, child_, node, nodeName_, fromsubclass_=False): + pass +# end class virtual_network_routing_instance + + +class customer_attachment_virtual_machine_interface(GeneratedsSuper): + """ + customer_attachment_virtual_machine_interface class definition from :doc:`vnc_cfg.xsd` + """ + subclass = None + superclass = None + def __init__(self, **kwargs): + pass + def factory(*args_, **kwargs_): + if customer_attachment_virtual_machine_interface.subclass: + return customer_attachment_virtual_machine_interface.subclass(*args_, **kwargs_) + else: + return customer_attachment_virtual_machine_interface(*args_, **kwargs_) + factory = staticmethod(factory) + def __eq__(self, other): return True + def __ne__(self, other): return False + @classmethod + def populate (cls, *a, **kwa): + obj = cls (*a, **kwa) + return obj + def export(self, outfile, level=1, namespace_='', name_='customer-attachment-virtual-machine-interface', namespacedef_='', pretty_print=True): + if pretty_print: + eol_ = '\n' + else: + eol_ = '' + showIndent(outfile, level, pretty_print) + outfile.write('<%s%s%s' % (namespace_, name_, namespacedef_ and ' ' + namespacedef_ or '', )) + already_processed = [] + self.exportAttributes(outfile, level, already_processed, namespace_, name_='customer-attachment-virtual-machine-interface') + if self.hasContent_(): + outfile.write('>%s' % (eol_, )) + self.exportChildren(outfile, level + 1, namespace_, name_, pretty_print=pretty_print) + outfile.write('</%s%s>%s' % (namespace_, name_, eol_)) + else: + outfile.write('/>%s' % (eol_, )) + def exportAttributes(self, outfile, level, already_processed, namespace_='', name_='customer-attachment-virtual-machine-interface'): + pass + def exportChildren(self, outfile, level, namespace_='', name_='customer-attachment-virtual-machine-interface', fromsubclass_=False, pretty_print=True): + pass + def hasContent_(self): + if ( + + ): + return True + else: + return False + def exportLiteral(self, outfile, level, name_='customer-attachment-virtual-machine-interface'): + level += 1 + self.exportLiteralAttributes(outfile, level, [], name_) + if self.hasContent_(): + self.exportLiteralChildren(outfile, level, name_) + def exportLiteralAttributes(self, outfile, level, already_processed, name_): + pass + def exportLiteralChildren(self, outfile, level, name_): + pass + def exportDict(self, name_='customer-attachment-virtual-machine-interface'): + obj_json = json.dumps(self, default=lambda o: dict((k, v) for k, v in o.__dict__.iteritems())) + obj_dict = json.loads(obj_json) + return {name_: obj_dict} + def build(self, node): + self.buildAttributes(node, node.attrib, []) + for child in node: + nodeName_ = Tag_pattern_.match(child.tag).groups()[-1] + self.buildChildren(child, node, nodeName_) + def buildAttributes(self, node, attrs, already_processed): + pass + def buildChildren(self, child_, node, nodeName_, fromsubclass_=False): + pass +# end class customer_attachment_virtual_machine_interface + + +class customer_attachment_floating_ip(GeneratedsSuper): + """ + customer_attachment_floating_ip class definition from :doc:`vnc_cfg.xsd` + """ + subclass = None + superclass = None + def __init__(self, **kwargs): + pass + def factory(*args_, **kwargs_): + if customer_attachment_floating_ip.subclass: + return customer_attachment_floating_ip.subclass(*args_, **kwargs_) + else: + return customer_attachment_floating_ip(*args_, **kwargs_) + factory = staticmethod(factory) + def __eq__(self, other): return True + def __ne__(self, other): return False + @classmethod + def populate (cls, *a, **kwa): + obj = cls (*a, **kwa) + return obj + def export(self, outfile, level=1, namespace_='', name_='customer-attachment-floating-ip', namespacedef_='', pretty_print=True): + if pretty_print: + eol_ = '\n' + else: + eol_ = '' + showIndent(outfile, level, pretty_print) + outfile.write('<%s%s%s' % (namespace_, name_, namespacedef_ and ' ' + namespacedef_ or '', )) + already_processed = [] + self.exportAttributes(outfile, level, already_processed, namespace_, name_='customer-attachment-floating-ip') + if self.hasContent_(): + outfile.write('>%s' % (eol_, )) + self.exportChildren(outfile, level + 1, namespace_, name_, pretty_print=pretty_print) + outfile.write('</%s%s>%s' % (namespace_, name_, eol_)) + else: + outfile.write('/>%s' % (eol_, )) + def exportAttributes(self, outfile, level, already_processed, namespace_='', name_='customer-attachment-floating-ip'): + pass + def exportChildren(self, outfile, level, namespace_='', name_='customer-attachment-floating-ip', fromsubclass_=False, pretty_print=True): + pass + def hasContent_(self): + if ( + + ): + return True + else: + return False + def exportLiteral(self, outfile, level, name_='customer-attachment-floating-ip'): + level += 1 + self.exportLiteralAttributes(outfile, level, [], name_) + if self.hasContent_(): + self.exportLiteralChildren(outfile, level, name_) + def exportLiteralAttributes(self, outfile, level, already_processed, name_): + pass + def exportLiteralChildren(self, outfile, level, name_): + pass + def exportDict(self, name_='customer-attachment-floating-ip'): + obj_json = json.dumps(self, default=lambda o: dict((k, v) for k, v in o.__dict__.iteritems())) + obj_dict = json.loads(obj_json) + return {name_: obj_dict} + def build(self, node): + self.buildAttributes(node, node.attrib, []) + for child in node: + nodeName_ = Tag_pattern_.match(child.tag).groups()[-1] + self.buildChildren(child, node, nodeName_) + def buildAttributes(self, node, attrs, already_processed): + pass + def buildChildren(self, child_, node, nodeName_, fromsubclass_=False): + pass +# end class customer_attachment_floating_ip + + +class provider_attachment_virtual_router(GeneratedsSuper): + """ + provider_attachment_virtual_router class definition from :doc:`vnc_cfg.xsd` + """ + subclass = None + superclass = None + def __init__(self, **kwargs): + pass + def factory(*args_, **kwargs_): + if provider_attachment_virtual_router.subclass: + return provider_attachment_virtual_router.subclass(*args_, **kwargs_) + else: + return provider_attachment_virtual_router(*args_, **kwargs_) + factory = staticmethod(factory) + def __eq__(self, other): return True + def __ne__(self, other): return False + @classmethod + def populate (cls, *a, **kwa): + obj = cls (*a, **kwa) + return obj + def export(self, outfile, level=1, namespace_='', name_='provider-attachment-virtual-router', namespacedef_='', pretty_print=True): + if pretty_print: + eol_ = '\n' + else: + eol_ = '' + showIndent(outfile, level, pretty_print) + outfile.write('<%s%s%s' % (namespace_, name_, namespacedef_ and ' ' + namespacedef_ or '', )) + already_processed = [] + self.exportAttributes(outfile, level, already_processed, namespace_, name_='provider-attachment-virtual-router') + if self.hasContent_(): + outfile.write('>%s' % (eol_, )) + self.exportChildren(outfile, level + 1, namespace_, name_, pretty_print=pretty_print) + outfile.write('</%s%s>%s' % (namespace_, name_, eol_)) + else: + outfile.write('/>%s' % (eol_, )) + def exportAttributes(self, outfile, level, already_processed, namespace_='', name_='provider-attachment-virtual-router'): + pass + def exportChildren(self, outfile, level, namespace_='', name_='provider-attachment-virtual-router', fromsubclass_=False, pretty_print=True): + pass + def hasContent_(self): + if ( + + ): + return True + else: + return False + def exportLiteral(self, outfile, level, name_='provider-attachment-virtual-router'): + level += 1 + self.exportLiteralAttributes(outfile, level, [], name_) + if self.hasContent_(): + self.exportLiteralChildren(outfile, level, name_) + def exportLiteralAttributes(self, outfile, level, already_processed, name_): + pass + def exportLiteralChildren(self, outfile, level, name_): + pass + def exportDict(self, name_='provider-attachment-virtual-router'): + obj_json = json.dumps(self, default=lambda o: dict((k, v) for k, v in o.__dict__.iteritems())) + obj_dict = json.loads(obj_json) + return {name_: obj_dict} + def build(self, node): + self.buildAttributes(node, node.attrib, []) + for child in node: + nodeName_ = Tag_pattern_.match(child.tag).groups()[-1] + self.buildChildren(child, node, nodeName_) + def buildAttributes(self, node, attrs, already_processed): + pass + def buildChildren(self, child_, node, nodeName_, fromsubclass_=False): + pass +# end class provider_attachment_virtual_router + + +class ServiceScaleOutType(GeneratedsSuper): + """ + ServiceScaleOutType class definition from :doc:`vnc_cfg.xsd` + """ + subclass = None + superclass = None + def __init__(self, max_instances=1, auto_scale=False, **kwargs): + self.max_instances = max_instances + self.auto_scale = auto_scale + def factory(*args_, **kwargs_): + if ServiceScaleOutType.subclass: + return ServiceScaleOutType.subclass(*args_, **kwargs_) + else: + return ServiceScaleOutType(*args_, **kwargs_) + factory = staticmethod(factory) + def get_max_instances(self): return self.max_instances + def set_max_instances(self, max_instances): self.max_instances = max_instances + def get_auto_scale(self): return self.auto_scale + def set_auto_scale(self, auto_scale): self.auto_scale = auto_scale + def __eq__(self, other): + if isinstance(other, self.__class__): + return (self.max_instances == other.max_instances and + self.auto_scale == other.auto_scale) + return NotImplemented + def __ne__(self, other): + if isinstance(other, self.__class__): + return not self.__eq__(other) + return NotImplemented + + @classmethod + def populate (cls, *a, **kwa): + obj = cls (*a, **kwa) + obj.set_max_instances (obj.populate_integer ("max_instances")) + obj.set_auto_scale (obj.populate_boolean ("auto_scale")) + return obj + def export(self, outfile, level=1, namespace_='', name_='ServiceScaleOutType', namespacedef_='', pretty_print=True): + if pretty_print: + eol_ = '\n' + else: + eol_ = '' + showIndent(outfile, level, pretty_print) + outfile.write('<%s%s%s' % (namespace_, name_, namespacedef_ and ' ' + namespacedef_ or '', )) + already_processed = [] + self.exportAttributes(outfile, level, already_processed, namespace_, name_='ServiceScaleOutType') + if self.hasContent_(): + outfile.write('>%s' % (eol_, )) + self.exportChildren(outfile, level + 1, namespace_, name_, pretty_print=pretty_print) + showIndent(outfile, level, pretty_print) + outfile.write('</%s%s>%s' % (namespace_, name_, eol_)) + else: + outfile.write('/>%s' % (eol_, )) + def exportAttributes(self, outfile, level, already_processed, namespace_='', name_='ServiceScaleOutType'): + pass + def exportChildren(self, outfile, level, namespace_='', name_='ServiceScaleOutType', fromsubclass_=False, pretty_print=True): + if pretty_print: + eol_ = '\n' + else: + eol_ = '' + if self.max_instances is not None: + showIndent(outfile, level, pretty_print) + outfile.write('<%smax-instances>%s</%smax-instances>%s' % (namespace_, self.gds_format_integer(self.max_instances, input_name='max-instances'), namespace_, eol_)) + if self.auto_scale is not None: + showIndent(outfile, level, pretty_print) + outfile.write('<%sauto-scale>%s</%sauto-scale>%s' % (namespace_, self.gds_format_boolean(self.gds_str_lower(str(self.auto_scale)), input_name='auto-scale'), namespace_, eol_)) + def hasContent_(self): + if ( + self.max_instances is not None or + self.auto_scale is not None + ): + return True + else: + return False + def exportLiteral(self, outfile, level, name_='ServiceScaleOutType'): + level += 1 + self.exportLiteralAttributes(outfile, level, [], name_) + if self.hasContent_(): + self.exportLiteralChildren(outfile, level, name_) + def exportLiteralAttributes(self, outfile, level, already_processed, name_): + pass + def exportLiteralChildren(self, outfile, level, name_): + if self.max_instances is not None: + showIndent(outfile, level) + outfile.write('max_instances=%d,\n' % self.max_instances) + if self.auto_scale is not None: + showIndent(outfile, level) + outfile.write('auto_scale=%s,\n' % self.auto_scale) + def exportDict(self, name_='ServiceScaleOutType'): + obj_json = json.dumps(self, default=lambda o: dict((k, v) for k, v in o.__dict__.iteritems())) + obj_dict = json.loads(obj_json) + return {name_: obj_dict} + def build(self, node): + self.buildAttributes(node, node.attrib, []) + for child in node: + nodeName_ = Tag_pattern_.match(child.tag).groups()[-1] + self.buildChildren(child, node, nodeName_) + def buildAttributes(self, node, attrs, already_processed): + pass + def buildChildren(self, child_, node, nodeName_, fromsubclass_=False): + if nodeName_ == 'max-instances': + sval_ = child_.text + try: + ival_ = int(sval_) + except (TypeError, ValueError), exp: + raise_parse_error(child_, 'requires integer: %s' % exp) + ival_ = self.gds_validate_integer(ival_, node, 'max_instances') + self.max_instances = ival_ + elif nodeName_ == 'auto-scale': + sval_ = child_.text + if sval_ in ('true', '1'): + ival_ = True + elif sval_ in ('false', '0'): + ival_ = False + else: + raise_parse_error(child_, 'requires boolean') + ival_ = self.gds_validate_boolean(ival_, node, 'auto_scale') + self.auto_scale = ival_ +# end class ServiceScaleOutType + + +class ServiceTemplateType(GeneratedsSuper): + """ + ServiceTemplateType class definition from :doc:`vnc_cfg.xsd` + """ + subclass = None + superclass = None + def __init__(self, service_mode=None, service_type=None, image_name=None, service_scaling=False, interface_type=None, flavor=None, ordered_interfaces=False, service_virtualization_type=None, availability_zone_enable=False, vrouter_instance_type=None, instance_data=None, **kwargs): + self.service_mode = service_mode + self.service_type = service_type + self.image_name = image_name + self.service_scaling = service_scaling + if (interface_type is None) or (interface_type == []): + self.interface_type = [] + else: + if isinstance(interface_type[0], dict): + objs = [ServiceTemplateInterfaceType(**elem) for elem in interface_type] + self.interface_type = objs + else: + self.interface_type = interface_type + self.flavor = flavor + self.ordered_interfaces = ordered_interfaces + self.service_virtualization_type = service_virtualization_type + self.availability_zone_enable = availability_zone_enable + self.vrouter_instance_type = vrouter_instance_type + self.instance_data = instance_data + def factory(*args_, **kwargs_): + if ServiceTemplateType.subclass: + return ServiceTemplateType.subclass(*args_, **kwargs_) + else: + return ServiceTemplateType(*args_, **kwargs_) + factory = staticmethod(factory) + def get_service_mode(self): return self.service_mode + def set_service_mode(self, service_mode): self.service_mode = service_mode + def validate_ServiceModeType(self, value): + # Validate type ServiceModeType, a restriction on xsd:string. + error = False + if isinstance(value, list): + error = set(value) - set([u'transparent', u'in-network', u'in-network-nat']) + else: + error = value not in [u'transparent', u'in-network', u'in-network-nat'] + if error: + raise ValueError("ServiceModeType must be one of [u'transparent', u'in-network', u'in-network-nat']") + def get_service_type(self): return self.service_type + def set_service_type(self, service_type): self.service_type = service_type + def validate_ServiceType(self, value): + # Validate type ServiceType, a restriction on xsd:string. + error = False + if isinstance(value, list): + error = set(value) - set([u'firewall', u'analyzer', u'source-nat', u'loadbalancer']) + else: + error = value not in [u'firewall', u'analyzer', u'source-nat', u'loadbalancer'] + if error: + raise ValueError("ServiceType must be one of [u'firewall', u'analyzer', u'source-nat', u'loadbalancer']") + def get_image_name(self): return self.image_name + def set_image_name(self, image_name): self.image_name = image_name + def get_service_scaling(self): return self.service_scaling + def set_service_scaling(self, service_scaling): self.service_scaling = service_scaling + def get_interface_type(self): return self.interface_type + def set_interface_type(self, interface_type): self.interface_type = interface_type + def add_interface_type(self, value): self.interface_type.append(value) + def insert_interface_type(self, index, value): self.interface_type[index] = value + def delete_interface_type(self, value): self.interface_type.remove(value) + def get_flavor(self): return self.flavor + def set_flavor(self, flavor): self.flavor = flavor + def get_ordered_interfaces(self): return self.ordered_interfaces + def set_ordered_interfaces(self, ordered_interfaces): self.ordered_interfaces = ordered_interfaces + def get_service_virtualization_type(self): return self.service_virtualization_type + def set_service_virtualization_type(self, service_virtualization_type): self.service_virtualization_type = service_virtualization_type + def validate_ServiceVirtualizationType(self, value): + # Validate type ServiceVirtualizationType, a restriction on xsd:string. + error = False + if isinstance(value, list): + error = set(value) - set([u'virtual-machine', u'network-namespace', u'vrouter-instance']) + else: + error = value not in [u'virtual-machine', u'network-namespace', u'vrouter-instance'] + if error: + raise ValueError("ServiceVirtualizationType must be one of [u'virtual-machine', u'network-namespace', u'vrouter-instance']") + def get_availability_zone_enable(self): return self.availability_zone_enable + def set_availability_zone_enable(self, availability_zone_enable): self.availability_zone_enable = availability_zone_enable + def get_vrouter_instance_type(self): return self.vrouter_instance_type + def set_vrouter_instance_type(self, vrouter_instance_type): self.vrouter_instance_type = vrouter_instance_type + def validate_VRouterInstanceType(self, value): + # Validate type VRouterInstanceType, a restriction on xsd:string. + error = False + if isinstance(value, list): + error = set(value) - set([u'libvirt-qemu', u'docker']) + else: + error = value not in [u'libvirt-qemu', u'docker'] + if error: + raise ValueError("VRouterInstanceType must be one of [u'libvirt-qemu', u'docker']") + def get_instance_data(self): return self.instance_data + def set_instance_data(self, instance_data): self.instance_data = instance_data + def __eq__(self, other): + if isinstance(other, self.__class__): + return (self.service_mode == other.service_mode and + self.service_type == other.service_type and + self.image_name == other.image_name and + self.service_scaling == other.service_scaling and + self.interface_type == other.interface_type and + self.flavor == other.flavor and + self.ordered_interfaces == other.ordered_interfaces and + self.service_virtualization_type == other.service_virtualization_type and + self.availability_zone_enable == other.availability_zone_enable and + self.vrouter_instance_type == other.vrouter_instance_type and + self.instance_data == other.instance_data) + return NotImplemented + def __ne__(self, other): + if isinstance(other, self.__class__): + return not self.__eq__(other) + return NotImplemented + + @classmethod + def populate (cls, *a, **kwa): + obj = cls (*a, **kwa) + obj.set_service_mode (obj.populate_string ("service_mode")) + obj.set_service_type (obj.populate_string ("service_type")) + obj.set_image_name (obj.populate_string ("image_name")) + obj.set_service_scaling (obj.populate_boolean ("service_scaling")) + obj.set_interface_type ([ServiceTemplateInterfaceType.populate ()]) + obj.set_flavor (obj.populate_string ("flavor")) + obj.set_ordered_interfaces (obj.populate_boolean ("ordered_interfaces")) + obj.set_service_virtualization_type (obj.populate_string ("service_virtualization_type")) + obj.set_availability_zone_enable (obj.populate_boolean ("availability_zone_enable")) + obj.set_vrouter_instance_type (obj.populate_string ("vrouter_instance_type")) + obj.set_instance_data (obj.populate_string ("instance_data")) + return obj + def export(self, outfile, level=1, namespace_='', name_='ServiceTemplateType', namespacedef_='', pretty_print=True): + if pretty_print: + eol_ = '\n' + else: + eol_ = '' + showIndent(outfile, level, pretty_print) + outfile.write('<%s%s%s' % (namespace_, name_, namespacedef_ and ' ' + namespacedef_ or '', )) + already_processed = [] + self.exportAttributes(outfile, level, already_processed, namespace_, name_='ServiceTemplateType') + if self.hasContent_(): + outfile.write('>%s' % (eol_, )) + self.exportChildren(outfile, level + 1, namespace_, name_, pretty_print=pretty_print) + showIndent(outfile, level, pretty_print) + outfile.write('</%s%s>%s' % (namespace_, name_, eol_)) + else: + outfile.write('/>%s' % (eol_, )) + def exportAttributes(self, outfile, level, already_processed, namespace_='', name_='ServiceTemplateType'): + pass + def exportChildren(self, outfile, level, namespace_='', name_='ServiceTemplateType', fromsubclass_=False, pretty_print=True): + if pretty_print: + eol_ = '\n' + else: + eol_ = '' + if self.service_mode is not None: + showIndent(outfile, level, pretty_print) + outfile.write('<%sservice-mode>%s</%sservice-mode>%s' % (namespace_, self.gds_format_string(quote_xml(self.service_mode).encode(ExternalEncoding), input_name='service-mode'), namespace_, eol_)) + if self.service_type is not None: + showIndent(outfile, level, pretty_print) + outfile.write('<%sservice-type>%s</%sservice-type>%s' % (namespace_, self.gds_format_string(quote_xml(self.service_type).encode(ExternalEncoding), input_name='service-type'), namespace_, eol_)) + if self.image_name is not None: + showIndent(outfile, level, pretty_print) + outfile.write('<%simage-name>%s</%simage-name>%s' % (namespace_, self.gds_format_string(quote_xml(self.image_name).encode(ExternalEncoding), input_name='image-name'), namespace_, eol_)) + if self.service_scaling is not None: + showIndent(outfile, level, pretty_print) + outfile.write('<%sservice-scaling>%s</%sservice-scaling>%s' % (namespace_, self.gds_format_boolean(self.gds_str_lower(str(self.service_scaling)), input_name='service-scaling'), namespace_, eol_)) + for interface_type_ in self.interface_type: + if isinstance(interface_type_, dict): + interface_type_ = ServiceTemplateInterfaceType(**interface_type_) + interface_type_.export(outfile, level, namespace_, name_='interface-type', pretty_print=pretty_print) + if self.flavor is not None: + showIndent(outfile, level, pretty_print) + outfile.write('<%sflavor>%s</%sflavor>%s' % (namespace_, self.gds_format_string(quote_xml(self.flavor).encode(ExternalEncoding), input_name='flavor'), namespace_, eol_)) + if self.ordered_interfaces is not None: + showIndent(outfile, level, pretty_print) + outfile.write('<%sordered-interfaces>%s</%sordered-interfaces>%s' % (namespace_, self.gds_format_boolean(self.gds_str_lower(str(self.ordered_interfaces)), input_name='ordered-interfaces'), namespace_, eol_)) + if self.service_virtualization_type is not None: + showIndent(outfile, level, pretty_print) + outfile.write('<%sservice-virtualization-type>%s</%sservice-virtualization-type>%s' % (namespace_, self.gds_format_string(quote_xml(self.service_virtualization_type).encode(ExternalEncoding), input_name='service-virtualization-type'), namespace_, eol_)) + if self.availability_zone_enable is not None: + showIndent(outfile, level, pretty_print) + outfile.write('<%savailability-zone-enable>%s</%savailability-zone-enable>%s' % (namespace_, self.gds_format_boolean(self.gds_str_lower(str(self.availability_zone_enable)), input_name='availability-zone-enable'), namespace_, eol_)) + if self.vrouter_instance_type is not None: + showIndent(outfile, level, pretty_print) + outfile.write('<%svrouter-instance-type>%s</%svrouter-instance-type>%s' % (namespace_, self.gds_format_string(quote_xml(self.vrouter_instance_type).encode(ExternalEncoding), input_name='vrouter-instance-type'), namespace_, eol_)) + if self.instance_data is not None: + showIndent(outfile, level, pretty_print) + outfile.write('<%sinstance-data>%s</%sinstance-data>%s' % (namespace_, self.gds_format_string(quote_xml(self.instance_data).encode(ExternalEncoding), input_name='instance-data'), namespace_, eol_)) + def hasContent_(self): + if ( + self.service_mode is not None or + self.service_type is not None or + self.image_name is not None or + self.service_scaling is not None or + self.interface_type or + self.flavor is not None or + self.ordered_interfaces is not None or + self.service_virtualization_type is not None or + self.availability_zone_enable is not None or + self.vrouter_instance_type is not None or + self.instance_data is not None + ): + return True + else: + return False + def exportLiteral(self, outfile, level, name_='ServiceTemplateType'): + level += 1 + self.exportLiteralAttributes(outfile, level, [], name_) + if self.hasContent_(): + self.exportLiteralChildren(outfile, level, name_) + def exportLiteralAttributes(self, outfile, level, already_processed, name_): + pass + def exportLiteralChildren(self, outfile, level, name_): + if self.service_mode is not None: + showIndent(outfile, level) + outfile.write('service_mode=%s,\n' % quote_python(self.service_mode).encode(ExternalEncoding)) + if self.service_type is not None: + showIndent(outfile, level) + outfile.write('service_type=%s,\n' % quote_python(self.service_type).encode(ExternalEncoding)) + if self.image_name is not None: + showIndent(outfile, level) + outfile.write('image_name=%s,\n' % quote_python(self.image_name).encode(ExternalEncoding)) + if self.service_scaling is not None: + showIndent(outfile, level) + outfile.write('service_scaling=%s,\n' % self.service_scaling) + showIndent(outfile, level) + outfile.write('interface_type=[\n') + level += 1 + for interface_type_ in self.interface_type: + showIndent(outfile, level) + outfile.write('model_.ServiceTemplateInterfaceType(\n') + interface_type_.exportLiteral(outfile, level, name_='ServiceTemplateInterfaceType') + showIndent(outfile, level) + outfile.write('),\n') + level -= 1 + showIndent(outfile, level) + outfile.write('],\n') + if self.flavor is not None: + showIndent(outfile, level) + outfile.write('flavor=%s,\n' % quote_python(self.flavor).encode(ExternalEncoding)) + if self.ordered_interfaces is not None: + showIndent(outfile, level) + outfile.write('ordered_interfaces=%s,\n' % self.ordered_interfaces) + if self.service_virtualization_type is not None: + showIndent(outfile, level) + outfile.write('service_virtualization_type=%s,\n' % quote_python(self.service_virtualization_type).encode(ExternalEncoding)) + if self.availability_zone_enable is not None: + showIndent(outfile, level) + outfile.write('availability_zone_enable=%s,\n' % self.availability_zone_enable) + if self.vrouter_instance_type is not None: + showIndent(outfile, level) + outfile.write('vrouter_instance_type=%s,\n' % quote_python(self.vrouter_instance_type).encode(ExternalEncoding)) + if self.instance_data is not None: + showIndent(outfile, level) + outfile.write('instance_data=%s,\n' % quote_python(self.instance_data).encode(ExternalEncoding)) + def exportDict(self, name_='ServiceTemplateType'): + obj_json = json.dumps(self, default=lambda o: dict((k, v) for k, v in o.__dict__.iteritems())) + obj_dict = json.loads(obj_json) + return {name_: obj_dict} + def build(self, node): + self.buildAttributes(node, node.attrib, []) + for child in node: + nodeName_ = Tag_pattern_.match(child.tag).groups()[-1] + self.buildChildren(child, node, nodeName_) + def buildAttributes(self, node, attrs, already_processed): + pass + def buildChildren(self, child_, node, nodeName_, fromsubclass_=False): + if nodeName_ == 'service-mode': + service_mode_ = child_.text + service_mode_ = self.gds_validate_string(service_mode_, node, 'service_mode') + self.service_mode = service_mode_ + self.validate_ServiceModeType(self.service_mode) # validate type ServiceModeType + elif nodeName_ == 'service-type': + service_type_ = child_.text + service_type_ = self.gds_validate_string(service_type_, node, 'service_type') + self.service_type = service_type_ + self.validate_ServiceType(self.service_type) # validate type ServiceType + elif nodeName_ == 'image-name': + image_name_ = child_.text + image_name_ = self.gds_validate_string(image_name_, node, 'image_name') + self.image_name = image_name_ + elif nodeName_ == 'service-scaling': + sval_ = child_.text + if sval_ in ('true', '1'): + ival_ = True + elif sval_ in ('false', '0'): + ival_ = False + else: + raise_parse_error(child_, 'requires boolean') + ival_ = self.gds_validate_boolean(ival_, node, 'service_scaling') + self.service_scaling = ival_ + elif nodeName_ == 'interface-type': + obj_ = ServiceTemplateInterfaceType.factory() + obj_.build(child_) + self.interface_type.append(obj_) + elif nodeName_ == 'flavor': + flavor_ = child_.text + flavor_ = self.gds_validate_string(flavor_, node, 'flavor') + self.flavor = flavor_ + elif nodeName_ == 'ordered-interfaces': + sval_ = child_.text + if sval_ in ('true', '1'): + ival_ = True + elif sval_ in ('false', '0'): + ival_ = False + else: + raise_parse_error(child_, 'requires boolean') + ival_ = self.gds_validate_boolean(ival_, node, 'ordered_interfaces') + self.ordered_interfaces = ival_ + elif nodeName_ == 'service-virtualization-type': + service_virtualization_type_ = child_.text + service_virtualization_type_ = self.gds_validate_string(service_virtualization_type_, node, 'service_virtualization_type') + self.service_virtualization_type = service_virtualization_type_ + self.validate_ServiceVirtualizationType(self.service_virtualization_type) # validate type ServiceVirtualizationType + elif nodeName_ == 'availability-zone-enable': + sval_ = child_.text + if sval_ in ('true', '1'): + ival_ = True + elif sval_ in ('false', '0'): + ival_ = False + else: + raise_parse_error(child_, 'requires boolean') + ival_ = self.gds_validate_boolean(ival_, node, 'availability_zone_enable') + self.availability_zone_enable = ival_ + elif nodeName_ == 'vrouter-instance-type': + vrouter_instance_type_ = child_.text + vrouter_instance_type_ = self.gds_validate_string(vrouter_instance_type_, node, 'vrouter_instance_type') + self.vrouter_instance_type = vrouter_instance_type_ + self.validate_VRouterInstanceType(self.vrouter_instance_type) # validate type VRouterInstanceType + elif nodeName_ == 'instance-data': + instance_data_ = child_.text + instance_data_ = self.gds_validate_string(instance_data_, node, 'instance_data') + self.instance_data = instance_data_ +# end class ServiceTemplateType + + +class ServiceInstanceType(GeneratedsSuper): + """ + ServiceInstanceType class definition from :doc:`vnc_cfg.xsd` + """ + subclass = None + superclass = None + def __init__(self, auto_policy=False, availability_zone=None, management_virtual_network=None, left_virtual_network=None, left_ip_address=None, right_virtual_network=None, right_ip_address=None, interface_list=None, scale_out=None, ha_mode=None, virtual_router_id=None, **kwargs): + self.auto_policy = auto_policy + self.availability_zone = availability_zone + self.management_virtual_network = management_virtual_network + self.left_virtual_network = left_virtual_network + self.left_ip_address = left_ip_address + self.right_virtual_network = right_virtual_network + self.right_ip_address = right_ip_address + if (interface_list is None) or (interface_list == []): + self.interface_list = [] + else: + if isinstance(interface_list[0], dict): + objs = [ServiceInstanceInterfaceType(**elem) for elem in interface_list] + self.interface_list = objs + else: + self.interface_list = interface_list + if isinstance(scale_out, dict): + obj = ServiceScaleOutType(**scale_out) + self.scale_out = obj + else: + self.scale_out = scale_out + self.ha_mode = ha_mode + self.virtual_router_id = virtual_router_id + def factory(*args_, **kwargs_): + if ServiceInstanceType.subclass: + return ServiceInstanceType.subclass(*args_, **kwargs_) + else: + return ServiceInstanceType(*args_, **kwargs_) + factory = staticmethod(factory) + def get_auto_policy(self): return self.auto_policy + def set_auto_policy(self, auto_policy): self.auto_policy = auto_policy + def get_availability_zone(self): return self.availability_zone + def set_availability_zone(self, availability_zone): self.availability_zone = availability_zone + def get_management_virtual_network(self): return self.management_virtual_network + def set_management_virtual_network(self, management_virtual_network): self.management_virtual_network = management_virtual_network + def get_left_virtual_network(self): return self.left_virtual_network + def set_left_virtual_network(self, left_virtual_network): self.left_virtual_network = left_virtual_network + def get_left_ip_address(self): return self.left_ip_address + def set_left_ip_address(self, left_ip_address): self.left_ip_address = left_ip_address + def validate_IpAddressType(self, value): + # Validate type IpAddressType, a restriction on xsd:string. + pass + def get_right_virtual_network(self): return self.right_virtual_network + def set_right_virtual_network(self, right_virtual_network): self.right_virtual_network = right_virtual_network + def get_right_ip_address(self): return self.right_ip_address + def set_right_ip_address(self, right_ip_address): self.right_ip_address = right_ip_address + def get_interface_list(self): return self.interface_list + def set_interface_list(self, interface_list): self.interface_list = interface_list + def add_interface_list(self, value): self.interface_list.append(value) + def insert_interface_list(self, index, value): self.interface_list[index] = value + def delete_interface_list(self, value): self.interface_list.remove(value) + def get_scale_out(self): return self.scale_out + def set_scale_out(self, scale_out): self.scale_out = scale_out + def get_ha_mode(self): return self.ha_mode + def set_ha_mode(self, ha_mode): self.ha_mode = ha_mode + def validate_AddressMode(self, value): + # Validate type AddressMode, a restriction on xsd:string. + error = False + if isinstance(value, list): + error = set(value) - set([u'active-active', u'active-standby']) + else: + error = value not in [u'active-active', u'active-standby'] + if error: + raise ValueError("AddressMode must be one of [u'active-active', u'active-standby']") + def get_virtual_router_id(self): return self.virtual_router_id + def set_virtual_router_id(self, virtual_router_id): self.virtual_router_id = virtual_router_id + def __eq__(self, other): + if isinstance(other, self.__class__): + return (self.auto_policy == other.auto_policy and + self.availability_zone == other.availability_zone and + self.management_virtual_network == other.management_virtual_network and + self.left_virtual_network == other.left_virtual_network and + self.left_ip_address == other.left_ip_address and + self.right_virtual_network == other.right_virtual_network and + self.right_ip_address == other.right_ip_address and + self.interface_list == other.interface_list and + self.scale_out == other.scale_out and + self.ha_mode == other.ha_mode and + self.virtual_router_id == other.virtual_router_id) + return NotImplemented + def __ne__(self, other): + if isinstance(other, self.__class__): + return not self.__eq__(other) + return NotImplemented + + @classmethod + def populate (cls, *a, **kwa): + obj = cls (*a, **kwa) + obj.set_auto_policy (obj.populate_boolean ("auto_policy")) + obj.set_availability_zone (obj.populate_string ("availability_zone")) + obj.set_management_virtual_network (obj.populate_string ("management_virtual_network")) + obj.set_left_virtual_network (obj.populate_string ("left_virtual_network")) + obj.set_left_ip_address (obj.populate_string ("left_ip_address")) + obj.set_right_virtual_network (obj.populate_string ("right_virtual_network")) + obj.set_right_ip_address (obj.populate_string ("right_ip_address")) + obj.set_interface_list ([ServiceInstanceInterfaceType.populate ()]) + obj.set_scale_out (ServiceScaleOutType.populate ()) + obj.set_ha_mode (obj.populate_string ("ha_mode")) + obj.set_virtual_router_id (obj.populate_string ("virtual_router_id")) + return obj + def export(self, outfile, level=1, namespace_='', name_='ServiceInstanceType', namespacedef_='', pretty_print=True): + if pretty_print: + eol_ = '\n' + else: + eol_ = '' + showIndent(outfile, level, pretty_print) + outfile.write('<%s%s%s' % (namespace_, name_, namespacedef_ and ' ' + namespacedef_ or '', )) + already_processed = [] + self.exportAttributes(outfile, level, already_processed, namespace_, name_='ServiceInstanceType') + if self.hasContent_(): + outfile.write('>%s' % (eol_, )) + self.exportChildren(outfile, level + 1, namespace_, name_, pretty_print=pretty_print) + showIndent(outfile, level, pretty_print) + outfile.write('</%s%s>%s' % (namespace_, name_, eol_)) + else: + outfile.write('/>%s' % (eol_, )) + def exportAttributes(self, outfile, level, already_processed, namespace_='', name_='ServiceInstanceType'): + pass + def exportChildren(self, outfile, level, namespace_='', name_='ServiceInstanceType', fromsubclass_=False, pretty_print=True): + if pretty_print: + eol_ = '\n' + else: + eol_ = '' + if self.auto_policy is not None: + showIndent(outfile, level, pretty_print) + outfile.write('<%sauto-policy>%s</%sauto-policy>%s' % (namespace_, self.gds_format_boolean(self.gds_str_lower(str(self.auto_policy)), input_name='auto-policy'), namespace_, eol_)) + if self.availability_zone is not None: + showIndent(outfile, level, pretty_print) + outfile.write('<%savailability-zone>%s</%savailability-zone>%s' % (namespace_, self.gds_format_string(quote_xml(self.availability_zone).encode(ExternalEncoding), input_name='availability-zone'), namespace_, eol_)) + if self.management_virtual_network is not None: + showIndent(outfile, level, pretty_print) + outfile.write('<%smanagement-virtual-network>%s</%smanagement-virtual-network>%s' % (namespace_, self.gds_format_string(quote_xml(self.management_virtual_network).encode(ExternalEncoding), input_name='management-virtual-network'), namespace_, eol_)) + if self.left_virtual_network is not None: + showIndent(outfile, level, pretty_print) + outfile.write('<%sleft-virtual-network>%s</%sleft-virtual-network>%s' % (namespace_, self.gds_format_string(quote_xml(self.left_virtual_network).encode(ExternalEncoding), input_name='left-virtual-network'), namespace_, eol_)) + if self.left_ip_address is not None: + showIndent(outfile, level, pretty_print) + outfile.write('<%sleft-ip-address>%s</%sleft-ip-address>%s' % (namespace_, self.gds_format_string(quote_xml(self.left_ip_address).encode(ExternalEncoding), input_name='left-ip-address'), namespace_, eol_)) + if self.right_virtual_network is not None: + showIndent(outfile, level, pretty_print) + outfile.write('<%sright-virtual-network>%s</%sright-virtual-network>%s' % (namespace_, self.gds_format_string(quote_xml(self.right_virtual_network).encode(ExternalEncoding), input_name='right-virtual-network'), namespace_, eol_)) + if self.right_ip_address is not None: + showIndent(outfile, level, pretty_print) + outfile.write('<%sright-ip-address>%s</%sright-ip-address>%s' % (namespace_, self.gds_format_string(quote_xml(self.right_ip_address).encode(ExternalEncoding), input_name='right-ip-address'), namespace_, eol_)) + for interface_list_ in self.interface_list: + if isinstance(interface_list_, dict): + interface_list_ = ServiceInstanceInterfaceType(**interface_list_) + interface_list_.export(outfile, level, namespace_, name_='interface-list', pretty_print=pretty_print) + if self.scale_out is not None: + self.scale_out.export(outfile, level, namespace_, name_='scale-out', pretty_print=pretty_print) + if self.ha_mode is not None: + showIndent(outfile, level, pretty_print) + outfile.write('<%sha-mode>%s</%sha-mode>%s' % (namespace_, self.gds_format_string(quote_xml(self.ha_mode).encode(ExternalEncoding), input_name='ha-mode'), namespace_, eol_)) + if self.virtual_router_id is not None: + showIndent(outfile, level, pretty_print) + outfile.write('<%svirtual-router-id>%s</%svirtual-router-id>%s' % (namespace_, self.gds_format_string(quote_xml(self.virtual_router_id).encode(ExternalEncoding), input_name='virtual-router-id'), namespace_, eol_)) + def hasContent_(self): + if ( + self.auto_policy is not None or + self.availability_zone is not None or + self.management_virtual_network is not None or + self.left_virtual_network is not None or + self.left_ip_address is not None or + self.right_virtual_network is not None or + self.right_ip_address is not None or + self.interface_list or + self.scale_out is not None or + self.ha_mode is not None or + self.virtual_router_id is not None + ): + return True + else: + return False + def exportLiteral(self, outfile, level, name_='ServiceInstanceType'): + level += 1 + self.exportLiteralAttributes(outfile, level, [], name_) + if self.hasContent_(): + self.exportLiteralChildren(outfile, level, name_) + def exportLiteralAttributes(self, outfile, level, already_processed, name_): + pass + def exportLiteralChildren(self, outfile, level, name_): + if self.auto_policy is not None: + showIndent(outfile, level) + outfile.write('auto_policy=%s,\n' % self.auto_policy) + if self.availability_zone is not None: + showIndent(outfile, level) + outfile.write('availability_zone=%s,\n' % quote_python(self.availability_zone).encode(ExternalEncoding)) + if self.management_virtual_network is not None: + showIndent(outfile, level) + outfile.write('management_virtual_network=%s,\n' % quote_python(self.management_virtual_network).encode(ExternalEncoding)) + if self.left_virtual_network is not None: + showIndent(outfile, level) + outfile.write('left_virtual_network=%s,\n' % quote_python(self.left_virtual_network).encode(ExternalEncoding)) + if self.left_ip_address is not None: + showIndent(outfile, level) + outfile.write('left_ip_address=%s,\n' % quote_python(self.left_ip_address).encode(ExternalEncoding)) + if self.right_virtual_network is not None: + showIndent(outfile, level) + outfile.write('right_virtual_network=%s,\n' % quote_python(self.right_virtual_network).encode(ExternalEncoding)) + if self.right_ip_address is not None: + showIndent(outfile, level) + outfile.write('right_ip_address=%s,\n' % quote_python(self.right_ip_address).encode(ExternalEncoding)) + showIndent(outfile, level) + outfile.write('interface_list=[\n') + level += 1 + for interface_list_ in self.interface_list: + showIndent(outfile, level) + outfile.write('model_.ServiceInstanceInterfaceType(\n') + interface_list_.exportLiteral(outfile, level, name_='ServiceInstanceInterfaceType') + showIndent(outfile, level) + outfile.write('),\n') + level -= 1 + showIndent(outfile, level) + outfile.write('],\n') + if self.scale_out is not None: + showIndent(outfile, level) + outfile.write('scale_out=model_.ServiceScaleOutType(\n') + self.scale_out.exportLiteral(outfile, level, name_='scale_out') + showIndent(outfile, level) + outfile.write('),\n') + if self.ha_mode is not None: + showIndent(outfile, level) + outfile.write('ha_mode=%s,\n' % quote_python(self.ha_mode).encode(ExternalEncoding)) + if self.virtual_router_id is not None: + showIndent(outfile, level) + outfile.write('virtual_router_id=%s,\n' % quote_python(self.virtual_router_id).encode(ExternalEncoding)) + def exportDict(self, name_='ServiceInstanceType'): + obj_json = json.dumps(self, default=lambda o: dict((k, v) for k, v in o.__dict__.iteritems())) + obj_dict = json.loads(obj_json) + return {name_: obj_dict} + def build(self, node): + self.buildAttributes(node, node.attrib, []) + for child in node: + nodeName_ = Tag_pattern_.match(child.tag).groups()[-1] + self.buildChildren(child, node, nodeName_) + def buildAttributes(self, node, attrs, already_processed): + pass + def buildChildren(self, child_, node, nodeName_, fromsubclass_=False): + if nodeName_ == 'auto-policy': + sval_ = child_.text + if sval_ in ('true', '1'): + ival_ = True + elif sval_ in ('false', '0'): + ival_ = False + else: + raise_parse_error(child_, 'requires boolean') + ival_ = self.gds_validate_boolean(ival_, node, 'auto_policy') + self.auto_policy = ival_ + elif nodeName_ == 'availability-zone': + availability_zone_ = child_.text + availability_zone_ = self.gds_validate_string(availability_zone_, node, 'availability_zone') + self.availability_zone = availability_zone_ + elif nodeName_ == 'management-virtual-network': + management_virtual_network_ = child_.text + management_virtual_network_ = self.gds_validate_string(management_virtual_network_, node, 'management_virtual_network') + self.management_virtual_network = management_virtual_network_ + elif nodeName_ == 'left-virtual-network': + left_virtual_network_ = child_.text + left_virtual_network_ = self.gds_validate_string(left_virtual_network_, node, 'left_virtual_network') + self.left_virtual_network = left_virtual_network_ + elif nodeName_ == 'left-ip-address': + left_ip_address_ = child_.text + left_ip_address_ = self.gds_validate_string(left_ip_address_, node, 'left_ip_address') + self.left_ip_address = left_ip_address_ + self.validate_IpAddressType(self.left_ip_address) # validate type IpAddressType + elif nodeName_ == 'right-virtual-network': + right_virtual_network_ = child_.text + right_virtual_network_ = self.gds_validate_string(right_virtual_network_, node, 'right_virtual_network') + self.right_virtual_network = right_virtual_network_ + elif nodeName_ == 'right-ip-address': + right_ip_address_ = child_.text + right_ip_address_ = self.gds_validate_string(right_ip_address_, node, 'right_ip_address') + self.right_ip_address = right_ip_address_ + self.validate_IpAddressType(self.right_ip_address) # validate type IpAddressType + elif nodeName_ == 'interface-list': + obj_ = ServiceInstanceInterfaceType.factory() + obj_.build(child_) + self.interface_list.append(obj_) + elif nodeName_ == 'scale-out': + obj_ = ServiceScaleOutType.factory() + obj_.build(child_) + self.set_scale_out(obj_) + elif nodeName_ == 'ha-mode': + ha_mode_ = child_.text + ha_mode_ = self.gds_validate_string(ha_mode_, node, 'ha_mode') + self.ha_mode = ha_mode_ + self.validate_AddressMode(self.ha_mode) # validate type AddressMode + elif nodeName_ == 'virtual-router-id': + virtual_router_id_ = child_.text + virtual_router_id_ = self.gds_validate_string(virtual_router_id_, node, 'virtual_router_id') + self.virtual_router_id = virtual_router_id_ +# end class ServiceInstanceType + + +class project_service_instance(GeneratedsSuper): + """ + project_service_instance class definition from :doc:`vnc_cfg.xsd` + """ + subclass = None + superclass = None + def __init__(self, **kwargs): + pass + def factory(*args_, **kwargs_): + if project_service_instance.subclass: + return project_service_instance.subclass(*args_, **kwargs_) + else: + return project_service_instance(*args_, **kwargs_) + factory = staticmethod(factory) + def __eq__(self, other): return True + def __ne__(self, other): return False + @classmethod + def populate (cls, *a, **kwa): + obj = cls (*a, **kwa) + return obj + def export(self, outfile, level=1, namespace_='', name_='project-service-instance', namespacedef_='', pretty_print=True): + if pretty_print: + eol_ = '\n' + else: + eol_ = '' + showIndent(outfile, level, pretty_print) + outfile.write('<%s%s%s' % (namespace_, name_, namespacedef_ and ' ' + namespacedef_ or '', )) + already_processed = [] + self.exportAttributes(outfile, level, already_processed, namespace_, name_='project-service-instance') + if self.hasContent_(): + outfile.write('>%s' % (eol_, )) + self.exportChildren(outfile, level + 1, namespace_, name_, pretty_print=pretty_print) + outfile.write('</%s%s>%s' % (namespace_, name_, eol_)) + else: + outfile.write('/>%s' % (eol_, )) + def exportAttributes(self, outfile, level, already_processed, namespace_='', name_='project-service-instance'): + pass + def exportChildren(self, outfile, level, namespace_='', name_='project-service-instance', fromsubclass_=False, pretty_print=True): + pass + def hasContent_(self): + if ( + + ): + return True + else: + return False + def exportLiteral(self, outfile, level, name_='project-service-instance'): + level += 1 + self.exportLiteralAttributes(outfile, level, [], name_) + if self.hasContent_(): + self.exportLiteralChildren(outfile, level, name_) + def exportLiteralAttributes(self, outfile, level, already_processed, name_): + pass + def exportLiteralChildren(self, outfile, level, name_): + pass + def exportDict(self, name_='project-service-instance'): + obj_json = json.dumps(self, default=lambda o: dict((k, v) for k, v in o.__dict__.iteritems())) + obj_dict = json.loads(obj_json) + return {name_: obj_dict} + def build(self, node): + self.buildAttributes(node, node.attrib, []) + for child in node: + nodeName_ = Tag_pattern_.match(child.tag).groups()[-1] + self.buildChildren(child, node, nodeName_) + def buildAttributes(self, node, attrs, already_processed): + pass + def buildChildren(self, child_, node, nodeName_, fromsubclass_=False): + pass +# end class project_service_instance + + +class domain_service_template(GeneratedsSuper): + """ + domain_service_template class definition from :doc:`vnc_cfg.xsd` + """ + subclass = None + superclass = None + def __init__(self, **kwargs): + pass + def factory(*args_, **kwargs_): + if domain_service_template.subclass: + return domain_service_template.subclass(*args_, **kwargs_) + else: + return domain_service_template(*args_, **kwargs_) + factory = staticmethod(factory) + def __eq__(self, other): return True + def __ne__(self, other): return False + @classmethod + def populate (cls, *a, **kwa): + obj = cls (*a, **kwa) + return obj + def export(self, outfile, level=1, namespace_='', name_='domain-service-template', namespacedef_='', pretty_print=True): + if pretty_print: + eol_ = '\n' + else: + eol_ = '' + showIndent(outfile, level, pretty_print) + outfile.write('<%s%s%s' % (namespace_, name_, namespacedef_ and ' ' + namespacedef_ or '', )) + already_processed = [] + self.exportAttributes(outfile, level, already_processed, namespace_, name_='domain-service-template') + if self.hasContent_(): + outfile.write('>%s' % (eol_, )) + self.exportChildren(outfile, level + 1, namespace_, name_, pretty_print=pretty_print) + outfile.write('</%s%s>%s' % (namespace_, name_, eol_)) + else: + outfile.write('/>%s' % (eol_, )) + def exportAttributes(self, outfile, level, already_processed, namespace_='', name_='domain-service-template'): + pass + def exportChildren(self, outfile, level, namespace_='', name_='domain-service-template', fromsubclass_=False, pretty_print=True): + pass + def hasContent_(self): + if ( + + ): + return True + else: + return False + def exportLiteral(self, outfile, level, name_='domain-service-template'): + level += 1 + self.exportLiteralAttributes(outfile, level, [], name_) + if self.hasContent_(): + self.exportLiteralChildren(outfile, level, name_) + def exportLiteralAttributes(self, outfile, level, already_processed, name_): + pass + def exportLiteralChildren(self, outfile, level, name_): + pass + def exportDict(self, name_='domain-service-template'): + obj_json = json.dumps(self, default=lambda o: dict((k, v) for k, v in o.__dict__.iteritems())) + obj_dict = json.loads(obj_json) + return {name_: obj_dict} + def build(self, node): + self.buildAttributes(node, node.attrib, []) + for child in node: + nodeName_ = Tag_pattern_.match(child.tag).groups()[-1] + self.buildChildren(child, node, nodeName_) + def buildAttributes(self, node, attrs, already_processed): + pass + def buildChildren(self, child_, node, nodeName_, fromsubclass_=False): + pass +# end class domain_service_template + + +class service_instance_service_template(GeneratedsSuper): + """ + service_instance_service_template class definition from :doc:`vnc_cfg.xsd` + """ + subclass = None + superclass = None + def __init__(self, **kwargs): + pass + def factory(*args_, **kwargs_): + if service_instance_service_template.subclass: + return service_instance_service_template.subclass(*args_, **kwargs_) + else: + return service_instance_service_template(*args_, **kwargs_) + factory = staticmethod(factory) + def __eq__(self, other): return True + def __ne__(self, other): return False + @classmethod + def populate (cls, *a, **kwa): + obj = cls (*a, **kwa) + return obj + def export(self, outfile, level=1, namespace_='', name_='service-instance-service-template', namespacedef_='', pretty_print=True): + if pretty_print: + eol_ = '\n' + else: + eol_ = '' + showIndent(outfile, level, pretty_print) + outfile.write('<%s%s%s' % (namespace_, name_, namespacedef_ and ' ' + namespacedef_ or '', )) + already_processed = [] + self.exportAttributes(outfile, level, already_processed, namespace_, name_='service-instance-service-template') + if self.hasContent_(): + outfile.write('>%s' % (eol_, )) + self.exportChildren(outfile, level + 1, namespace_, name_, pretty_print=pretty_print) + outfile.write('</%s%s>%s' % (namespace_, name_, eol_)) + else: + outfile.write('/>%s' % (eol_, )) + def exportAttributes(self, outfile, level, already_processed, namespace_='', name_='service-instance-service-template'): + pass + def exportChildren(self, outfile, level, namespace_='', name_='service-instance-service-template', fromsubclass_=False, pretty_print=True): + pass + def hasContent_(self): + if ( + + ): + return True + else: + return False + def exportLiteral(self, outfile, level, name_='service-instance-service-template'): + level += 1 + self.exportLiteralAttributes(outfile, level, [], name_) + if self.hasContent_(): + self.exportLiteralChildren(outfile, level, name_) + def exportLiteralAttributes(self, outfile, level, already_processed, name_): + pass + def exportLiteralChildren(self, outfile, level, name_): + pass + def exportDict(self, name_='service-instance-service-template'): + obj_json = json.dumps(self, default=lambda o: dict((k, v) for k, v in o.__dict__.iteritems())) + obj_dict = json.loads(obj_json) + return {name_: obj_dict} + def build(self, node): + self.buildAttributes(node, node.attrib, []) + for child in node: + nodeName_ = Tag_pattern_.match(child.tag).groups()[-1] + self.buildChildren(child, node, nodeName_) + def buildAttributes(self, node, attrs, already_processed): + pass + def buildChildren(self, child_, node, nodeName_, fromsubclass_=False): + pass +# end class service_instance_service_template + + +class virtual_machine_service_instance(GeneratedsSuper): + """ + virtual_machine_service_instance class definition from :doc:`vnc_cfg.xsd` + """ + subclass = None + superclass = None + def __init__(self, **kwargs): + pass + def factory(*args_, **kwargs_): + if virtual_machine_service_instance.subclass: + return virtual_machine_service_instance.subclass(*args_, **kwargs_) + else: + return virtual_machine_service_instance(*args_, **kwargs_) + factory = staticmethod(factory) + def __eq__(self, other): return True + def __ne__(self, other): return False + @classmethod + def populate (cls, *a, **kwa): + obj = cls (*a, **kwa) + return obj + def export(self, outfile, level=1, namespace_='', name_='virtual-machine-service-instance', namespacedef_='', pretty_print=True): + if pretty_print: + eol_ = '\n' + else: + eol_ = '' + showIndent(outfile, level, pretty_print) + outfile.write('<%s%s%s' % (namespace_, name_, namespacedef_ and ' ' + namespacedef_ or '', )) + already_processed = [] + self.exportAttributes(outfile, level, already_processed, namespace_, name_='virtual-machine-service-instance') + if self.hasContent_(): + outfile.write('>%s' % (eol_, )) + self.exportChildren(outfile, level + 1, namespace_, name_, pretty_print=pretty_print) + outfile.write('</%s%s>%s' % (namespace_, name_, eol_)) + else: + outfile.write('/>%s' % (eol_, )) + def exportAttributes(self, outfile, level, already_processed, namespace_='', name_='virtual-machine-service-instance'): + pass + def exportChildren(self, outfile, level, namespace_='', name_='virtual-machine-service-instance', fromsubclass_=False, pretty_print=True): + pass + def hasContent_(self): + if ( + + ): + return True + else: + return False + def exportLiteral(self, outfile, level, name_='virtual-machine-service-instance'): + level += 1 + self.exportLiteralAttributes(outfile, level, [], name_) + if self.hasContent_(): + self.exportLiteralChildren(outfile, level, name_) + def exportLiteralAttributes(self, outfile, level, already_processed, name_): + pass + def exportLiteralChildren(self, outfile, level, name_): + pass + def exportDict(self, name_='virtual-machine-service-instance'): + obj_json = json.dumps(self, default=lambda o: dict((k, v) for k, v in o.__dict__.iteritems())) + obj_dict = json.loads(obj_json) + return {name_: obj_dict} + def build(self, node): + self.buildAttributes(node, node.attrib, []) + for child in node: + nodeName_ = Tag_pattern_.match(child.tag).groups()[-1] + self.buildChildren(child, node, nodeName_) + def buildAttributes(self, node, attrs, already_processed): + pass + def buildChildren(self, child_, node, nodeName_, fromsubclass_=False): + pass +# end class virtual_machine_service_instance + + +class domain_virtual_DNS(GeneratedsSuper): + """ + domain_virtual_DNS class definition from :doc:`vnc_cfg.xsd` + """ + subclass = None + superclass = None + def __init__(self, **kwargs): + pass + def factory(*args_, **kwargs_): + if domain_virtual_DNS.subclass: + return domain_virtual_DNS.subclass(*args_, **kwargs_) + else: + return domain_virtual_DNS(*args_, **kwargs_) + factory = staticmethod(factory) + def __eq__(self, other): return True + def __ne__(self, other): return False + @classmethod + def populate (cls, *a, **kwa): + obj = cls (*a, **kwa) + return obj + def export(self, outfile, level=1, namespace_='', name_='domain-virtual-DNS', namespacedef_='', pretty_print=True): + if pretty_print: + eol_ = '\n' + else: + eol_ = '' + showIndent(outfile, level, pretty_print) + outfile.write('<%s%s%s' % (namespace_, name_, namespacedef_ and ' ' + namespacedef_ or '', )) + already_processed = [] + self.exportAttributes(outfile, level, already_processed, namespace_, name_='domain-virtual-DNS') + if self.hasContent_(): + outfile.write('>%s' % (eol_, )) + self.exportChildren(outfile, level + 1, namespace_, name_, pretty_print=pretty_print) + outfile.write('</%s%s>%s' % (namespace_, name_, eol_)) + else: + outfile.write('/>%s' % (eol_, )) + def exportAttributes(self, outfile, level, already_processed, namespace_='', name_='domain-virtual-DNS'): + pass + def exportChildren(self, outfile, level, namespace_='', name_='domain-virtual-DNS', fromsubclass_=False, pretty_print=True): + pass + def hasContent_(self): + if ( + + ): + return True + else: + return False + def exportLiteral(self, outfile, level, name_='domain-virtual-DNS'): + level += 1 + self.exportLiteralAttributes(outfile, level, [], name_) + if self.hasContent_(): + self.exportLiteralChildren(outfile, level, name_) + def exportLiteralAttributes(self, outfile, level, already_processed, name_): + pass + def exportLiteralChildren(self, outfile, level, name_): + pass + def exportDict(self, name_='domain-virtual-DNS'): + obj_json = json.dumps(self, default=lambda o: dict((k, v) for k, v in o.__dict__.iteritems())) + obj_dict = json.loads(obj_json) + return {name_: obj_dict} + def build(self, node): + self.buildAttributes(node, node.attrib, []) + for child in node: + nodeName_ = Tag_pattern_.match(child.tag).groups()[-1] + self.buildChildren(child, node, nodeName_) + def buildAttributes(self, node, attrs, already_processed): + pass + def buildChildren(self, child_, node, nodeName_, fromsubclass_=False): + pass +# end class domain_virtual_DNS + + +class virtual_DNS_virtual_DNS_record(GeneratedsSuper): + """ + virtual_DNS_virtual_DNS_record class definition from :doc:`vnc_cfg.xsd` + """ + subclass = None + superclass = None + def __init__(self, **kwargs): + pass + def factory(*args_, **kwargs_): + if virtual_DNS_virtual_DNS_record.subclass: + return virtual_DNS_virtual_DNS_record.subclass(*args_, **kwargs_) + else: + return virtual_DNS_virtual_DNS_record(*args_, **kwargs_) + factory = staticmethod(factory) + def __eq__(self, other): return True + def __ne__(self, other): return False + @classmethod + def populate (cls, *a, **kwa): + obj = cls (*a, **kwa) + return obj + def export(self, outfile, level=1, namespace_='', name_='virtual-DNS-virtual-DNS-record', namespacedef_='', pretty_print=True): + if pretty_print: + eol_ = '\n' + else: + eol_ = '' + showIndent(outfile, level, pretty_print) + outfile.write('<%s%s%s' % (namespace_, name_, namespacedef_ and ' ' + namespacedef_ or '', )) + already_processed = [] + self.exportAttributes(outfile, level, already_processed, namespace_, name_='virtual-DNS-virtual-DNS-record') + if self.hasContent_(): + outfile.write('>%s' % (eol_, )) + self.exportChildren(outfile, level + 1, namespace_, name_, pretty_print=pretty_print) + outfile.write('</%s%s>%s' % (namespace_, name_, eol_)) + else: + outfile.write('/>%s' % (eol_, )) + def exportAttributes(self, outfile, level, already_processed, namespace_='', name_='virtual-DNS-virtual-DNS-record'): + pass + def exportChildren(self, outfile, level, namespace_='', name_='virtual-DNS-virtual-DNS-record', fromsubclass_=False, pretty_print=True): + pass + def hasContent_(self): + if ( + + ): + return True + else: + return False + def exportLiteral(self, outfile, level, name_='virtual-DNS-virtual-DNS-record'): + level += 1 + self.exportLiteralAttributes(outfile, level, [], name_) + if self.hasContent_(): + self.exportLiteralChildren(outfile, level, name_) + def exportLiteralAttributes(self, outfile, level, already_processed, name_): + pass + def exportLiteralChildren(self, outfile, level, name_): + pass + def exportDict(self, name_='virtual-DNS-virtual-DNS-record'): + obj_json = json.dumps(self, default=lambda o: dict((k, v) for k, v in o.__dict__.iteritems())) + obj_dict = json.loads(obj_json) + return {name_: obj_dict} + def build(self, node): + self.buildAttributes(node, node.attrib, []) + for child in node: + nodeName_ = Tag_pattern_.match(child.tag).groups()[-1] + self.buildChildren(child, node, nodeName_) + def buildAttributes(self, node, attrs, already_processed): + pass + def buildChildren(self, child_, node, nodeName_, fromsubclass_=False): + pass +# end class virtual_DNS_virtual_DNS_record + + +class network_ipam_virtual_DNS(GeneratedsSuper): + """ + network_ipam_virtual_DNS class definition from :doc:`vnc_cfg.xsd` + """ + subclass = None + superclass = None + def __init__(self, **kwargs): + pass + def factory(*args_, **kwargs_): + if network_ipam_virtual_DNS.subclass: + return network_ipam_virtual_DNS.subclass(*args_, **kwargs_) + else: + return network_ipam_virtual_DNS(*args_, **kwargs_) + factory = staticmethod(factory) + def __eq__(self, other): return True + def __ne__(self, other): return False + @classmethod + def populate (cls, *a, **kwa): + obj = cls (*a, **kwa) + return obj + def export(self, outfile, level=1, namespace_='', name_='network-ipam-virtual-DNS', namespacedef_='', pretty_print=True): + if pretty_print: + eol_ = '\n' + else: + eol_ = '' + showIndent(outfile, level, pretty_print) + outfile.write('<%s%s%s' % (namespace_, name_, namespacedef_ and ' ' + namespacedef_ or '', )) + already_processed = [] + self.exportAttributes(outfile, level, already_processed, namespace_, name_='network-ipam-virtual-DNS') + if self.hasContent_(): + outfile.write('>%s' % (eol_, )) + self.exportChildren(outfile, level + 1, namespace_, name_, pretty_print=pretty_print) + outfile.write('</%s%s>%s' % (namespace_, name_, eol_)) + else: + outfile.write('/>%s' % (eol_, )) + def exportAttributes(self, outfile, level, already_processed, namespace_='', name_='network-ipam-virtual-DNS'): + pass + def exportChildren(self, outfile, level, namespace_='', name_='network-ipam-virtual-DNS', fromsubclass_=False, pretty_print=True): + pass + def hasContent_(self): + if ( + + ): + return True + else: + return False + def exportLiteral(self, outfile, level, name_='network-ipam-virtual-DNS'): + level += 1 + self.exportLiteralAttributes(outfile, level, [], name_) + if self.hasContent_(): + self.exportLiteralChildren(outfile, level, name_) + def exportLiteralAttributes(self, outfile, level, already_processed, name_): + pass + def exportLiteralChildren(self, outfile, level, name_): + pass + def exportDict(self, name_='network-ipam-virtual-DNS'): + obj_json = json.dumps(self, default=lambda o: dict((k, v) for k, v in o.__dict__.iteritems())) + obj_dict = json.loads(obj_json) + return {name_: obj_dict} + def build(self, node): + self.buildAttributes(node, node.attrib, []) + for child in node: + nodeName_ = Tag_pattern_.match(child.tag).groups()[-1] + self.buildChildren(child, node, nodeName_) + def buildAttributes(self, node, attrs, already_processed): + pass + def buildChildren(self, child_, node, nodeName_, fromsubclass_=False): + pass +# end class network_ipam_virtual_DNS + + +class RouteType(GeneratedsSuper): + """ + RouteType class definition from :doc:`vnc_cfg.xsd` + """ + subclass = None + superclass = None + def __init__(self, prefix=None, next_hop=None, next_hop_type=None, **kwargs): + self.prefix = prefix + self.next_hop = next_hop + self.next_hop_type = next_hop_type + def factory(*args_, **kwargs_): + if RouteType.subclass: + return RouteType.subclass(*args_, **kwargs_) + else: + return RouteType(*args_, **kwargs_) + factory = staticmethod(factory) + def get_prefix(self): return self.prefix + def set_prefix(self, prefix): self.prefix = prefix + def get_next_hop(self): return self.next_hop + def set_next_hop(self, next_hop): self.next_hop = next_hop + def get_next_hop_type(self): return self.next_hop_type + def set_next_hop_type(self, next_hop_type): self.next_hop_type = next_hop_type + def __eq__(self, other): + if isinstance(other, self.__class__): + return (self.prefix == other.prefix and + self.next_hop == other.next_hop and + self.next_hop_type == other.next_hop_type) + return NotImplemented + def __ne__(self, other): + if isinstance(other, self.__class__): + return not self.__eq__(other) + return NotImplemented + + @classmethod + def populate (cls, *a, **kwa): + obj = cls (*a, **kwa) + obj.set_prefix (obj.populate_string ("prefix")) + obj.set_next_hop (obj.populate_string ("next_hop")) + obj.set_next_hop_type (obj.populate_string ("next_hop_type")) + return obj + def export(self, outfile, level=1, namespace_='', name_='RouteType', namespacedef_='', pretty_print=True): + if pretty_print: + eol_ = '\n' + else: + eol_ = '' + showIndent(outfile, level, pretty_print) + outfile.write('<%s%s%s' % (namespace_, name_, namespacedef_ and ' ' + namespacedef_ or '', )) + already_processed = [] + self.exportAttributes(outfile, level, already_processed, namespace_, name_='RouteType') + if self.hasContent_(): + outfile.write('>%s' % (eol_, )) + self.exportChildren(outfile, level + 1, namespace_, name_, pretty_print=pretty_print) + showIndent(outfile, level, pretty_print) + outfile.write('</%s%s>%s' % (namespace_, name_, eol_)) + else: + outfile.write('/>%s' % (eol_, )) + def exportAttributes(self, outfile, level, already_processed, namespace_='', name_='RouteType'): + pass + def exportChildren(self, outfile, level, namespace_='', name_='RouteType', fromsubclass_=False, pretty_print=True): + if pretty_print: + eol_ = '\n' + else: + eol_ = '' + if self.prefix is not None: + showIndent(outfile, level, pretty_print) + outfile.write('<%sprefix>%s</%sprefix>%s' % (namespace_, self.gds_format_string(quote_xml(self.prefix).encode(ExternalEncoding), input_name='prefix'), namespace_, eol_)) + if self.next_hop is not None: + showIndent(outfile, level, pretty_print) + outfile.write('<%snext-hop>%s</%snext-hop>%s' % (namespace_, self.gds_format_string(quote_xml(self.next_hop).encode(ExternalEncoding), input_name='next-hop'), namespace_, eol_)) + if self.next_hop_type is not None: + showIndent(outfile, level, pretty_print) + outfile.write('<%snext-hop-type>%s</%snext-hop-type>%s' % (namespace_, self.gds_format_string(quote_xml(self.next_hop_type).encode(ExternalEncoding), input_name='next-hop-type'), namespace_, eol_)) + def hasContent_(self): + if ( + self.prefix is not None or + self.next_hop is not None or + self.next_hop_type is not None + ): + return True + else: + return False + def exportLiteral(self, outfile, level, name_='RouteType'): + level += 1 + self.exportLiteralAttributes(outfile, level, [], name_) + if self.hasContent_(): + self.exportLiteralChildren(outfile, level, name_) + def exportLiteralAttributes(self, outfile, level, already_processed, name_): + pass + def exportLiteralChildren(self, outfile, level, name_): + if self.prefix is not None: + showIndent(outfile, level) + outfile.write('prefix=%s,\n' % quote_python(self.prefix).encode(ExternalEncoding)) + if self.next_hop is not None: + showIndent(outfile, level) + outfile.write('next_hop=%s,\n' % quote_python(self.next_hop).encode(ExternalEncoding)) + if self.next_hop_type is not None: + showIndent(outfile, level) + outfile.write('next_hop_type=%s,\n' % quote_python(self.next_hop_type).encode(ExternalEncoding)) + def exportDict(self, name_='RouteType'): + obj_json = json.dumps(self, default=lambda o: dict((k, v) for k, v in o.__dict__.iteritems())) + obj_dict = json.loads(obj_json) + return {name_: obj_dict} + def build(self, node): + self.buildAttributes(node, node.attrib, []) + for child in node: + nodeName_ = Tag_pattern_.match(child.tag).groups()[-1] + self.buildChildren(child, node, nodeName_) + def buildAttributes(self, node, attrs, already_processed): + pass + def buildChildren(self, child_, node, nodeName_, fromsubclass_=False): + if nodeName_ == 'prefix': + prefix_ = child_.text + prefix_ = self.gds_validate_string(prefix_, node, 'prefix') + self.prefix = prefix_ + elif nodeName_ == 'next-hop': + next_hop_ = child_.text + next_hop_ = self.gds_validate_string(next_hop_, node, 'next_hop') + self.next_hop = next_hop_ + elif nodeName_ == 'next-hop-type': + next_hop_type_ = child_.text + next_hop_type_ = self.gds_validate_string(next_hop_type_, node, 'next_hop_type') + self.next_hop_type = next_hop_type_ +# end class RouteType + + +class RouteTableType(GeneratedsSuper): + """ + RouteTableType class definition from :doc:`vnc_cfg.xsd` + """ + subclass = None + superclass = None + def __init__(self, route=None, **kwargs): + if (route is None) or (route == []): + self.route = [] + else: + if isinstance(route[0], dict): + objs = [RouteType(**elem) for elem in route] + self.route = objs + else: + self.route = route + def factory(*args_, **kwargs_): + if RouteTableType.subclass: + return RouteTableType.subclass(*args_, **kwargs_) + else: + return RouteTableType(*args_, **kwargs_) + factory = staticmethod(factory) + def get_route(self): return self.route + def set_route(self, route): self.route = route + def add_route(self, value): self.route.append(value) + def insert_route(self, index, value): self.route[index] = value + def delete_route(self, value): self.route.remove(value) + def __eq__(self, other): + if isinstance(other, self.__class__): + return (self.route == other.route) + return NotImplemented + def __ne__(self, other): + if isinstance(other, self.__class__): + return not self.__eq__(other) + return NotImplemented + + @classmethod + def populate (cls, *a, **kwa): + obj = cls (*a, **kwa) + obj.set_route ([RouteType.populate ()]) + return obj + def export(self, outfile, level=1, namespace_='', name_='RouteTableType', namespacedef_='', pretty_print=True): + if pretty_print: + eol_ = '\n' + else: + eol_ = '' + showIndent(outfile, level, pretty_print) + outfile.write('<%s%s%s' % (namespace_, name_, namespacedef_ and ' ' + namespacedef_ or '', )) + already_processed = [] + self.exportAttributes(outfile, level, already_processed, namespace_, name_='RouteTableType') + if self.hasContent_(): + outfile.write('>%s' % (eol_, )) + self.exportChildren(outfile, level + 1, namespace_, name_, pretty_print=pretty_print) + showIndent(outfile, level, pretty_print) + outfile.write('</%s%s>%s' % (namespace_, name_, eol_)) + else: + outfile.write('/>%s' % (eol_, )) + def exportAttributes(self, outfile, level, already_processed, namespace_='', name_='RouteTableType'): + pass + def exportChildren(self, outfile, level, namespace_='', name_='RouteTableType', fromsubclass_=False, pretty_print=True): + if pretty_print: + eol_ = '\n' + else: + eol_ = '' + for route_ in self.route: + if isinstance(route_, dict): + route_ = RouteType(**route_) + route_.export(outfile, level, namespace_, name_='route', pretty_print=pretty_print) + def hasContent_(self): + if ( + self.route + ): + return True + else: + return False + def exportLiteral(self, outfile, level, name_='RouteTableType'): + level += 1 + self.exportLiteralAttributes(outfile, level, [], name_) + if self.hasContent_(): + self.exportLiteralChildren(outfile, level, name_) + def exportLiteralAttributes(self, outfile, level, already_processed, name_): + pass + def exportLiteralChildren(self, outfile, level, name_): + showIndent(outfile, level) + outfile.write('route=[\n') + level += 1 + for route_ in self.route: + showIndent(outfile, level) + outfile.write('model_.RouteType(\n') + route_.exportLiteral(outfile, level, name_='RouteType') + showIndent(outfile, level) + outfile.write('),\n') + level -= 1 + showIndent(outfile, level) + outfile.write('],\n') + def exportDict(self, name_='RouteTableType'): + obj_json = json.dumps(self, default=lambda o: dict((k, v) for k, v in o.__dict__.iteritems())) + obj_dict = json.loads(obj_json) + return {name_: obj_dict} + def build(self, node): + self.buildAttributes(node, node.attrib, []) + for child in node: + nodeName_ = Tag_pattern_.match(child.tag).groups()[-1] + self.buildChildren(child, node, nodeName_) + def buildAttributes(self, node, attrs, already_processed): + pass + def buildChildren(self, child_, node, nodeName_, fromsubclass_=False): + if nodeName_ == 'route': + obj_ = RouteType.factory() + obj_.build(child_) + self.route.append(obj_) +# end class RouteTableType + + +class project_route_table(GeneratedsSuper): + """ + project_route_table class definition from :doc:`vnc_cfg.xsd` + """ + subclass = None + superclass = None + def __init__(self, **kwargs): + pass + def factory(*args_, **kwargs_): + if project_route_table.subclass: + return project_route_table.subclass(*args_, **kwargs_) + else: + return project_route_table(*args_, **kwargs_) + factory = staticmethod(factory) + def __eq__(self, other): return True + def __ne__(self, other): return False + @classmethod + def populate (cls, *a, **kwa): + obj = cls (*a, **kwa) + return obj + def export(self, outfile, level=1, namespace_='', name_='project-route-table', namespacedef_='', pretty_print=True): + if pretty_print: + eol_ = '\n' + else: + eol_ = '' + showIndent(outfile, level, pretty_print) + outfile.write('<%s%s%s' % (namespace_, name_, namespacedef_ and ' ' + namespacedef_ or '', )) + already_processed = [] + self.exportAttributes(outfile, level, already_processed, namespace_, name_='project-route-table') + if self.hasContent_(): + outfile.write('>%s' % (eol_, )) + self.exportChildren(outfile, level + 1, namespace_, name_, pretty_print=pretty_print) + outfile.write('</%s%s>%s' % (namespace_, name_, eol_)) + else: + outfile.write('/>%s' % (eol_, )) + def exportAttributes(self, outfile, level, already_processed, namespace_='', name_='project-route-table'): + pass + def exportChildren(self, outfile, level, namespace_='', name_='project-route-table', fromsubclass_=False, pretty_print=True): + pass + def hasContent_(self): + if ( + + ): + return True + else: + return False + def exportLiteral(self, outfile, level, name_='project-route-table'): + level += 1 + self.exportLiteralAttributes(outfile, level, [], name_) + if self.hasContent_(): + self.exportLiteralChildren(outfile, level, name_) + def exportLiteralAttributes(self, outfile, level, already_processed, name_): + pass + def exportLiteralChildren(self, outfile, level, name_): + pass + def exportDict(self, name_='project-route-table'): + obj_json = json.dumps(self, default=lambda o: dict((k, v) for k, v in o.__dict__.iteritems())) + obj_dict = json.loads(obj_json) + return {name_: obj_dict} + def build(self, node): + self.buildAttributes(node, node.attrib, []) + for child in node: + nodeName_ = Tag_pattern_.match(child.tag).groups()[-1] + self.buildChildren(child, node, nodeName_) + def buildAttributes(self, node, attrs, already_processed): + pass + def buildChildren(self, child_, node, nodeName_, fromsubclass_=False): + pass +# end class project_route_table + + +class virtual_network_route_table(GeneratedsSuper): + """ + virtual_network_route_table class definition from :doc:`vnc_cfg.xsd` + """ + subclass = None + superclass = None + def __init__(self, **kwargs): + pass + def factory(*args_, **kwargs_): + if virtual_network_route_table.subclass: + return virtual_network_route_table.subclass(*args_, **kwargs_) + else: + return virtual_network_route_table(*args_, **kwargs_) + factory = staticmethod(factory) + def __eq__(self, other): return True + def __ne__(self, other): return False + @classmethod + def populate (cls, *a, **kwa): + obj = cls (*a, **kwa) + return obj + def export(self, outfile, level=1, namespace_='', name_='virtual-network-route-table', namespacedef_='', pretty_print=True): + if pretty_print: + eol_ = '\n' + else: + eol_ = '' + showIndent(outfile, level, pretty_print) + outfile.write('<%s%s%s' % (namespace_, name_, namespacedef_ and ' ' + namespacedef_ or '', )) + already_processed = [] + self.exportAttributes(outfile, level, already_processed, namespace_, name_='virtual-network-route-table') + if self.hasContent_(): + outfile.write('>%s' % (eol_, )) + self.exportChildren(outfile, level + 1, namespace_, name_, pretty_print=pretty_print) + outfile.write('</%s%s>%s' % (namespace_, name_, eol_)) + else: + outfile.write('/>%s' % (eol_, )) + def exportAttributes(self, outfile, level, already_processed, namespace_='', name_='virtual-network-route-table'): + pass + def exportChildren(self, outfile, level, namespace_='', name_='virtual-network-route-table', fromsubclass_=False, pretty_print=True): + pass + def hasContent_(self): + if ( + + ): + return True + else: + return False + def exportLiteral(self, outfile, level, name_='virtual-network-route-table'): + level += 1 + self.exportLiteralAttributes(outfile, level, [], name_) + if self.hasContent_(): + self.exportLiteralChildren(outfile, level, name_) + def exportLiteralAttributes(self, outfile, level, already_processed, name_): + pass + def exportLiteralChildren(self, outfile, level, name_): + pass + def exportDict(self, name_='virtual-network-route-table'): + obj_json = json.dumps(self, default=lambda o: dict((k, v) for k, v in o.__dict__.iteritems())) + obj_dict = json.loads(obj_json) + return {name_: obj_dict} + def build(self, node): + self.buildAttributes(node, node.attrib, []) + for child in node: + nodeName_ = Tag_pattern_.match(child.tag).groups()[-1] + self.buildChildren(child, node, nodeName_) + def buildAttributes(self, node, attrs, already_processed): + pass + def buildChildren(self, child_, node, nodeName_, fromsubclass_=False): + pass +# end class virtual_network_route_table + + +class project_interface_route_table(GeneratedsSuper): + """ + project_interface_route_table class definition from :doc:`vnc_cfg.xsd` + """ + subclass = None + superclass = None + def __init__(self, **kwargs): + pass + def factory(*args_, **kwargs_): + if project_interface_route_table.subclass: + return project_interface_route_table.subclass(*args_, **kwargs_) + else: + return project_interface_route_table(*args_, **kwargs_) + factory = staticmethod(factory) + def __eq__(self, other): return True + def __ne__(self, other): return False + @classmethod + def populate (cls, *a, **kwa): + obj = cls (*a, **kwa) + return obj + def export(self, outfile, level=1, namespace_='', name_='project-interface-route-table', namespacedef_='', pretty_print=True): + if pretty_print: + eol_ = '\n' + else: + eol_ = '' + showIndent(outfile, level, pretty_print) + outfile.write('<%s%s%s' % (namespace_, name_, namespacedef_ and ' ' + namespacedef_ or '', )) + already_processed = [] + self.exportAttributes(outfile, level, already_processed, namespace_, name_='project-interface-route-table') + if self.hasContent_(): + outfile.write('>%s' % (eol_, )) + self.exportChildren(outfile, level + 1, namespace_, name_, pretty_print=pretty_print) + outfile.write('</%s%s>%s' % (namespace_, name_, eol_)) + else: + outfile.write('/>%s' % (eol_, )) + def exportAttributes(self, outfile, level, already_processed, namespace_='', name_='project-interface-route-table'): + pass + def exportChildren(self, outfile, level, namespace_='', name_='project-interface-route-table', fromsubclass_=False, pretty_print=True): + pass + def hasContent_(self): + if ( + + ): + return True + else: + return False + def exportLiteral(self, outfile, level, name_='project-interface-route-table'): + level += 1 + self.exportLiteralAttributes(outfile, level, [], name_) + if self.hasContent_(): + self.exportLiteralChildren(outfile, level, name_) + def exportLiteralAttributes(self, outfile, level, already_processed, name_): + pass + def exportLiteralChildren(self, outfile, level, name_): + pass + def exportDict(self, name_='project-interface-route-table'): + obj_json = json.dumps(self, default=lambda o: dict((k, v) for k, v in o.__dict__.iteritems())) + obj_dict = json.loads(obj_json) + return {name_: obj_dict} + def build(self, node): + self.buildAttributes(node, node.attrib, []) + for child in node: + nodeName_ = Tag_pattern_.match(child.tag).groups()[-1] + self.buildChildren(child, node, nodeName_) + def buildAttributes(self, node, attrs, already_processed): + pass + def buildChildren(self, child_, node, nodeName_, fromsubclass_=False): + pass +# end class project_interface_route_table + + +class virtual_machine_interface_route_table(GeneratedsSuper): + """ + virtual_machine_interface_route_table class definition from :doc:`vnc_cfg.xsd` + """ + subclass = None + superclass = None + def __init__(self, **kwargs): + pass + def factory(*args_, **kwargs_): + if virtual_machine_interface_route_table.subclass: + return virtual_machine_interface_route_table.subclass(*args_, **kwargs_) + else: + return virtual_machine_interface_route_table(*args_, **kwargs_) + factory = staticmethod(factory) + def __eq__(self, other): return True + def __ne__(self, other): return False + @classmethod + def populate (cls, *a, **kwa): + obj = cls (*a, **kwa) + return obj + def export(self, outfile, level=1, namespace_='', name_='virtual-machine-interface-route-table', namespacedef_='', pretty_print=True): + if pretty_print: + eol_ = '\n' + else: + eol_ = '' + showIndent(outfile, level, pretty_print) + outfile.write('<%s%s%s' % (namespace_, name_, namespacedef_ and ' ' + namespacedef_ or '', )) + already_processed = [] + self.exportAttributes(outfile, level, already_processed, namespace_, name_='virtual-machine-interface-route-table') + if self.hasContent_(): + outfile.write('>%s' % (eol_, )) + self.exportChildren(outfile, level + 1, namespace_, name_, pretty_print=pretty_print) + outfile.write('</%s%s>%s' % (namespace_, name_, eol_)) + else: + outfile.write('/>%s' % (eol_, )) + def exportAttributes(self, outfile, level, already_processed, namespace_='', name_='virtual-machine-interface-route-table'): + pass + def exportChildren(self, outfile, level, namespace_='', name_='virtual-machine-interface-route-table', fromsubclass_=False, pretty_print=True): + pass + def hasContent_(self): + if ( + + ): + return True + else: + return False + def exportLiteral(self, outfile, level, name_='virtual-machine-interface-route-table'): + level += 1 + self.exportLiteralAttributes(outfile, level, [], name_) + if self.hasContent_(): + self.exportLiteralChildren(outfile, level, name_) + def exportLiteralAttributes(self, outfile, level, already_processed, name_): + pass + def exportLiteralChildren(self, outfile, level, name_): + pass + def exportDict(self, name_='virtual-machine-interface-route-table'): + obj_json = json.dumps(self, default=lambda o: dict((k, v) for k, v in o.__dict__.iteritems())) + obj_dict = json.loads(obj_json) + return {name_: obj_dict} + def build(self, node): + self.buildAttributes(node, node.attrib, []) + for child in node: + nodeName_ = Tag_pattern_.match(child.tag).groups()[-1] + self.buildChildren(child, node, nodeName_) + def buildAttributes(self, node, attrs, already_processed): + pass + def buildChildren(self, child_, node, nodeName_, fromsubclass_=False): + pass +# end class virtual_machine_interface_route_table + + +class project_logical_router(GeneratedsSuper): + """ + project_logical_router class definition from :doc:`vnc_cfg.xsd` + """ + subclass = None + superclass = None + def __init__(self, **kwargs): + pass + def factory(*args_, **kwargs_): + if project_logical_router.subclass: + return project_logical_router.subclass(*args_, **kwargs_) + else: + return project_logical_router(*args_, **kwargs_) + factory = staticmethod(factory) + def __eq__(self, other): return True + def __ne__(self, other): return False + @classmethod + def populate (cls, *a, **kwa): + obj = cls (*a, **kwa) + return obj + def export(self, outfile, level=1, namespace_='', name_='project-logical-router', namespacedef_='', pretty_print=True): + if pretty_print: + eol_ = '\n' + else: + eol_ = '' + showIndent(outfile, level, pretty_print) + outfile.write('<%s%s%s' % (namespace_, name_, namespacedef_ and ' ' + namespacedef_ or '', )) + already_processed = [] + self.exportAttributes(outfile, level, already_processed, namespace_, name_='project-logical-router') + if self.hasContent_(): + outfile.write('>%s' % (eol_, )) + self.exportChildren(outfile, level + 1, namespace_, name_, pretty_print=pretty_print) + outfile.write('</%s%s>%s' % (namespace_, name_, eol_)) + else: + outfile.write('/>%s' % (eol_, )) + def exportAttributes(self, outfile, level, already_processed, namespace_='', name_='project-logical-router'): + pass + def exportChildren(self, outfile, level, namespace_='', name_='project-logical-router', fromsubclass_=False, pretty_print=True): + pass + def hasContent_(self): + if ( + + ): + return True + else: + return False + def exportLiteral(self, outfile, level, name_='project-logical-router'): + level += 1 + self.exportLiteralAttributes(outfile, level, [], name_) + if self.hasContent_(): + self.exportLiteralChildren(outfile, level, name_) + def exportLiteralAttributes(self, outfile, level, already_processed, name_): + pass + def exportLiteralChildren(self, outfile, level, name_): + pass + def exportDict(self, name_='project-logical-router'): + obj_json = json.dumps(self, default=lambda o: dict((k, v) for k, v in o.__dict__.iteritems())) + obj_dict = json.loads(obj_json) + return {name_: obj_dict} + def build(self, node): + self.buildAttributes(node, node.attrib, []) + for child in node: + nodeName_ = Tag_pattern_.match(child.tag).groups()[-1] + self.buildChildren(child, node, nodeName_) + def buildAttributes(self, node, attrs, already_processed): + pass + def buildChildren(self, child_, node, nodeName_, fromsubclass_=False): + pass +# end class project_logical_router + + +class logical_router_interface(GeneratedsSuper): + """ + logical_router_interface class definition from :doc:`vnc_cfg.xsd` + """ + subclass = None + superclass = None + def __init__(self, **kwargs): + pass + def factory(*args_, **kwargs_): + if logical_router_interface.subclass: + return logical_router_interface.subclass(*args_, **kwargs_) + else: + return logical_router_interface(*args_, **kwargs_) + factory = staticmethod(factory) + def __eq__(self, other): return True + def __ne__(self, other): return False + @classmethod + def populate (cls, *a, **kwa): + obj = cls (*a, **kwa) + return obj + def export(self, outfile, level=1, namespace_='', name_='logical-router-interface', namespacedef_='', pretty_print=True): + if pretty_print: + eol_ = '\n' + else: + eol_ = '' + showIndent(outfile, level, pretty_print) + outfile.write('<%s%s%s' % (namespace_, name_, namespacedef_ and ' ' + namespacedef_ or '', )) + already_processed = [] + self.exportAttributes(outfile, level, already_processed, namespace_, name_='logical-router-interface') + if self.hasContent_(): + outfile.write('>%s' % (eol_, )) + self.exportChildren(outfile, level + 1, namespace_, name_, pretty_print=pretty_print) + outfile.write('</%s%s>%s' % (namespace_, name_, eol_)) + else: + outfile.write('/>%s' % (eol_, )) + def exportAttributes(self, outfile, level, already_processed, namespace_='', name_='logical-router-interface'): + pass + def exportChildren(self, outfile, level, namespace_='', name_='logical-router-interface', fromsubclass_=False, pretty_print=True): + pass + def hasContent_(self): + if ( + + ): + return True + else: + return False + def exportLiteral(self, outfile, level, name_='logical-router-interface'): + level += 1 + self.exportLiteralAttributes(outfile, level, [], name_) + if self.hasContent_(): + self.exportLiteralChildren(outfile, level, name_) + def exportLiteralAttributes(self, outfile, level, already_processed, name_): + pass + def exportLiteralChildren(self, outfile, level, name_): + pass + def exportDict(self, name_='logical-router-interface'): + obj_json = json.dumps(self, default=lambda o: dict((k, v) for k, v in o.__dict__.iteritems())) + obj_dict = json.loads(obj_json) + return {name_: obj_dict} + def build(self, node): + self.buildAttributes(node, node.attrib, []) + for child in node: + nodeName_ = Tag_pattern_.match(child.tag).groups()[-1] + self.buildChildren(child, node, nodeName_) + def buildAttributes(self, node, attrs, already_processed): + pass + def buildChildren(self, child_, node, nodeName_, fromsubclass_=False): + pass +# end class logical_router_interface + + +class logical_router_target(GeneratedsSuper): + """ + logical_router_target class definition from :doc:`vnc_cfg.xsd` + """ + subclass = None + superclass = None + def __init__(self, **kwargs): + pass + def factory(*args_, **kwargs_): + if logical_router_target.subclass: + return logical_router_target.subclass(*args_, **kwargs_) + else: + return logical_router_target(*args_, **kwargs_) + factory = staticmethod(factory) + def __eq__(self, other): return True + def __ne__(self, other): return False + @classmethod + def populate (cls, *a, **kwa): + obj = cls (*a, **kwa) + return obj + def export(self, outfile, level=1, namespace_='', name_='logical-router-target', namespacedef_='', pretty_print=True): + if pretty_print: + eol_ = '\n' + else: + eol_ = '' + showIndent(outfile, level, pretty_print) + outfile.write('<%s%s%s' % (namespace_, name_, namespacedef_ and ' ' + namespacedef_ or '', )) + already_processed = [] + self.exportAttributes(outfile, level, already_processed, namespace_, name_='logical-router-target') + if self.hasContent_(): + outfile.write('>%s' % (eol_, )) + self.exportChildren(outfile, level + 1, namespace_, name_, pretty_print=pretty_print) + outfile.write('</%s%s>%s' % (namespace_, name_, eol_)) + else: + outfile.write('/>%s' % (eol_, )) + def exportAttributes(self, outfile, level, already_processed, namespace_='', name_='logical-router-target'): + pass + def exportChildren(self, outfile, level, namespace_='', name_='logical-router-target', fromsubclass_=False, pretty_print=True): + pass + def hasContent_(self): + if ( + + ): + return True + else: + return False + def exportLiteral(self, outfile, level, name_='logical-router-target'): + level += 1 + self.exportLiteralAttributes(outfile, level, [], name_) + if self.hasContent_(): + self.exportLiteralChildren(outfile, level, name_) + def exportLiteralAttributes(self, outfile, level, already_processed, name_): + pass + def exportLiteralChildren(self, outfile, level, name_): + pass + def exportDict(self, name_='logical-router-target'): + obj_json = json.dumps(self, default=lambda o: dict((k, v) for k, v in o.__dict__.iteritems())) + obj_dict = json.loads(obj_json) + return {name_: obj_dict} + def build(self, node): + self.buildAttributes(node, node.attrib, []) + for child in node: + nodeName_ = Tag_pattern_.match(child.tag).groups()[-1] + self.buildChildren(child, node, nodeName_) + def buildAttributes(self, node, attrs, already_processed): + pass + def buildChildren(self, child_, node, nodeName_, fromsubclass_=False): + pass +# end class logical_router_target + + +class logical_router_gateway(GeneratedsSuper): + """ + logical_router_gateway class definition from :doc:`vnc_cfg.xsd` + """ + subclass = None + superclass = None + def __init__(self, **kwargs): + pass + def factory(*args_, **kwargs_): + if logical_router_gateway.subclass: + return logical_router_gateway.subclass(*args_, **kwargs_) + else: + return logical_router_gateway(*args_, **kwargs_) + factory = staticmethod(factory) + def __eq__(self, other): return True + def __ne__(self, other): return False + @classmethod + def populate (cls, *a, **kwa): + obj = cls (*a, **kwa) + return obj + def export(self, outfile, level=1, namespace_='', name_='logical-router-gateway', namespacedef_='', pretty_print=True): + if pretty_print: + eol_ = '\n' + else: + eol_ = '' + showIndent(outfile, level, pretty_print) + outfile.write('<%s%s%s' % (namespace_, name_, namespacedef_ and ' ' + namespacedef_ or '', )) + already_processed = [] + self.exportAttributes(outfile, level, already_processed, namespace_, name_='logical-router-gateway') + if self.hasContent_(): + outfile.write('>%s' % (eol_, )) + self.exportChildren(outfile, level + 1, namespace_, name_, pretty_print=pretty_print) + outfile.write('</%s%s>%s' % (namespace_, name_, eol_)) + else: + outfile.write('/>%s' % (eol_, )) + def exportAttributes(self, outfile, level, already_processed, namespace_='', name_='logical-router-gateway'): + pass + def exportChildren(self, outfile, level, namespace_='', name_='logical-router-gateway', fromsubclass_=False, pretty_print=True): + pass + def hasContent_(self): + if ( + + ): + return True + else: + return False + def exportLiteral(self, outfile, level, name_='logical-router-gateway'): + level += 1 + self.exportLiteralAttributes(outfile, level, [], name_) + if self.hasContent_(): + self.exportLiteralChildren(outfile, level, name_) + def exportLiteralAttributes(self, outfile, level, already_processed, name_): + pass + def exportLiteralChildren(self, outfile, level, name_): + pass + def exportDict(self, name_='logical-router-gateway'): + obj_json = json.dumps(self, default=lambda o: dict((k, v) for k, v in o.__dict__.iteritems())) + obj_dict = json.loads(obj_json) + return {name_: obj_dict} + def build(self, node): + self.buildAttributes(node, node.attrib, []) + for child in node: + nodeName_ = Tag_pattern_.match(child.tag).groups()[-1] + self.buildChildren(child, node, nodeName_) + def buildAttributes(self, node, attrs, already_processed): + pass + def buildChildren(self, child_, node, nodeName_, fromsubclass_=False): + pass +# end class logical_router_gateway + + +class logical_router_service_instance(GeneratedsSuper): + """ + logical_router_service_instance class definition from :doc:`vnc_cfg.xsd` + """ + subclass = None + superclass = None + def __init__(self, **kwargs): + pass + def factory(*args_, **kwargs_): + if logical_router_service_instance.subclass: + return logical_router_service_instance.subclass(*args_, **kwargs_) + else: + return logical_router_service_instance(*args_, **kwargs_) + factory = staticmethod(factory) + def __eq__(self, other): return True + def __ne__(self, other): return False + @classmethod + def populate (cls, *a, **kwa): + obj = cls (*a, **kwa) + return obj + def export(self, outfile, level=1, namespace_='', name_='logical-router-service-instance', namespacedef_='', pretty_print=True): + if pretty_print: + eol_ = '\n' + else: + eol_ = '' + showIndent(outfile, level, pretty_print) + outfile.write('<%s%s%s' % (namespace_, name_, namespacedef_ and ' ' + namespacedef_ or '', )) + already_processed = [] + self.exportAttributes(outfile, level, already_processed, namespace_, name_='logical-router-service-instance') + if self.hasContent_(): + outfile.write('>%s' % (eol_, )) + self.exportChildren(outfile, level + 1, namespace_, name_, pretty_print=pretty_print) + outfile.write('</%s%s>%s' % (namespace_, name_, eol_)) + else: + outfile.write('/>%s' % (eol_, )) + def exportAttributes(self, outfile, level, already_processed, namespace_='', name_='logical-router-service-instance'): + pass + def exportChildren(self, outfile, level, namespace_='', name_='logical-router-service-instance', fromsubclass_=False, pretty_print=True): + pass + def hasContent_(self): + if ( + + ): + return True + else: + return False + def exportLiteral(self, outfile, level, name_='logical-router-service-instance'): + level += 1 + self.exportLiteralAttributes(outfile, level, [], name_) + if self.hasContent_(): + self.exportLiteralChildren(outfile, level, name_) + def exportLiteralAttributes(self, outfile, level, already_processed, name_): + pass + def exportLiteralChildren(self, outfile, level, name_): + pass + def exportDict(self, name_='logical-router-service-instance'): + obj_json = json.dumps(self, default=lambda o: dict((k, v) for k, v in o.__dict__.iteritems())) + obj_dict = json.loads(obj_json) + return {name_: obj_dict} + def build(self, node): + self.buildAttributes(node, node.attrib, []) + for child in node: + nodeName_ = Tag_pattern_.match(child.tag).groups()[-1] + self.buildChildren(child, node, nodeName_) + def buildAttributes(self, node, attrs, already_processed): + pass + def buildChildren(self, child_, node, nodeName_, fromsubclass_=False): + pass +# end class logical_router_service_instance + + +class global_system_config_config_node(GeneratedsSuper): + """ + global_system_config_config_node class definition from :doc:`vnc_cfg.xsd` + """ + subclass = None + superclass = None + def __init__(self, **kwargs): + pass + def factory(*args_, **kwargs_): + if global_system_config_config_node.subclass: + return global_system_config_config_node.subclass(*args_, **kwargs_) + else: + return global_system_config_config_node(*args_, **kwargs_) + factory = staticmethod(factory) + def __eq__(self, other): return True + def __ne__(self, other): return False + @classmethod + def populate (cls, *a, **kwa): + obj = cls (*a, **kwa) + return obj + def export(self, outfile, level=1, namespace_='', name_='global-system-config-config-node', namespacedef_='', pretty_print=True): + if pretty_print: + eol_ = '\n' + else: + eol_ = '' + showIndent(outfile, level, pretty_print) + outfile.write('<%s%s%s' % (namespace_, name_, namespacedef_ and ' ' + namespacedef_ or '', )) + already_processed = [] + self.exportAttributes(outfile, level, already_processed, namespace_, name_='global-system-config-config-node') + if self.hasContent_(): + outfile.write('>%s' % (eol_, )) + self.exportChildren(outfile, level + 1, namespace_, name_, pretty_print=pretty_print) + outfile.write('</%s%s>%s' % (namespace_, name_, eol_)) + else: + outfile.write('/>%s' % (eol_, )) + def exportAttributes(self, outfile, level, already_processed, namespace_='', name_='global-system-config-config-node'): + pass + def exportChildren(self, outfile, level, namespace_='', name_='global-system-config-config-node', fromsubclass_=False, pretty_print=True): + pass + def hasContent_(self): + if ( + + ): + return True + else: + return False + def exportLiteral(self, outfile, level, name_='global-system-config-config-node'): + level += 1 + self.exportLiteralAttributes(outfile, level, [], name_) + if self.hasContent_(): + self.exportLiteralChildren(outfile, level, name_) + def exportLiteralAttributes(self, outfile, level, already_processed, name_): + pass + def exportLiteralChildren(self, outfile, level, name_): + pass + def exportDict(self, name_='global-system-config-config-node'): + obj_json = json.dumps(self, default=lambda o: dict((k, v) for k, v in o.__dict__.iteritems())) + obj_dict = json.loads(obj_json) + return {name_: obj_dict} + def build(self, node): + self.buildAttributes(node, node.attrib, []) + for child in node: + nodeName_ = Tag_pattern_.match(child.tag).groups()[-1] + self.buildChildren(child, node, nodeName_) + def buildAttributes(self, node, attrs, already_processed): + pass + def buildChildren(self, child_, node, nodeName_, fromsubclass_=False): + pass +# end class global_system_config_config_node + + +class global_system_config_analytics_node(GeneratedsSuper): + """ + global_system_config_analytics_node class definition from :doc:`vnc_cfg.xsd` + """ + subclass = None + superclass = None + def __init__(self, **kwargs): + pass + def factory(*args_, **kwargs_): + if global_system_config_analytics_node.subclass: + return global_system_config_analytics_node.subclass(*args_, **kwargs_) + else: + return global_system_config_analytics_node(*args_, **kwargs_) + factory = staticmethod(factory) + def __eq__(self, other): return True + def __ne__(self, other): return False + @classmethod + def populate (cls, *a, **kwa): + obj = cls (*a, **kwa) + return obj + def export(self, outfile, level=1, namespace_='', name_='global-system-config-analytics-node', namespacedef_='', pretty_print=True): + if pretty_print: + eol_ = '\n' + else: + eol_ = '' + showIndent(outfile, level, pretty_print) + outfile.write('<%s%s%s' % (namespace_, name_, namespacedef_ and ' ' + namespacedef_ or '', )) + already_processed = [] + self.exportAttributes(outfile, level, already_processed, namespace_, name_='global-system-config-analytics-node') + if self.hasContent_(): + outfile.write('>%s' % (eol_, )) + self.exportChildren(outfile, level + 1, namespace_, name_, pretty_print=pretty_print) + outfile.write('</%s%s>%s' % (namespace_, name_, eol_)) + else: + outfile.write('/>%s' % (eol_, )) + def exportAttributes(self, outfile, level, already_processed, namespace_='', name_='global-system-config-analytics-node'): + pass + def exportChildren(self, outfile, level, namespace_='', name_='global-system-config-analytics-node', fromsubclass_=False, pretty_print=True): + pass + def hasContent_(self): + if ( + + ): + return True + else: + return False + def exportLiteral(self, outfile, level, name_='global-system-config-analytics-node'): + level += 1 + self.exportLiteralAttributes(outfile, level, [], name_) + if self.hasContent_(): + self.exportLiteralChildren(outfile, level, name_) + def exportLiteralAttributes(self, outfile, level, already_processed, name_): + pass + def exportLiteralChildren(self, outfile, level, name_): + pass + def exportDict(self, name_='global-system-config-analytics-node'): + obj_json = json.dumps(self, default=lambda o: dict((k, v) for k, v in o.__dict__.iteritems())) + obj_dict = json.loads(obj_json) + return {name_: obj_dict} + def build(self, node): + self.buildAttributes(node, node.attrib, []) + for child in node: + nodeName_ = Tag_pattern_.match(child.tag).groups()[-1] + self.buildChildren(child, node, nodeName_) + def buildAttributes(self, node, attrs, already_processed): + pass + def buildChildren(self, child_, node, nodeName_, fromsubclass_=False): + pass +# end class global_system_config_analytics_node + + +class global_system_config_database_node(GeneratedsSuper): + """ + global_system_config_database_node class definition from :doc:`vnc_cfg.xsd` + """ + subclass = None + superclass = None + def __init__(self, **kwargs): + pass + def factory(*args_, **kwargs_): + if global_system_config_database_node.subclass: + return global_system_config_database_node.subclass(*args_, **kwargs_) + else: + return global_system_config_database_node(*args_, **kwargs_) + factory = staticmethod(factory) + def __eq__(self, other): return True + def __ne__(self, other): return False + @classmethod + def populate (cls, *a, **kwa): + obj = cls (*a, **kwa) + return obj + def export(self, outfile, level=1, namespace_='', name_='global-system-config-database-node', namespacedef_='', pretty_print=True): + if pretty_print: + eol_ = '\n' + else: + eol_ = '' + showIndent(outfile, level, pretty_print) + outfile.write('<%s%s%s' % (namespace_, name_, namespacedef_ and ' ' + namespacedef_ or '', )) + already_processed = [] + self.exportAttributes(outfile, level, already_processed, namespace_, name_='global-system-config-database-node') + if self.hasContent_(): + outfile.write('>%s' % (eol_, )) + self.exportChildren(outfile, level + 1, namespace_, name_, pretty_print=pretty_print) + outfile.write('</%s%s>%s' % (namespace_, name_, eol_)) + else: + outfile.write('/>%s' % (eol_, )) + def exportAttributes(self, outfile, level, already_processed, namespace_='', name_='global-system-config-database-node'): + pass + def exportChildren(self, outfile, level, namespace_='', name_='global-system-config-database-node', fromsubclass_=False, pretty_print=True): + pass + def hasContent_(self): + if ( + + ): + return True + else: + return False + def exportLiteral(self, outfile, level, name_='global-system-config-database-node'): + level += 1 + self.exportLiteralAttributes(outfile, level, [], name_) + if self.hasContent_(): + self.exportLiteralChildren(outfile, level, name_) + def exportLiteralAttributes(self, outfile, level, already_processed, name_): + pass + def exportLiteralChildren(self, outfile, level, name_): + pass + def exportDict(self, name_='global-system-config-database-node'): + obj_json = json.dumps(self, default=lambda o: dict((k, v) for k, v in o.__dict__.iteritems())) + obj_dict = json.loads(obj_json) + return {name_: obj_dict} + def build(self, node): + self.buildAttributes(node, node.attrib, []) + for child in node: + nodeName_ = Tag_pattern_.match(child.tag).groups()[-1] + self.buildChildren(child, node, nodeName_) + def buildAttributes(self, node, attrs, already_processed): + pass + def buildChildren(self, child_, node, nodeName_, fromsubclass_=False): + pass +# end class global_system_config_database_node + + +class KeyValuePair(GeneratedsSuper): + """ + KeyValuePair class definition from :doc:`vnc_cfg.xsd` + """ + subclass = None + superclass = None + def __init__(self, key=None, value=None, **kwargs): + self.key = key + self.value = value + def factory(*args_, **kwargs_): + if KeyValuePair.subclass: + return KeyValuePair.subclass(*args_, **kwargs_) + else: + return KeyValuePair(*args_, **kwargs_) + factory = staticmethod(factory) + def get_key(self): return self.key + def set_key(self, key): self.key = key + def get_value(self): return self.value + def set_value(self, value): self.value = value + def __eq__(self, other): + if isinstance(other, self.__class__): + return (self.key == other.key and + self.value == other.value) + return NotImplemented + def __ne__(self, other): + if isinstance(other, self.__class__): + return not self.__eq__(other) + return NotImplemented + + @classmethod + def populate (cls, *a, **kwa): + obj = cls (*a, **kwa) + obj.set_key (obj.populate_string ("key")) + obj.set_value (obj.populate_string ("value")) + return obj + def export(self, outfile, level=1, namespace_='', name_='KeyValuePair', namespacedef_='', pretty_print=True): + if pretty_print: + eol_ = '\n' + else: + eol_ = '' + showIndent(outfile, level, pretty_print) + outfile.write('<%s%s%s' % (namespace_, name_, namespacedef_ and ' ' + namespacedef_ or '', )) + already_processed = [] + self.exportAttributes(outfile, level, already_processed, namespace_, name_='KeyValuePair') + if self.hasContent_(): + outfile.write('>%s' % (eol_, )) + self.exportChildren(outfile, level + 1, namespace_, name_, pretty_print=pretty_print) + showIndent(outfile, level, pretty_print) + outfile.write('</%s%s>%s' % (namespace_, name_, eol_)) + else: + outfile.write('/>%s' % (eol_, )) + def exportAttributes(self, outfile, level, already_processed, namespace_='', name_='KeyValuePair'): + pass + def exportChildren(self, outfile, level, namespace_='', name_='KeyValuePair', fromsubclass_=False, pretty_print=True): + if pretty_print: + eol_ = '\n' + else: + eol_ = '' + if self.key is not None: + showIndent(outfile, level, pretty_print) + outfile.write('<%skey>%s</%skey>%s' % (namespace_, self.gds_format_string(quote_xml(self.key).encode(ExternalEncoding), input_name='key'), namespace_, eol_)) + if self.value is not None: + showIndent(outfile, level, pretty_print) + outfile.write('<%svalue>%s</%svalue>%s' % (namespace_, self.gds_format_string(quote_xml(self.value).encode(ExternalEncoding), input_name='value'), namespace_, eol_)) + def hasContent_(self): + if ( + self.key is not None or + self.value is not None + ): + return True + else: + return False + def exportLiteral(self, outfile, level, name_='KeyValuePair'): + level += 1 + self.exportLiteralAttributes(outfile, level, [], name_) + if self.hasContent_(): + self.exportLiteralChildren(outfile, level, name_) + def exportLiteralAttributes(self, outfile, level, already_processed, name_): + pass + def exportLiteralChildren(self, outfile, level, name_): + if self.key is not None: + showIndent(outfile, level) + outfile.write('key=%s,\n' % quote_python(self.key).encode(ExternalEncoding)) + if self.value is not None: + showIndent(outfile, level) + outfile.write('value=%s,\n' % quote_python(self.value).encode(ExternalEncoding)) + def exportDict(self, name_='KeyValuePair'): + obj_json = json.dumps(self, default=lambda o: dict((k, v) for k, v in o.__dict__.iteritems())) + obj_dict = json.loads(obj_json) + return {name_: obj_dict} + def build(self, node): + self.buildAttributes(node, node.attrib, []) + for child in node: + nodeName_ = Tag_pattern_.match(child.tag).groups()[-1] + self.buildChildren(child, node, nodeName_) + def buildAttributes(self, node, attrs, already_processed): + pass + def buildChildren(self, child_, node, nodeName_, fromsubclass_=False): + if nodeName_ == 'key': + key_ = child_.text + key_ = self.gds_validate_string(key_, node, 'key') + self.key = key_ + elif nodeName_ == 'value': + value_ = child_.text + value_ = self.gds_validate_string(value_, node, 'value') + self.value = value_ +# end class KeyValuePair + + +class KeyValuePairs(GeneratedsSuper): + """ + KeyValuePairs class definition from :doc:`vnc_cfg.xsd` + """ + subclass = None + superclass = None + def __init__(self, key_value_pair=None, **kwargs): + if (key_value_pair is None) or (key_value_pair == []): + self.key_value_pair = [] + else: + if isinstance(key_value_pair[0], dict): + objs = [KeyValuePair(**elem) for elem in key_value_pair] + self.key_value_pair = objs + else: + self.key_value_pair = key_value_pair + def factory(*args_, **kwargs_): + if KeyValuePairs.subclass: + return KeyValuePairs.subclass(*args_, **kwargs_) + else: + return KeyValuePairs(*args_, **kwargs_) + factory = staticmethod(factory) + def get_key_value_pair(self): return self.key_value_pair + def set_key_value_pair(self, key_value_pair): self.key_value_pair = key_value_pair + def add_key_value_pair(self, value): self.key_value_pair.append(value) + def insert_key_value_pair(self, index, value): self.key_value_pair[index] = value + def delete_key_value_pair(self, value): self.key_value_pair.remove(value) + def __eq__(self, other): + if isinstance(other, self.__class__): + return (self.key_value_pair == other.key_value_pair) + return NotImplemented + def __ne__(self, other): + if isinstance(other, self.__class__): + return not self.__eq__(other) + return NotImplemented + + @classmethod + def populate (cls, *a, **kwa): + obj = cls (*a, **kwa) + obj.set_key_value_pair ([KeyValuePair.populate ()]) + return obj + def export(self, outfile, level=1, namespace_='', name_='KeyValuePairs', namespacedef_='', pretty_print=True): + if pretty_print: + eol_ = '\n' + else: + eol_ = '' + showIndent(outfile, level, pretty_print) + outfile.write('<%s%s%s' % (namespace_, name_, namespacedef_ and ' ' + namespacedef_ or '', )) + already_processed = [] + self.exportAttributes(outfile, level, already_processed, namespace_, name_='KeyValuePairs') + if self.hasContent_(): + outfile.write('>%s' % (eol_, )) + self.exportChildren(outfile, level + 1, namespace_, name_, pretty_print=pretty_print) + showIndent(outfile, level, pretty_print) + outfile.write('</%s%s>%s' % (namespace_, name_, eol_)) + else: + outfile.write('/>%s' % (eol_, )) + def exportAttributes(self, outfile, level, already_processed, namespace_='', name_='KeyValuePairs'): + pass + def exportChildren(self, outfile, level, namespace_='', name_='KeyValuePairs', fromsubclass_=False, pretty_print=True): + if pretty_print: + eol_ = '\n' + else: + eol_ = '' + for key_value_pair_ in self.key_value_pair: + if isinstance(key_value_pair_, dict): + key_value_pair_ = KeyValuePair(**key_value_pair_) + key_value_pair_.export(outfile, level, namespace_, name_='key-value-pair', pretty_print=pretty_print) + def hasContent_(self): + if ( + self.key_value_pair + ): + return True + else: + return False + def exportLiteral(self, outfile, level, name_='KeyValuePairs'): + level += 1 + self.exportLiteralAttributes(outfile, level, [], name_) + if self.hasContent_(): + self.exportLiteralChildren(outfile, level, name_) + def exportLiteralAttributes(self, outfile, level, already_processed, name_): + pass + def exportLiteralChildren(self, outfile, level, name_): + showIndent(outfile, level) + outfile.write('key_value_pair=[\n') + level += 1 + for key_value_pair_ in self.key_value_pair: + showIndent(outfile, level) + outfile.write('model_.KeyValuePair(\n') + key_value_pair_.exportLiteral(outfile, level, name_='KeyValuePair') + showIndent(outfile, level) + outfile.write('),\n') + level -= 1 + showIndent(outfile, level) + outfile.write('],\n') + def exportDict(self, name_='KeyValuePairs'): + obj_json = json.dumps(self, default=lambda o: dict((k, v) for k, v in o.__dict__.iteritems())) + obj_dict = json.loads(obj_json) + return {name_: obj_dict} + def build(self, node): + self.buildAttributes(node, node.attrib, []) + for child in node: + nodeName_ = Tag_pattern_.match(child.tag).groups()[-1] + self.buildChildren(child, node, nodeName_) + def buildAttributes(self, node, attrs, already_processed): + pass + def buildChildren(self, child_, node, nodeName_, fromsubclass_=False): + if nodeName_ == 'key-value-pair': + obj_ = KeyValuePair.factory() + obj_.build(child_) + self.key_value_pair.append(obj_) +# end class KeyValuePairs + + +class global_system_config_service_appliance_set(GeneratedsSuper): + """ + global_system_config_service_appliance_set class definition from :doc:`vnc_cfg.xsd` + """ + subclass = None + superclass = None + def __init__(self, **kwargs): + pass + def factory(*args_, **kwargs_): + if global_system_config_service_appliance_set.subclass: + return global_system_config_service_appliance_set.subclass(*args_, **kwargs_) + else: + return global_system_config_service_appliance_set(*args_, **kwargs_) + factory = staticmethod(factory) + def __eq__(self, other): return True + def __ne__(self, other): return False + @classmethod + def populate (cls, *a, **kwa): + obj = cls (*a, **kwa) + return obj + def export(self, outfile, level=1, namespace_='', name_='global-system-config-service-appliance-set', namespacedef_='', pretty_print=True): + if pretty_print: + eol_ = '\n' + else: + eol_ = '' + showIndent(outfile, level, pretty_print) + outfile.write('<%s%s%s' % (namespace_, name_, namespacedef_ and ' ' + namespacedef_ or '', )) + already_processed = [] + self.exportAttributes(outfile, level, already_processed, namespace_, name_='global-system-config-service-appliance-set') + if self.hasContent_(): + outfile.write('>%s' % (eol_, )) + self.exportChildren(outfile, level + 1, namespace_, name_, pretty_print=pretty_print) + outfile.write('</%s%s>%s' % (namespace_, name_, eol_)) + else: + outfile.write('/>%s' % (eol_, )) + def exportAttributes(self, outfile, level, already_processed, namespace_='', name_='global-system-config-service-appliance-set'): + pass + def exportChildren(self, outfile, level, namespace_='', name_='global-system-config-service-appliance-set', fromsubclass_=False, pretty_print=True): + pass + def hasContent_(self): + if ( + + ): + return True + else: + return False + def exportLiteral(self, outfile, level, name_='global-system-config-service-appliance-set'): + level += 1 + self.exportLiteralAttributes(outfile, level, [], name_) + if self.hasContent_(): + self.exportLiteralChildren(outfile, level, name_) + def exportLiteralAttributes(self, outfile, level, already_processed, name_): + pass + def exportLiteralChildren(self, outfile, level, name_): + pass + def exportDict(self, name_='global-system-config-service-appliance-set'): + obj_json = json.dumps(self, default=lambda o: dict((k, v) for k, v in o.__dict__.iteritems())) + obj_dict = json.loads(obj_json) + return {name_: obj_dict} + def build(self, node): + self.buildAttributes(node, node.attrib, []) + for child in node: + nodeName_ = Tag_pattern_.match(child.tag).groups()[-1] + self.buildChildren(child, node, nodeName_) + def buildAttributes(self, node, attrs, already_processed): + pass + def buildChildren(self, child_, node, nodeName_, fromsubclass_=False): + pass +# end class global_system_config_service_appliance_set + + +class service_appliance_set_service_appliance(GeneratedsSuper): + """ + service_appliance_set_service_appliance class definition from :doc:`vnc_cfg.xsd` + """ + subclass = None + superclass = None + def __init__(self, **kwargs): + pass + def factory(*args_, **kwargs_): + if service_appliance_set_service_appliance.subclass: + return service_appliance_set_service_appliance.subclass(*args_, **kwargs_) + else: + return service_appliance_set_service_appliance(*args_, **kwargs_) + factory = staticmethod(factory) + def __eq__(self, other): return True + def __ne__(self, other): return False + @classmethod + def populate (cls, *a, **kwa): + obj = cls (*a, **kwa) + return obj + def export(self, outfile, level=1, namespace_='', name_='service-appliance-set-service-appliance', namespacedef_='', pretty_print=True): + if pretty_print: + eol_ = '\n' + else: + eol_ = '' + showIndent(outfile, level, pretty_print) + outfile.write('<%s%s%s' % (namespace_, name_, namespacedef_ and ' ' + namespacedef_ or '', )) + already_processed = [] + self.exportAttributes(outfile, level, already_processed, namespace_, name_='service-appliance-set-service-appliance') + if self.hasContent_(): + outfile.write('>%s' % (eol_, )) + self.exportChildren(outfile, level + 1, namespace_, name_, pretty_print=pretty_print) + outfile.write('</%s%s>%s' % (namespace_, name_, eol_)) + else: + outfile.write('/>%s' % (eol_, )) + def exportAttributes(self, outfile, level, already_processed, namespace_='', name_='service-appliance-set-service-appliance'): + pass + def exportChildren(self, outfile, level, namespace_='', name_='service-appliance-set-service-appliance', fromsubclass_=False, pretty_print=True): + pass + def hasContent_(self): + if ( + + ): + return True + else: + return False + def exportLiteral(self, outfile, level, name_='service-appliance-set-service-appliance'): + level += 1 + self.exportLiteralAttributes(outfile, level, [], name_) + if self.hasContent_(): + self.exportLiteralChildren(outfile, level, name_) + def exportLiteralAttributes(self, outfile, level, already_processed, name_): + pass + def exportLiteralChildren(self, outfile, level, name_): + pass + def exportDict(self, name_='service-appliance-set-service-appliance'): + obj_json = json.dumps(self, default=lambda o: dict((k, v) for k, v in o.__dict__.iteritems())) + obj_dict = json.loads(obj_json) + return {name_: obj_dict} + def build(self, node): + self.buildAttributes(node, node.attrib, []) + for child in node: + nodeName_ = Tag_pattern_.match(child.tag).groups()[-1] + self.buildChildren(child, node, nodeName_) + def buildAttributes(self, node, attrs, already_processed): + pass + def buildChildren(self, child_, node, nodeName_, fromsubclass_=False): + pass +# end class service_appliance_set_service_appliance + + +class project_loadbalancer_pool(GeneratedsSuper): + """ + project_loadbalancer_pool class definition from :doc:`vnc_cfg.xsd` + """ + subclass = None + superclass = None + def __init__(self, **kwargs): + pass + def factory(*args_, **kwargs_): + if project_loadbalancer_pool.subclass: + return project_loadbalancer_pool.subclass(*args_, **kwargs_) + else: + return project_loadbalancer_pool(*args_, **kwargs_) + factory = staticmethod(factory) + def __eq__(self, other): return True + def __ne__(self, other): return False + @classmethod + def populate (cls, *a, **kwa): + obj = cls (*a, **kwa) + return obj + def export(self, outfile, level=1, namespace_='', name_='project-loadbalancer-pool', namespacedef_='', pretty_print=True): + if pretty_print: + eol_ = '\n' + else: + eol_ = '' + showIndent(outfile, level, pretty_print) + outfile.write('<%s%s%s' % (namespace_, name_, namespacedef_ and ' ' + namespacedef_ or '', )) + already_processed = [] + self.exportAttributes(outfile, level, already_processed, namespace_, name_='project-loadbalancer-pool') + if self.hasContent_(): + outfile.write('>%s' % (eol_, )) + self.exportChildren(outfile, level + 1, namespace_, name_, pretty_print=pretty_print) + outfile.write('</%s%s>%s' % (namespace_, name_, eol_)) + else: + outfile.write('/>%s' % (eol_, )) + def exportAttributes(self, outfile, level, already_processed, namespace_='', name_='project-loadbalancer-pool'): + pass + def exportChildren(self, outfile, level, namespace_='', name_='project-loadbalancer-pool', fromsubclass_=False, pretty_print=True): + pass + def hasContent_(self): + if ( + + ): + return True + else: + return False + def exportLiteral(self, outfile, level, name_='project-loadbalancer-pool'): + level += 1 + self.exportLiteralAttributes(outfile, level, [], name_) + if self.hasContent_(): + self.exportLiteralChildren(outfile, level, name_) + def exportLiteralAttributes(self, outfile, level, already_processed, name_): + pass + def exportLiteralChildren(self, outfile, level, name_): + pass + def exportDict(self, name_='project-loadbalancer-pool'): + obj_json = json.dumps(self, default=lambda o: dict((k, v) for k, v in o.__dict__.iteritems())) + obj_dict = json.loads(obj_json) + return {name_: obj_dict} + def build(self, node): + self.buildAttributes(node, node.attrib, []) + for child in node: + nodeName_ = Tag_pattern_.match(child.tag).groups()[-1] + self.buildChildren(child, node, nodeName_) + def buildAttributes(self, node, attrs, already_processed): + pass + def buildChildren(self, child_, node, nodeName_, fromsubclass_=False): + pass +# end class project_loadbalancer_pool + + +class loadbalancer_pool_service_instance(GeneratedsSuper): + """ + loadbalancer_pool_service_instance class definition from :doc:`vnc_cfg.xsd` + """ + subclass = None + superclass = None + def __init__(self, **kwargs): + pass + def factory(*args_, **kwargs_): + if loadbalancer_pool_service_instance.subclass: + return loadbalancer_pool_service_instance.subclass(*args_, **kwargs_) + else: + return loadbalancer_pool_service_instance(*args_, **kwargs_) + factory = staticmethod(factory) + def __eq__(self, other): return True + def __ne__(self, other): return False + @classmethod + def populate (cls, *a, **kwa): + obj = cls (*a, **kwa) + return obj + def export(self, outfile, level=1, namespace_='', name_='loadbalancer-pool-service-instance', namespacedef_='', pretty_print=True): + if pretty_print: + eol_ = '\n' + else: + eol_ = '' + showIndent(outfile, level, pretty_print) + outfile.write('<%s%s%s' % (namespace_, name_, namespacedef_ and ' ' + namespacedef_ or '', )) + already_processed = [] + self.exportAttributes(outfile, level, already_processed, namespace_, name_='loadbalancer-pool-service-instance') + if self.hasContent_(): + outfile.write('>%s' % (eol_, )) + self.exportChildren(outfile, level + 1, namespace_, name_, pretty_print=pretty_print) + outfile.write('</%s%s>%s' % (namespace_, name_, eol_)) + else: + outfile.write('/>%s' % (eol_, )) + def exportAttributes(self, outfile, level, already_processed, namespace_='', name_='loadbalancer-pool-service-instance'): + pass + def exportChildren(self, outfile, level, namespace_='', name_='loadbalancer-pool-service-instance', fromsubclass_=False, pretty_print=True): + pass + def hasContent_(self): + if ( + + ): + return True + else: + return False + def exportLiteral(self, outfile, level, name_='loadbalancer-pool-service-instance'): + level += 1 + self.exportLiteralAttributes(outfile, level, [], name_) + if self.hasContent_(): + self.exportLiteralChildren(outfile, level, name_) + def exportLiteralAttributes(self, outfile, level, already_processed, name_): + pass + def exportLiteralChildren(self, outfile, level, name_): + pass + def exportDict(self, name_='loadbalancer-pool-service-instance'): + obj_json = json.dumps(self, default=lambda o: dict((k, v) for k, v in o.__dict__.iteritems())) + obj_dict = json.loads(obj_json) + return {name_: obj_dict} + def build(self, node): + self.buildAttributes(node, node.attrib, []) + for child in node: + nodeName_ = Tag_pattern_.match(child.tag).groups()[-1] + self.buildChildren(child, node, nodeName_) + def buildAttributes(self, node, attrs, already_processed): + pass + def buildChildren(self, child_, node, nodeName_, fromsubclass_=False): + pass +# end class loadbalancer_pool_service_instance + + +class loadbalancer_pool_virtual_machine_interface(GeneratedsSuper): + """ + loadbalancer_pool_virtual_machine_interface class definition from :doc:`vnc_cfg.xsd` + """ + subclass = None + superclass = None + def __init__(self, **kwargs): + pass + def factory(*args_, **kwargs_): + if loadbalancer_pool_virtual_machine_interface.subclass: + return loadbalancer_pool_virtual_machine_interface.subclass(*args_, **kwargs_) + else: + return loadbalancer_pool_virtual_machine_interface(*args_, **kwargs_) + factory = staticmethod(factory) + def __eq__(self, other): return True + def __ne__(self, other): return False + @classmethod + def populate (cls, *a, **kwa): + obj = cls (*a, **kwa) + return obj + def export(self, outfile, level=1, namespace_='', name_='loadbalancer-pool-virtual-machine-interface', namespacedef_='', pretty_print=True): + if pretty_print: + eol_ = '\n' + else: + eol_ = '' + showIndent(outfile, level, pretty_print) + outfile.write('<%s%s%s' % (namespace_, name_, namespacedef_ and ' ' + namespacedef_ or '', )) + already_processed = [] + self.exportAttributes(outfile, level, already_processed, namespace_, name_='loadbalancer-pool-virtual-machine-interface') + if self.hasContent_(): + outfile.write('>%s' % (eol_, )) + self.exportChildren(outfile, level + 1, namespace_, name_, pretty_print=pretty_print) + outfile.write('</%s%s>%s' % (namespace_, name_, eol_)) + else: + outfile.write('/>%s' % (eol_, )) + def exportAttributes(self, outfile, level, already_processed, namespace_='', name_='loadbalancer-pool-virtual-machine-interface'): + pass + def exportChildren(self, outfile, level, namespace_='', name_='loadbalancer-pool-virtual-machine-interface', fromsubclass_=False, pretty_print=True): + pass + def hasContent_(self): + if ( + + ): + return True + else: + return False + def exportLiteral(self, outfile, level, name_='loadbalancer-pool-virtual-machine-interface'): + level += 1 + self.exportLiteralAttributes(outfile, level, [], name_) + if self.hasContent_(): + self.exportLiteralChildren(outfile, level, name_) + def exportLiteralAttributes(self, outfile, level, already_processed, name_): + pass + def exportLiteralChildren(self, outfile, level, name_): + pass + def exportDict(self, name_='loadbalancer-pool-virtual-machine-interface'): + obj_json = json.dumps(self, default=lambda o: dict((k, v) for k, v in o.__dict__.iteritems())) + obj_dict = json.loads(obj_json) + return {name_: obj_dict} + def build(self, node): + self.buildAttributes(node, node.attrib, []) + for child in node: + nodeName_ = Tag_pattern_.match(child.tag).groups()[-1] + self.buildChildren(child, node, nodeName_) + def buildAttributes(self, node, attrs, already_processed): + pass + def buildChildren(self, child_, node, nodeName_, fromsubclass_=False): + pass +# end class loadbalancer_pool_virtual_machine_interface + + +class LoadbalancerPoolType(GeneratedsSuper): + """ + LoadbalancerPoolType class definition from :doc:`vnc_cfg.xsd` + """ + subclass = None + superclass = None + def __init__(self, status=None, status_description=None, admin_state=True, protocol=None, loadbalancer_method=None, subnet_id=None, **kwargs): + self.status = status + self.status_description = status_description + self.admin_state = admin_state + self.protocol = protocol + self.loadbalancer_method = loadbalancer_method + self.subnet_id = subnet_id + def factory(*args_, **kwargs_): + if LoadbalancerPoolType.subclass: + return LoadbalancerPoolType.subclass(*args_, **kwargs_) + else: + return LoadbalancerPoolType(*args_, **kwargs_) + factory = staticmethod(factory) + def get_status(self): return self.status + def set_status(self, status): self.status = status + def get_status_description(self): return self.status_description + def set_status_description(self, status_description): self.status_description = status_description + def get_admin_state(self): return self.admin_state + def set_admin_state(self, admin_state): self.admin_state = admin_state + def get_protocol(self): return self.protocol + def set_protocol(self, protocol): self.protocol = protocol + def validate_LoadbalancerProtocolType(self, value): + # Validate type LoadbalancerProtocolType, a restriction on xsd:string. + error = False + if isinstance(value, list): + error = set(value) - set([u'HTTP', u'HTTPS', u'TCP']) + else: + error = value not in [u'HTTP', u'HTTPS', u'TCP'] + if error: + raise ValueError("LoadbalancerProtocolType must be one of [u'HTTP', u'HTTPS', u'TCP']") + def get_loadbalancer_method(self): return self.loadbalancer_method + def set_loadbalancer_method(self, loadbalancer_method): self.loadbalancer_method = loadbalancer_method + def validate_LoadbalancerMethodType(self, value): + # Validate type LoadbalancerMethodType, a restriction on xsd:string. + error = False + if isinstance(value, list): + error = set(value) - set([u'ROUND_ROBIN', u'LEAST_CONNECTIONS', u'SOURCE_IP']) + else: + error = value not in [u'ROUND_ROBIN', u'LEAST_CONNECTIONS', u'SOURCE_IP'] + if error: + raise ValueError("LoadbalancerMethodType must be one of [u'ROUND_ROBIN', u'LEAST_CONNECTIONS', u'SOURCE_IP']") + def get_subnet_id(self): return self.subnet_id + def set_subnet_id(self, subnet_id): self.subnet_id = subnet_id + def validate_UuidStringType(self, value): + # Validate type UuidStringType, a restriction on xsd:string. + pass + def __eq__(self, other): + if isinstance(other, self.__class__): + return (self.status == other.status and + self.status_description == other.status_description and + self.admin_state == other.admin_state and + self.protocol == other.protocol and + self.loadbalancer_method == other.loadbalancer_method and + self.subnet_id == other.subnet_id) + return NotImplemented + def __ne__(self, other): + if isinstance(other, self.__class__): + return not self.__eq__(other) + return NotImplemented + + @classmethod + def populate (cls, *a, **kwa): + obj = cls (*a, **kwa) + obj.set_status (obj.populate_string ("status")) + obj.set_status_description (obj.populate_string ("status_description")) + obj.set_admin_state (obj.populate_boolean ("admin_state")) + obj.set_protocol (obj.populate_string ("protocol")) + obj.set_loadbalancer_method (obj.populate_string ("loadbalancer_method")) + obj.set_subnet_id (obj.populate_string ("subnet_id")) + return obj + def export(self, outfile, level=1, namespace_='', name_='LoadbalancerPoolType', namespacedef_='', pretty_print=True): + if pretty_print: + eol_ = '\n' + else: + eol_ = '' + showIndent(outfile, level, pretty_print) + outfile.write('<%s%s%s' % (namespace_, name_, namespacedef_ and ' ' + namespacedef_ or '', )) + already_processed = [] + self.exportAttributes(outfile, level, already_processed, namespace_, name_='LoadbalancerPoolType') + if self.hasContent_(): + outfile.write('>%s' % (eol_, )) + self.exportChildren(outfile, level + 1, namespace_, name_, pretty_print=pretty_print) + showIndent(outfile, level, pretty_print) + outfile.write('</%s%s>%s' % (namespace_, name_, eol_)) + else: + outfile.write('/>%s' % (eol_, )) + def exportAttributes(self, outfile, level, already_processed, namespace_='', name_='LoadbalancerPoolType'): + pass + def exportChildren(self, outfile, level, namespace_='', name_='LoadbalancerPoolType', fromsubclass_=False, pretty_print=True): + if pretty_print: + eol_ = '\n' + else: + eol_ = '' + if self.status is not None: + showIndent(outfile, level, pretty_print) + outfile.write('<%sstatus>%s</%sstatus>%s' % (namespace_, self.gds_format_string(quote_xml(self.status).encode(ExternalEncoding), input_name='status'), namespace_, eol_)) + if self.status_description is not None: + showIndent(outfile, level, pretty_print) + outfile.write('<%sstatus-description>%s</%sstatus-description>%s' % (namespace_, self.gds_format_string(quote_xml(self.status_description).encode(ExternalEncoding), input_name='status-description'), namespace_, eol_)) + if self.admin_state is not None: + showIndent(outfile, level, pretty_print) + outfile.write('<%sadmin-state>%s</%sadmin-state>%s' % (namespace_, self.gds_format_boolean(self.gds_str_lower(str(self.admin_state)), input_name='admin-state'), namespace_, eol_)) + if self.protocol is not None: + showIndent(outfile, level, pretty_print) + outfile.write('<%sprotocol>%s</%sprotocol>%s' % (namespace_, self.gds_format_string(quote_xml(self.protocol).encode(ExternalEncoding), input_name='protocol'), namespace_, eol_)) + if self.loadbalancer_method is not None: + showIndent(outfile, level, pretty_print) + outfile.write('<%sloadbalancer-method>%s</%sloadbalancer-method>%s' % (namespace_, self.gds_format_string(quote_xml(self.loadbalancer_method).encode(ExternalEncoding), input_name='loadbalancer-method'), namespace_, eol_)) + if self.subnet_id is not None: + showIndent(outfile, level, pretty_print) + outfile.write('<%ssubnet-id>%s</%ssubnet-id>%s' % (namespace_, self.gds_format_string(quote_xml(self.subnet_id).encode(ExternalEncoding), input_name='subnet-id'), namespace_, eol_)) + def hasContent_(self): + if ( + self.status is not None or + self.status_description is not None or + self.admin_state is not None or + self.protocol is not None or + self.loadbalancer_method is not None or + self.subnet_id is not None + ): + return True + else: + return False + def exportLiteral(self, outfile, level, name_='LoadbalancerPoolType'): + level += 1 + self.exportLiteralAttributes(outfile, level, [], name_) + if self.hasContent_(): + self.exportLiteralChildren(outfile, level, name_) + def exportLiteralAttributes(self, outfile, level, already_processed, name_): + pass + def exportLiteralChildren(self, outfile, level, name_): + if self.status is not None: + showIndent(outfile, level) + outfile.write('status=%s,\n' % quote_python(self.status).encode(ExternalEncoding)) + if self.status_description is not None: + showIndent(outfile, level) + outfile.write('status_description=%s,\n' % quote_python(self.status_description).encode(ExternalEncoding)) + if self.admin_state is not None: + showIndent(outfile, level) + outfile.write('admin_state=%s,\n' % self.admin_state) + if self.protocol is not None: + showIndent(outfile, level) + outfile.write('protocol=%s,\n' % quote_python(self.protocol).encode(ExternalEncoding)) + if self.loadbalancer_method is not None: + showIndent(outfile, level) + outfile.write('loadbalancer_method=%s,\n' % quote_python(self.loadbalancer_method).encode(ExternalEncoding)) + if self.subnet_id is not None: + showIndent(outfile, level) + outfile.write('subnet_id=%s,\n' % quote_python(self.subnet_id).encode(ExternalEncoding)) + def exportDict(self, name_='LoadbalancerPoolType'): + obj_json = json.dumps(self, default=lambda o: dict((k, v) for k, v in o.__dict__.iteritems())) + obj_dict = json.loads(obj_json) + return {name_: obj_dict} + def build(self, node): + self.buildAttributes(node, node.attrib, []) + for child in node: + nodeName_ = Tag_pattern_.match(child.tag).groups()[-1] + self.buildChildren(child, node, nodeName_) + def buildAttributes(self, node, attrs, already_processed): + pass + def buildChildren(self, child_, node, nodeName_, fromsubclass_=False): + if nodeName_ == 'status': + status_ = child_.text + status_ = self.gds_validate_string(status_, node, 'status') + self.status = status_ + elif nodeName_ == 'status-description': + status_description_ = child_.text + status_description_ = self.gds_validate_string(status_description_, node, 'status_description') + self.status_description = status_description_ + elif nodeName_ == 'admin-state': + sval_ = child_.text + if sval_ in ('true', '1'): + ival_ = True + elif sval_ in ('false', '0'): + ival_ = False + else: + raise_parse_error(child_, 'requires boolean') + ival_ = self.gds_validate_boolean(ival_, node, 'admin_state') + self.admin_state = ival_ + elif nodeName_ == 'protocol': + protocol_ = child_.text + protocol_ = self.gds_validate_string(protocol_, node, 'protocol') + self.protocol = protocol_ + self.validate_LoadbalancerProtocolType(self.protocol) # validate type LoadbalancerProtocolType + elif nodeName_ == 'loadbalancer-method': + loadbalancer_method_ = child_.text + loadbalancer_method_ = self.gds_validate_string(loadbalancer_method_, node, 'loadbalancer_method') + self.loadbalancer_method = loadbalancer_method_ + self.validate_LoadbalancerMethodType(self.loadbalancer_method) # validate type LoadbalancerMethodType + elif nodeName_ == 'subnet-id': + subnet_id_ = child_.text + subnet_id_ = self.gds_validate_string(subnet_id_, node, 'subnet_id') + self.subnet_id = subnet_id_ + self.validate_UuidStringType(self.subnet_id) # validate type UuidStringType +# end class LoadbalancerPoolType + + +class loadbalancer_pool_service_appliance_set(GeneratedsSuper): + """ + loadbalancer_pool_service_appliance_set class definition from :doc:`vnc_cfg.xsd` + """ + subclass = None + superclass = None + def __init__(self, **kwargs): + pass + def factory(*args_, **kwargs_): + if loadbalancer_pool_service_appliance_set.subclass: + return loadbalancer_pool_service_appliance_set.subclass(*args_, **kwargs_) + else: + return loadbalancer_pool_service_appliance_set(*args_, **kwargs_) + factory = staticmethod(factory) + def __eq__(self, other): return True + def __ne__(self, other): return False + @classmethod + def populate (cls, *a, **kwa): + obj = cls (*a, **kwa) + return obj + def export(self, outfile, level=1, namespace_='', name_='loadbalancer-pool-service-appliance-set', namespacedef_='', pretty_print=True): + if pretty_print: + eol_ = '\n' + else: + eol_ = '' + showIndent(outfile, level, pretty_print) + outfile.write('<%s%s%s' % (namespace_, name_, namespacedef_ and ' ' + namespacedef_ or '', )) + already_processed = [] + self.exportAttributes(outfile, level, already_processed, namespace_, name_='loadbalancer-pool-service-appliance-set') + if self.hasContent_(): + outfile.write('>%s' % (eol_, )) + self.exportChildren(outfile, level + 1, namespace_, name_, pretty_print=pretty_print) + outfile.write('</%s%s>%s' % (namespace_, name_, eol_)) + else: + outfile.write('/>%s' % (eol_, )) + def exportAttributes(self, outfile, level, already_processed, namespace_='', name_='loadbalancer-pool-service-appliance-set'): + pass + def exportChildren(self, outfile, level, namespace_='', name_='loadbalancer-pool-service-appliance-set', fromsubclass_=False, pretty_print=True): + pass + def hasContent_(self): + if ( + + ): + return True + else: + return False + def exportLiteral(self, outfile, level, name_='loadbalancer-pool-service-appliance-set'): + level += 1 + self.exportLiteralAttributes(outfile, level, [], name_) + if self.hasContent_(): + self.exportLiteralChildren(outfile, level, name_) + def exportLiteralAttributes(self, outfile, level, already_processed, name_): + pass + def exportLiteralChildren(self, outfile, level, name_): + pass + def exportDict(self, name_='loadbalancer-pool-service-appliance-set'): + obj_json = json.dumps(self, default=lambda o: dict((k, v) for k, v in o.__dict__.iteritems())) + obj_dict = json.loads(obj_json) + return {name_: obj_dict} + def build(self, node): + self.buildAttributes(node, node.attrib, []) + for child in node: + nodeName_ = Tag_pattern_.match(child.tag).groups()[-1] + self.buildChildren(child, node, nodeName_) + def buildAttributes(self, node, attrs, already_processed): + pass + def buildChildren(self, child_, node, nodeName_, fromsubclass_=False): + pass +# end class loadbalancer_pool_service_appliance_set + + +class loadbalancer_pool_loadbalancer_member(GeneratedsSuper): + """ + loadbalancer_pool_loadbalancer_member class definition from :doc:`vnc_cfg.xsd` + """ + subclass = None + superclass = None + def __init__(self, **kwargs): + pass + def factory(*args_, **kwargs_): + if loadbalancer_pool_loadbalancer_member.subclass: + return loadbalancer_pool_loadbalancer_member.subclass(*args_, **kwargs_) + else: + return loadbalancer_pool_loadbalancer_member(*args_, **kwargs_) + factory = staticmethod(factory) + def __eq__(self, other): return True + def __ne__(self, other): return False + @classmethod + def populate (cls, *a, **kwa): + obj = cls (*a, **kwa) + return obj + def export(self, outfile, level=1, namespace_='', name_='loadbalancer-pool-loadbalancer-member', namespacedef_='', pretty_print=True): + if pretty_print: + eol_ = '\n' + else: + eol_ = '' + showIndent(outfile, level, pretty_print) + outfile.write('<%s%s%s' % (namespace_, name_, namespacedef_ and ' ' + namespacedef_ or '', )) + already_processed = [] + self.exportAttributes(outfile, level, already_processed, namespace_, name_='loadbalancer-pool-loadbalancer-member') + if self.hasContent_(): + outfile.write('>%s' % (eol_, )) + self.exportChildren(outfile, level + 1, namespace_, name_, pretty_print=pretty_print) + outfile.write('</%s%s>%s' % (namespace_, name_, eol_)) + else: + outfile.write('/>%s' % (eol_, )) + def exportAttributes(self, outfile, level, already_processed, namespace_='', name_='loadbalancer-pool-loadbalancer-member'): + pass + def exportChildren(self, outfile, level, namespace_='', name_='loadbalancer-pool-loadbalancer-member', fromsubclass_=False, pretty_print=True): + pass + def hasContent_(self): + if ( + + ): + return True + else: + return False + def exportLiteral(self, outfile, level, name_='loadbalancer-pool-loadbalancer-member'): + level += 1 + self.exportLiteralAttributes(outfile, level, [], name_) + if self.hasContent_(): + self.exportLiteralChildren(outfile, level, name_) + def exportLiteralAttributes(self, outfile, level, already_processed, name_): + pass + def exportLiteralChildren(self, outfile, level, name_): + pass + def exportDict(self, name_='loadbalancer-pool-loadbalancer-member'): + obj_json = json.dumps(self, default=lambda o: dict((k, v) for k, v in o.__dict__.iteritems())) + obj_dict = json.loads(obj_json) + return {name_: obj_dict} + def build(self, node): + self.buildAttributes(node, node.attrib, []) + for child in node: + nodeName_ = Tag_pattern_.match(child.tag).groups()[-1] + self.buildChildren(child, node, nodeName_) + def buildAttributes(self, node, attrs, already_processed): + pass + def buildChildren(self, child_, node, nodeName_, fromsubclass_=False): + pass +# end class loadbalancer_pool_loadbalancer_member + + +class LoadbalancerMemberType(GeneratedsSuper): + """ + LoadbalancerMemberType class definition from :doc:`vnc_cfg.xsd` + """ + subclass = None + superclass = None + def __init__(self, admin_state=True, status=None, status_description=None, protocol_port=None, weight=None, address=None, **kwargs): + self.admin_state = admin_state + self.status = status + self.status_description = status_description + self.protocol_port = protocol_port + self.weight = weight + self.address = address + def factory(*args_, **kwargs_): + if LoadbalancerMemberType.subclass: + return LoadbalancerMemberType.subclass(*args_, **kwargs_) + else: + return LoadbalancerMemberType(*args_, **kwargs_) + factory = staticmethod(factory) + def get_admin_state(self): return self.admin_state + def set_admin_state(self, admin_state): self.admin_state = admin_state + def get_status(self): return self.status + def set_status(self, status): self.status = status + def get_status_description(self): return self.status_description + def set_status_description(self, status_description): self.status_description = status_description + def get_protocol_port(self): return self.protocol_port + def set_protocol_port(self, protocol_port): self.protocol_port = protocol_port + def get_weight(self): return self.weight + def set_weight(self, weight): self.weight = weight + def get_address(self): return self.address + def set_address(self, address): self.address = address + def validate_IpAddressType(self, value): + # Validate type IpAddressType, a restriction on xsd:string. + pass + def __eq__(self, other): + if isinstance(other, self.__class__): + return (self.admin_state == other.admin_state and + self.status == other.status and + self.status_description == other.status_description and + self.protocol_port == other.protocol_port and + self.weight == other.weight and + self.address == other.address) + return NotImplemented + def __ne__(self, other): + if isinstance(other, self.__class__): + return not self.__eq__(other) + return NotImplemented + + @classmethod + def populate (cls, *a, **kwa): + obj = cls (*a, **kwa) + obj.set_admin_state (obj.populate_boolean ("admin_state")) + obj.set_status (obj.populate_string ("status")) + obj.set_status_description (obj.populate_string ("status_description")) + obj.set_protocol_port (obj.populate_integer ("protocol_port")) + obj.set_weight (obj.populate_integer ("weight")) + obj.set_address (obj.populate_string ("address")) + return obj + def export(self, outfile, level=1, namespace_='', name_='LoadbalancerMemberType', namespacedef_='', pretty_print=True): + if pretty_print: + eol_ = '\n' + else: + eol_ = '' + showIndent(outfile, level, pretty_print) + outfile.write('<%s%s%s' % (namespace_, name_, namespacedef_ and ' ' + namespacedef_ or '', )) + already_processed = [] + self.exportAttributes(outfile, level, already_processed, namespace_, name_='LoadbalancerMemberType') + if self.hasContent_(): + outfile.write('>%s' % (eol_, )) + self.exportChildren(outfile, level + 1, namespace_, name_, pretty_print=pretty_print) + showIndent(outfile, level, pretty_print) + outfile.write('</%s%s>%s' % (namespace_, name_, eol_)) + else: + outfile.write('/>%s' % (eol_, )) + def exportAttributes(self, outfile, level, already_processed, namespace_='', name_='LoadbalancerMemberType'): + pass + def exportChildren(self, outfile, level, namespace_='', name_='LoadbalancerMemberType', fromsubclass_=False, pretty_print=True): + if pretty_print: + eol_ = '\n' + else: + eol_ = '' + if self.admin_state is not None: + showIndent(outfile, level, pretty_print) + outfile.write('<%sadmin-state>%s</%sadmin-state>%s' % (namespace_, self.gds_format_boolean(self.gds_str_lower(str(self.admin_state)), input_name='admin-state'), namespace_, eol_)) + if self.status is not None: + showIndent(outfile, level, pretty_print) + outfile.write('<%sstatus>%s</%sstatus>%s' % (namespace_, self.gds_format_string(quote_xml(self.status).encode(ExternalEncoding), input_name='status'), namespace_, eol_)) + if self.status_description is not None: + showIndent(outfile, level, pretty_print) + outfile.write('<%sstatus-description>%s</%sstatus-description>%s' % (namespace_, self.gds_format_string(quote_xml(self.status_description).encode(ExternalEncoding), input_name='status-description'), namespace_, eol_)) + if self.protocol_port is not None: + showIndent(outfile, level, pretty_print) + outfile.write('<%sprotocol-port>%s</%sprotocol-port>%s' % (namespace_, self.gds_format_integer(self.protocol_port, input_name='protocol-port'), namespace_, eol_)) + if self.weight is not None: + showIndent(outfile, level, pretty_print) + outfile.write('<%sweight>%s</%sweight>%s' % (namespace_, self.gds_format_integer(self.weight, input_name='weight'), namespace_, eol_)) + if self.address is not None: + showIndent(outfile, level, pretty_print) + outfile.write('<%saddress>%s</%saddress>%s' % (namespace_, self.gds_format_string(quote_xml(self.address).encode(ExternalEncoding), input_name='address'), namespace_, eol_)) + def hasContent_(self): + if ( + self.admin_state is not None or + self.status is not None or + self.status_description is not None or + self.protocol_port is not None or + self.weight is not None or + self.address is not None + ): + return True + else: + return False + def exportLiteral(self, outfile, level, name_='LoadbalancerMemberType'): + level += 1 + self.exportLiteralAttributes(outfile, level, [], name_) + if self.hasContent_(): + self.exportLiteralChildren(outfile, level, name_) + def exportLiteralAttributes(self, outfile, level, already_processed, name_): + pass + def exportLiteralChildren(self, outfile, level, name_): + if self.admin_state is not None: + showIndent(outfile, level) + outfile.write('admin_state=%s,\n' % self.admin_state) + if self.status is not None: + showIndent(outfile, level) + outfile.write('status=%s,\n' % quote_python(self.status).encode(ExternalEncoding)) + if self.status_description is not None: + showIndent(outfile, level) + outfile.write('status_description=%s,\n' % quote_python(self.status_description).encode(ExternalEncoding)) + if self.protocol_port is not None: + showIndent(outfile, level) + outfile.write('protocol_port=%d,\n' % self.protocol_port) + if self.weight is not None: + showIndent(outfile, level) + outfile.write('weight=%d,\n' % self.weight) + if self.address is not None: + showIndent(outfile, level) + outfile.write('address=%s,\n' % quote_python(self.address).encode(ExternalEncoding)) + def exportDict(self, name_='LoadbalancerMemberType'): + obj_json = json.dumps(self, default=lambda o: dict((k, v) for k, v in o.__dict__.iteritems())) + obj_dict = json.loads(obj_json) + return {name_: obj_dict} + def build(self, node): + self.buildAttributes(node, node.attrib, []) + for child in node: + nodeName_ = Tag_pattern_.match(child.tag).groups()[-1] + self.buildChildren(child, node, nodeName_) + def buildAttributes(self, node, attrs, already_processed): + pass + def buildChildren(self, child_, node, nodeName_, fromsubclass_=False): + if nodeName_ == 'admin-state': + sval_ = child_.text + if sval_ in ('true', '1'): + ival_ = True + elif sval_ in ('false', '0'): + ival_ = False + else: + raise_parse_error(child_, 'requires boolean') + ival_ = self.gds_validate_boolean(ival_, node, 'admin_state') + self.admin_state = ival_ + elif nodeName_ == 'status': + status_ = child_.text + status_ = self.gds_validate_string(status_, node, 'status') + self.status = status_ + elif nodeName_ == 'status-description': + status_description_ = child_.text + status_description_ = self.gds_validate_string(status_description_, node, 'status_description') + self.status_description = status_description_ + elif nodeName_ == 'protocol-port': + sval_ = child_.text + try: + ival_ = int(sval_) + except (TypeError, ValueError), exp: + raise_parse_error(child_, 'requires integer: %s' % exp) + ival_ = self.gds_validate_integer(ival_, node, 'protocol_port') + self.protocol_port = ival_ + elif nodeName_ == 'weight': + sval_ = child_.text + try: + ival_ = int(sval_) + except (TypeError, ValueError), exp: + raise_parse_error(child_, 'requires integer: %s' % exp) + ival_ = self.gds_validate_integer(ival_, node, 'weight') + self.weight = ival_ + elif nodeName_ == 'address': + address_ = child_.text + address_ = self.gds_validate_string(address_, node, 'address') + self.address = address_ + self.validate_IpAddressType(self.address) # validate type IpAddressType +# end class LoadbalancerMemberType + + +class project_loadbalancer_healthmonitor(GeneratedsSuper): + """ + project_loadbalancer_healthmonitor class definition from :doc:`vnc_cfg.xsd` + """ + subclass = None + superclass = None + def __init__(self, **kwargs): + pass + def factory(*args_, **kwargs_): + if project_loadbalancer_healthmonitor.subclass: + return project_loadbalancer_healthmonitor.subclass(*args_, **kwargs_) + else: + return project_loadbalancer_healthmonitor(*args_, **kwargs_) + factory = staticmethod(factory) + def __eq__(self, other): return True + def __ne__(self, other): return False + @classmethod + def populate (cls, *a, **kwa): + obj = cls (*a, **kwa) + return obj + def export(self, outfile, level=1, namespace_='', name_='project-loadbalancer-healthmonitor', namespacedef_='', pretty_print=True): + if pretty_print: + eol_ = '\n' + else: + eol_ = '' + showIndent(outfile, level, pretty_print) + outfile.write('<%s%s%s' % (namespace_, name_, namespacedef_ and ' ' + namespacedef_ or '', )) + already_processed = [] + self.exportAttributes(outfile, level, already_processed, namespace_, name_='project-loadbalancer-healthmonitor') + if self.hasContent_(): + outfile.write('>%s' % (eol_, )) + self.exportChildren(outfile, level + 1, namespace_, name_, pretty_print=pretty_print) + outfile.write('</%s%s>%s' % (namespace_, name_, eol_)) + else: + outfile.write('/>%s' % (eol_, )) + def exportAttributes(self, outfile, level, already_processed, namespace_='', name_='project-loadbalancer-healthmonitor'): + pass + def exportChildren(self, outfile, level, namespace_='', name_='project-loadbalancer-healthmonitor', fromsubclass_=False, pretty_print=True): + pass + def hasContent_(self): + if ( + + ): + return True + else: + return False + def exportLiteral(self, outfile, level, name_='project-loadbalancer-healthmonitor'): + level += 1 + self.exportLiteralAttributes(outfile, level, [], name_) + if self.hasContent_(): + self.exportLiteralChildren(outfile, level, name_) + def exportLiteralAttributes(self, outfile, level, already_processed, name_): + pass + def exportLiteralChildren(self, outfile, level, name_): + pass + def exportDict(self, name_='project-loadbalancer-healthmonitor'): + obj_json = json.dumps(self, default=lambda o: dict((k, v) for k, v in o.__dict__.iteritems())) + obj_dict = json.loads(obj_json) + return {name_: obj_dict} + def build(self, node): + self.buildAttributes(node, node.attrib, []) + for child in node: + nodeName_ = Tag_pattern_.match(child.tag).groups()[-1] + self.buildChildren(child, node, nodeName_) + def buildAttributes(self, node, attrs, already_processed): + pass + def buildChildren(self, child_, node, nodeName_, fromsubclass_=False): + pass +# end class project_loadbalancer_healthmonitor + + +class loadbalancer_pool_loadbalancer_healthmonitor(GeneratedsSuper): + """ + loadbalancer_pool_loadbalancer_healthmonitor class definition from :doc:`vnc_cfg.xsd` + """ + subclass = None + superclass = None + def __init__(self, **kwargs): + pass + def factory(*args_, **kwargs_): + if loadbalancer_pool_loadbalancer_healthmonitor.subclass: + return loadbalancer_pool_loadbalancer_healthmonitor.subclass(*args_, **kwargs_) + else: + return loadbalancer_pool_loadbalancer_healthmonitor(*args_, **kwargs_) + factory = staticmethod(factory) + def __eq__(self, other): return True + def __ne__(self, other): return False + @classmethod + def populate (cls, *a, **kwa): + obj = cls (*a, **kwa) + return obj + def export(self, outfile, level=1, namespace_='', name_='loadbalancer-pool-loadbalancer-healthmonitor', namespacedef_='', pretty_print=True): + if pretty_print: + eol_ = '\n' + else: + eol_ = '' + showIndent(outfile, level, pretty_print) + outfile.write('<%s%s%s' % (namespace_, name_, namespacedef_ and ' ' + namespacedef_ or '', )) + already_processed = [] + self.exportAttributes(outfile, level, already_processed, namespace_, name_='loadbalancer-pool-loadbalancer-healthmonitor') + if self.hasContent_(): + outfile.write('>%s' % (eol_, )) + self.exportChildren(outfile, level + 1, namespace_, name_, pretty_print=pretty_print) + outfile.write('</%s%s>%s' % (namespace_, name_, eol_)) + else: + outfile.write('/>%s' % (eol_, )) + def exportAttributes(self, outfile, level, already_processed, namespace_='', name_='loadbalancer-pool-loadbalancer-healthmonitor'): + pass + def exportChildren(self, outfile, level, namespace_='', name_='loadbalancer-pool-loadbalancer-healthmonitor', fromsubclass_=False, pretty_print=True): + pass + def hasContent_(self): + if ( + + ): + return True + else: + return False + def exportLiteral(self, outfile, level, name_='loadbalancer-pool-loadbalancer-healthmonitor'): + level += 1 + self.exportLiteralAttributes(outfile, level, [], name_) + if self.hasContent_(): + self.exportLiteralChildren(outfile, level, name_) + def exportLiteralAttributes(self, outfile, level, already_processed, name_): + pass + def exportLiteralChildren(self, outfile, level, name_): + pass + def exportDict(self, name_='loadbalancer-pool-loadbalancer-healthmonitor'): + obj_json = json.dumps(self, default=lambda o: dict((k, v) for k, v in o.__dict__.iteritems())) + obj_dict = json.loads(obj_json) + return {name_: obj_dict} + def build(self, node): + self.buildAttributes(node, node.attrib, []) + for child in node: + nodeName_ = Tag_pattern_.match(child.tag).groups()[-1] + self.buildChildren(child, node, nodeName_) + def buildAttributes(self, node, attrs, already_processed): + pass + def buildChildren(self, child_, node, nodeName_, fromsubclass_=False): + pass +# end class loadbalancer_pool_loadbalancer_healthmonitor + + +class LoadbalancerHealthmonitorType(GeneratedsSuper): + """ + LoadbalancerHealthmonitorType class definition from :doc:`vnc_cfg.xsd` + """ + subclass = None + superclass = None + def __init__(self, admin_state=True, monitor_type=None, delay=None, timeout=None, max_retries=None, http_method=None, url_path=None, expected_codes=None, **kwargs): + self.admin_state = admin_state + self.monitor_type = monitor_type + self.delay = delay + self.timeout = timeout + self.max_retries = max_retries + self.http_method = http_method + self.url_path = url_path + self.expected_codes = expected_codes + def factory(*args_, **kwargs_): + if LoadbalancerHealthmonitorType.subclass: + return LoadbalancerHealthmonitorType.subclass(*args_, **kwargs_) + else: + return LoadbalancerHealthmonitorType(*args_, **kwargs_) + factory = staticmethod(factory) + def get_admin_state(self): return self.admin_state + def set_admin_state(self, admin_state): self.admin_state = admin_state + def get_monitor_type(self): return self.monitor_type + def set_monitor_type(self, monitor_type): self.monitor_type = monitor_type + def validate_HealthmonitorType(self, value): + # Validate type HealthmonitorType, a restriction on xsd:string. + error = False + if isinstance(value, list): + error = set(value) - set([u'PING', u'TCP', u'HTTP', u'HTTPS']) + else: + error = value not in [u'PING', u'TCP', u'HTTP', u'HTTPS'] + if error: + raise ValueError("HealthmonitorType must be one of [u'PING', u'TCP', u'HTTP', u'HTTPS']") + def get_delay(self): return self.delay + def set_delay(self, delay): self.delay = delay + def get_timeout(self): return self.timeout + def set_timeout(self, timeout): self.timeout = timeout + def get_max_retries(self): return self.max_retries + def set_max_retries(self, max_retries): self.max_retries = max_retries + def get_http_method(self): return self.http_method + def set_http_method(self, http_method): self.http_method = http_method + def get_url_path(self): return self.url_path + def set_url_path(self, url_path): self.url_path = url_path + def get_expected_codes(self): return self.expected_codes + def set_expected_codes(self, expected_codes): self.expected_codes = expected_codes + def __eq__(self, other): + if isinstance(other, self.__class__): + return (self.admin_state == other.admin_state and + self.monitor_type == other.monitor_type and + self.delay == other.delay and + self.timeout == other.timeout and + self.max_retries == other.max_retries and + self.http_method == other.http_method and + self.url_path == other.url_path and + self.expected_codes == other.expected_codes) + return NotImplemented + def __ne__(self, other): + if isinstance(other, self.__class__): + return not self.__eq__(other) + return NotImplemented + + @classmethod + def populate (cls, *a, **kwa): + obj = cls (*a, **kwa) + obj.set_admin_state (obj.populate_boolean ("admin_state")) + obj.set_monitor_type (obj.populate_string ("monitor_type")) + obj.set_delay (obj.populate_integer ("delay")) + obj.set_timeout (obj.populate_integer ("timeout")) + obj.set_max_retries (obj.populate_integer ("max_retries")) + obj.set_http_method (obj.populate_string ("http_method")) + obj.set_url_path (obj.populate_string ("url_path")) + obj.set_expected_codes (obj.populate_string ("expected_codes")) + return obj + def export(self, outfile, level=1, namespace_='', name_='LoadbalancerHealthmonitorType', namespacedef_='', pretty_print=True): + if pretty_print: + eol_ = '\n' + else: + eol_ = '' + showIndent(outfile, level, pretty_print) + outfile.write('<%s%s%s' % (namespace_, name_, namespacedef_ and ' ' + namespacedef_ or '', )) + already_processed = [] + self.exportAttributes(outfile, level, already_processed, namespace_, name_='LoadbalancerHealthmonitorType') + if self.hasContent_(): + outfile.write('>%s' % (eol_, )) + self.exportChildren(outfile, level + 1, namespace_, name_, pretty_print=pretty_print) + showIndent(outfile, level, pretty_print) + outfile.write('</%s%s>%s' % (namespace_, name_, eol_)) + else: + outfile.write('/>%s' % (eol_, )) + def exportAttributes(self, outfile, level, already_processed, namespace_='', name_='LoadbalancerHealthmonitorType'): + pass + def exportChildren(self, outfile, level, namespace_='', name_='LoadbalancerHealthmonitorType', fromsubclass_=False, pretty_print=True): + if pretty_print: + eol_ = '\n' + else: + eol_ = '' + if self.admin_state is not None: + showIndent(outfile, level, pretty_print) + outfile.write('<%sadmin-state>%s</%sadmin-state>%s' % (namespace_, self.gds_format_boolean(self.gds_str_lower(str(self.admin_state)), input_name='admin-state'), namespace_, eol_)) + if self.monitor_type is not None: + showIndent(outfile, level, pretty_print) + outfile.write('<%smonitor-type>%s</%smonitor-type>%s' % (namespace_, self.gds_format_string(quote_xml(self.monitor_type).encode(ExternalEncoding), input_name='monitor-type'), namespace_, eol_)) + if self.delay is not None: + showIndent(outfile, level, pretty_print) + outfile.write('<%sdelay>%s</%sdelay>%s' % (namespace_, self.gds_format_integer(self.delay, input_name='delay'), namespace_, eol_)) + if self.timeout is not None: + showIndent(outfile, level, pretty_print) + outfile.write('<%stimeout>%s</%stimeout>%s' % (namespace_, self.gds_format_integer(self.timeout, input_name='timeout'), namespace_, eol_)) + if self.max_retries is not None: + showIndent(outfile, level, pretty_print) + outfile.write('<%smax-retries>%s</%smax-retries>%s' % (namespace_, self.gds_format_integer(self.max_retries, input_name='max-retries'), namespace_, eol_)) + if self.http_method is not None: + showIndent(outfile, level, pretty_print) + outfile.write('<%shttp-method>%s</%shttp-method>%s' % (namespace_, self.gds_format_string(quote_xml(self.http_method).encode(ExternalEncoding), input_name='http-method'), namespace_, eol_)) + if self.url_path is not None: + showIndent(outfile, level, pretty_print) + outfile.write('<%surl-path>%s</%surl-path>%s' % (namespace_, self.gds_format_string(quote_xml(self.url_path).encode(ExternalEncoding), input_name='url-path'), namespace_, eol_)) + if self.expected_codes is not None: + showIndent(outfile, level, pretty_print) + outfile.write('<%sexpected-codes>%s</%sexpected-codes>%s' % (namespace_, self.gds_format_string(quote_xml(self.expected_codes).encode(ExternalEncoding), input_name='expected-codes'), namespace_, eol_)) + def hasContent_(self): + if ( + self.admin_state is not None or + self.monitor_type is not None or + self.delay is not None or + self.timeout is not None or + self.max_retries is not None or + self.http_method is not None or + self.url_path is not None or + self.expected_codes is not None + ): + return True + else: + return False + def exportLiteral(self, outfile, level, name_='LoadbalancerHealthmonitorType'): + level += 1 + self.exportLiteralAttributes(outfile, level, [], name_) + if self.hasContent_(): + self.exportLiteralChildren(outfile, level, name_) + def exportLiteralAttributes(self, outfile, level, already_processed, name_): + pass + def exportLiteralChildren(self, outfile, level, name_): + if self.admin_state is not None: + showIndent(outfile, level) + outfile.write('admin_state=%s,\n' % self.admin_state) + if self.monitor_type is not None: + showIndent(outfile, level) + outfile.write('monitor_type=%s,\n' % quote_python(self.monitor_type).encode(ExternalEncoding)) + if self.delay is not None: + showIndent(outfile, level) + outfile.write('delay=%d,\n' % self.delay) + if self.timeout is not None: + showIndent(outfile, level) + outfile.write('timeout=%d,\n' % self.timeout) + if self.max_retries is not None: + showIndent(outfile, level) + outfile.write('max_retries=%d,\n' % self.max_retries) + if self.http_method is not None: + showIndent(outfile, level) + outfile.write('http_method=%s,\n' % quote_python(self.http_method).encode(ExternalEncoding)) + if self.url_path is not None: + showIndent(outfile, level) + outfile.write('url_path=%s,\n' % quote_python(self.url_path).encode(ExternalEncoding)) + if self.expected_codes is not None: + showIndent(outfile, level) + outfile.write('expected_codes=%s,\n' % quote_python(self.expected_codes).encode(ExternalEncoding)) + def exportDict(self, name_='LoadbalancerHealthmonitorType'): + obj_json = json.dumps(self, default=lambda o: dict((k, v) for k, v in o.__dict__.iteritems())) + obj_dict = json.loads(obj_json) + return {name_: obj_dict} + def build(self, node): + self.buildAttributes(node, node.attrib, []) + for child in node: + nodeName_ = Tag_pattern_.match(child.tag).groups()[-1] + self.buildChildren(child, node, nodeName_) + def buildAttributes(self, node, attrs, already_processed): + pass + def buildChildren(self, child_, node, nodeName_, fromsubclass_=False): + if nodeName_ == 'admin-state': + sval_ = child_.text + if sval_ in ('true', '1'): + ival_ = True + elif sval_ in ('false', '0'): + ival_ = False + else: + raise_parse_error(child_, 'requires boolean') + ival_ = self.gds_validate_boolean(ival_, node, 'admin_state') + self.admin_state = ival_ + elif nodeName_ == 'monitor-type': + monitor_type_ = child_.text + monitor_type_ = self.gds_validate_string(monitor_type_, node, 'monitor_type') + self.monitor_type = monitor_type_ + self.validate_HealthmonitorType(self.monitor_type) # validate type HealthmonitorType + elif nodeName_ == 'delay': + sval_ = child_.text + try: + ival_ = int(sval_) + except (TypeError, ValueError), exp: + raise_parse_error(child_, 'requires integer: %s' % exp) + ival_ = self.gds_validate_integer(ival_, node, 'delay') + self.delay = ival_ + elif nodeName_ == 'timeout': + sval_ = child_.text + try: + ival_ = int(sval_) + except (TypeError, ValueError), exp: + raise_parse_error(child_, 'requires integer: %s' % exp) + ival_ = self.gds_validate_integer(ival_, node, 'timeout') + self.timeout = ival_ + elif nodeName_ == 'max-retries': + sval_ = child_.text + try: + ival_ = int(sval_) + except (TypeError, ValueError), exp: + raise_parse_error(child_, 'requires integer: %s' % exp) + ival_ = self.gds_validate_integer(ival_, node, 'max_retries') + self.max_retries = ival_ + elif nodeName_ == 'http-method': + http_method_ = child_.text + http_method_ = self.gds_validate_string(http_method_, node, 'http_method') + self.http_method = http_method_ + elif nodeName_ == 'url-path': + url_path_ = child_.text + url_path_ = self.gds_validate_string(url_path_, node, 'url_path') + self.url_path = url_path_ + elif nodeName_ == 'expected-codes': + expected_codes_ = child_.text + expected_codes_ = self.gds_validate_string(expected_codes_, node, 'expected_codes') + self.expected_codes = expected_codes_ +# end class LoadbalancerHealthmonitorType + + +class project_virtual_ip(GeneratedsSuper): + """ + project_virtual_ip class definition from :doc:`vnc_cfg.xsd` + """ + subclass = None + superclass = None + def __init__(self, **kwargs): + pass + def factory(*args_, **kwargs_): + if project_virtual_ip.subclass: + return project_virtual_ip.subclass(*args_, **kwargs_) + else: + return project_virtual_ip(*args_, **kwargs_) + factory = staticmethod(factory) + def __eq__(self, other): return True + def __ne__(self, other): return False + @classmethod + def populate (cls, *a, **kwa): + obj = cls (*a, **kwa) + return obj + def export(self, outfile, level=1, namespace_='', name_='project-virtual-ip', namespacedef_='', pretty_print=True): + if pretty_print: + eol_ = '\n' + else: + eol_ = '' + showIndent(outfile, level, pretty_print) + outfile.write('<%s%s%s' % (namespace_, name_, namespacedef_ and ' ' + namespacedef_ or '', )) + already_processed = [] + self.exportAttributes(outfile, level, already_processed, namespace_, name_='project-virtual-ip') + if self.hasContent_(): + outfile.write('>%s' % (eol_, )) + self.exportChildren(outfile, level + 1, namespace_, name_, pretty_print=pretty_print) + outfile.write('</%s%s>%s' % (namespace_, name_, eol_)) + else: + outfile.write('/>%s' % (eol_, )) + def exportAttributes(self, outfile, level, already_processed, namespace_='', name_='project-virtual-ip'): + pass + def exportChildren(self, outfile, level, namespace_='', name_='project-virtual-ip', fromsubclass_=False, pretty_print=True): + pass + def hasContent_(self): + if ( + + ): + return True + else: + return False + def exportLiteral(self, outfile, level, name_='project-virtual-ip'): + level += 1 + self.exportLiteralAttributes(outfile, level, [], name_) + if self.hasContent_(): + self.exportLiteralChildren(outfile, level, name_) + def exportLiteralAttributes(self, outfile, level, already_processed, name_): + pass + def exportLiteralChildren(self, outfile, level, name_): + pass + def exportDict(self, name_='project-virtual-ip'): + obj_json = json.dumps(self, default=lambda o: dict((k, v) for k, v in o.__dict__.iteritems())) + obj_dict = json.loads(obj_json) + return {name_: obj_dict} + def build(self, node): + self.buildAttributes(node, node.attrib, []) + for child in node: + nodeName_ = Tag_pattern_.match(child.tag).groups()[-1] + self.buildChildren(child, node, nodeName_) + def buildAttributes(self, node, attrs, already_processed): + pass + def buildChildren(self, child_, node, nodeName_, fromsubclass_=False): + pass +# end class project_virtual_ip + + +class virtual_ip_loadbalancer_pool(GeneratedsSuper): + """ + virtual_ip_loadbalancer_pool class definition from :doc:`vnc_cfg.xsd` + """ + subclass = None + superclass = None + def __init__(self, **kwargs): + pass + def factory(*args_, **kwargs_): + if virtual_ip_loadbalancer_pool.subclass: + return virtual_ip_loadbalancer_pool.subclass(*args_, **kwargs_) + else: + return virtual_ip_loadbalancer_pool(*args_, **kwargs_) + factory = staticmethod(factory) + def __eq__(self, other): return True + def __ne__(self, other): return False + @classmethod + def populate (cls, *a, **kwa): + obj = cls (*a, **kwa) + return obj + def export(self, outfile, level=1, namespace_='', name_='virtual-ip-loadbalancer-pool', namespacedef_='', pretty_print=True): + if pretty_print: + eol_ = '\n' + else: + eol_ = '' + showIndent(outfile, level, pretty_print) + outfile.write('<%s%s%s' % (namespace_, name_, namespacedef_ and ' ' + namespacedef_ or '', )) + already_processed = [] + self.exportAttributes(outfile, level, already_processed, namespace_, name_='virtual-ip-loadbalancer-pool') + if self.hasContent_(): + outfile.write('>%s' % (eol_, )) + self.exportChildren(outfile, level + 1, namespace_, name_, pretty_print=pretty_print) + outfile.write('</%s%s>%s' % (namespace_, name_, eol_)) + else: + outfile.write('/>%s' % (eol_, )) + def exportAttributes(self, outfile, level, already_processed, namespace_='', name_='virtual-ip-loadbalancer-pool'): + pass + def exportChildren(self, outfile, level, namespace_='', name_='virtual-ip-loadbalancer-pool', fromsubclass_=False, pretty_print=True): + pass + def hasContent_(self): + if ( + + ): + return True + else: + return False + def exportLiteral(self, outfile, level, name_='virtual-ip-loadbalancer-pool'): + level += 1 + self.exportLiteralAttributes(outfile, level, [], name_) + if self.hasContent_(): + self.exportLiteralChildren(outfile, level, name_) + def exportLiteralAttributes(self, outfile, level, already_processed, name_): + pass + def exportLiteralChildren(self, outfile, level, name_): + pass + def exportDict(self, name_='virtual-ip-loadbalancer-pool'): + obj_json = json.dumps(self, default=lambda o: dict((k, v) for k, v in o.__dict__.iteritems())) + obj_dict = json.loads(obj_json) + return {name_: obj_dict} + def build(self, node): + self.buildAttributes(node, node.attrib, []) + for child in node: + nodeName_ = Tag_pattern_.match(child.tag).groups()[-1] + self.buildChildren(child, node, nodeName_) + def buildAttributes(self, node, attrs, already_processed): + pass + def buildChildren(self, child_, node, nodeName_, fromsubclass_=False): + pass +# end class virtual_ip_loadbalancer_pool + + +class virtual_ip_virtual_machine_interface(GeneratedsSuper): + """ + virtual_ip_virtual_machine_interface class definition from :doc:`vnc_cfg.xsd` + """ + subclass = None + superclass = None + def __init__(self, **kwargs): + pass + def factory(*args_, **kwargs_): + if virtual_ip_virtual_machine_interface.subclass: + return virtual_ip_virtual_machine_interface.subclass(*args_, **kwargs_) + else: + return virtual_ip_virtual_machine_interface(*args_, **kwargs_) + factory = staticmethod(factory) + def __eq__(self, other): return True + def __ne__(self, other): return False + @classmethod + def populate (cls, *a, **kwa): + obj = cls (*a, **kwa) + return obj + def export(self, outfile, level=1, namespace_='', name_='virtual-ip-virtual-machine-interface', namespacedef_='', pretty_print=True): + if pretty_print: + eol_ = '\n' + else: + eol_ = '' + showIndent(outfile, level, pretty_print) + outfile.write('<%s%s%s' % (namespace_, name_, namespacedef_ and ' ' + namespacedef_ or '', )) + already_processed = [] + self.exportAttributes(outfile, level, already_processed, namespace_, name_='virtual-ip-virtual-machine-interface') + if self.hasContent_(): + outfile.write('>%s' % (eol_, )) + self.exportChildren(outfile, level + 1, namespace_, name_, pretty_print=pretty_print) + outfile.write('</%s%s>%s' % (namespace_, name_, eol_)) + else: + outfile.write('/>%s' % (eol_, )) + def exportAttributes(self, outfile, level, already_processed, namespace_='', name_='virtual-ip-virtual-machine-interface'): + pass + def exportChildren(self, outfile, level, namespace_='', name_='virtual-ip-virtual-machine-interface', fromsubclass_=False, pretty_print=True): + pass + def hasContent_(self): + if ( + + ): + return True + else: + return False + def exportLiteral(self, outfile, level, name_='virtual-ip-virtual-machine-interface'): + level += 1 + self.exportLiteralAttributes(outfile, level, [], name_) + if self.hasContent_(): + self.exportLiteralChildren(outfile, level, name_) + def exportLiteralAttributes(self, outfile, level, already_processed, name_): + pass + def exportLiteralChildren(self, outfile, level, name_): + pass + def exportDict(self, name_='virtual-ip-virtual-machine-interface'): + obj_json = json.dumps(self, default=lambda o: dict((k, v) for k, v in o.__dict__.iteritems())) + obj_dict = json.loads(obj_json) + return {name_: obj_dict} + def build(self, node): + self.buildAttributes(node, node.attrib, []) + for child in node: + nodeName_ = Tag_pattern_.match(child.tag).groups()[-1] + self.buildChildren(child, node, nodeName_) + def buildAttributes(self, node, attrs, already_processed): + pass + def buildChildren(self, child_, node, nodeName_, fromsubclass_=False): + pass +# end class virtual_ip_virtual_machine_interface + + +class VirtualIpType(GeneratedsSuper): + """ + VirtualIpType class definition from :doc:`vnc_cfg.xsd` + """ + subclass = None + superclass = None + def __init__(self, address=None, status=None, status_description=None, admin_state=True, protocol=None, protocol_port=None, connection_limit=None, subnet_id=None, persistence_cookie_name=None, persistence_type=None, **kwargs): + self.address = address + self.status = status + self.status_description = status_description + self.admin_state = admin_state + self.protocol = protocol + self.protocol_port = protocol_port + self.connection_limit = connection_limit + self.subnet_id = subnet_id + self.persistence_cookie_name = persistence_cookie_name + self.persistence_type = persistence_type + def factory(*args_, **kwargs_): + if VirtualIpType.subclass: + return VirtualIpType.subclass(*args_, **kwargs_) + else: + return VirtualIpType(*args_, **kwargs_) + factory = staticmethod(factory) + def get_address(self): return self.address + def set_address(self, address): self.address = address + def validate_IpAddressType(self, value): + # Validate type IpAddressType, a restriction on xsd:string. + pass + def get_status(self): return self.status + def set_status(self, status): self.status = status + def get_status_description(self): return self.status_description + def set_status_description(self, status_description): self.status_description = status_description + def get_admin_state(self): return self.admin_state + def set_admin_state(self, admin_state): self.admin_state = admin_state + def get_protocol(self): return self.protocol + def set_protocol(self, protocol): self.protocol = protocol + def validate_LoadbalancerProtocolType(self, value): + # Validate type LoadbalancerProtocolType, a restriction on xsd:string. + error = False + if isinstance(value, list): + error = set(value) - set([u'HTTP', u'HTTPS', u'TCP']) + else: + error = value not in [u'HTTP', u'HTTPS', u'TCP'] + if error: + raise ValueError("LoadbalancerProtocolType must be one of [u'HTTP', u'HTTPS', u'TCP']") + def get_protocol_port(self): return self.protocol_port + def set_protocol_port(self, protocol_port): self.protocol_port = protocol_port + def get_connection_limit(self): return self.connection_limit + def set_connection_limit(self, connection_limit): self.connection_limit = connection_limit + def get_subnet_id(self): return self.subnet_id + def set_subnet_id(self, subnet_id): self.subnet_id = subnet_id + def validate_UuidStringType(self, value): + # Validate type UuidStringType, a restriction on xsd:string. + pass + def get_persistence_cookie_name(self): return self.persistence_cookie_name + def set_persistence_cookie_name(self, persistence_cookie_name): self.persistence_cookie_name = persistence_cookie_name + def get_persistence_type(self): return self.persistence_type + def set_persistence_type(self, persistence_type): self.persistence_type = persistence_type + def validate_SessionPersistenceType(self, value): + # Validate type SessionPersistenceType, a restriction on xsd:string. + error = False + if isinstance(value, list): + error = set(value) - set([u'SOURCE_IP', u'HTTP_COOKIE', u'APP_COOKIE']) + else: + error = value not in [u'SOURCE_IP', u'HTTP_COOKIE', u'APP_COOKIE'] + if error: + raise ValueError("SessionPersistenceType must be one of [u'SOURCE_IP', u'HTTP_COOKIE', u'APP_COOKIE']") + def __eq__(self, other): + if isinstance(other, self.__class__): + return (self.address == other.address and + self.status == other.status and + self.status_description == other.status_description and + self.admin_state == other.admin_state and + self.protocol == other.protocol and + self.protocol_port == other.protocol_port and + self.connection_limit == other.connection_limit and + self.subnet_id == other.subnet_id and + self.persistence_cookie_name == other.persistence_cookie_name and + self.persistence_type == other.persistence_type) + return NotImplemented + def __ne__(self, other): + if isinstance(other, self.__class__): + return not self.__eq__(other) + return NotImplemented + + @classmethod + def populate (cls, *a, **kwa): + obj = cls (*a, **kwa) + obj.set_address (obj.populate_string ("address")) + obj.set_status (obj.populate_string ("status")) + obj.set_status_description (obj.populate_string ("status_description")) + obj.set_admin_state (obj.populate_boolean ("admin_state")) + obj.set_protocol (obj.populate_string ("protocol")) + obj.set_protocol_port (obj.populate_integer ("protocol_port")) + obj.set_connection_limit (obj.populate_integer ("connection_limit")) + obj.set_subnet_id (obj.populate_string ("subnet_id")) + obj.set_persistence_cookie_name (obj.populate_string ("persistence_cookie_name")) + obj.set_persistence_type (obj.populate_string ("persistence_type")) + return obj + def export(self, outfile, level=1, namespace_='', name_='VirtualIpType', namespacedef_='', pretty_print=True): + if pretty_print: + eol_ = '\n' + else: + eol_ = '' + showIndent(outfile, level, pretty_print) + outfile.write('<%s%s%s' % (namespace_, name_, namespacedef_ and ' ' + namespacedef_ or '', )) + already_processed = [] + self.exportAttributes(outfile, level, already_processed, namespace_, name_='VirtualIpType') + if self.hasContent_(): + outfile.write('>%s' % (eol_, )) + self.exportChildren(outfile, level + 1, namespace_, name_, pretty_print=pretty_print) + showIndent(outfile, level, pretty_print) + outfile.write('</%s%s>%s' % (namespace_, name_, eol_)) + else: + outfile.write('/>%s' % (eol_, )) + def exportAttributes(self, outfile, level, already_processed, namespace_='', name_='VirtualIpType'): + pass + def exportChildren(self, outfile, level, namespace_='', name_='VirtualIpType', fromsubclass_=False, pretty_print=True): + if pretty_print: + eol_ = '\n' + else: + eol_ = '' + if self.address is not None: + showIndent(outfile, level, pretty_print) + outfile.write('<%saddress>%s</%saddress>%s' % (namespace_, self.gds_format_string(quote_xml(self.address).encode(ExternalEncoding), input_name='address'), namespace_, eol_)) + if self.status is not None: + showIndent(outfile, level, pretty_print) + outfile.write('<%sstatus>%s</%sstatus>%s' % (namespace_, self.gds_format_string(quote_xml(self.status).encode(ExternalEncoding), input_name='status'), namespace_, eol_)) + if self.status_description is not None: + showIndent(outfile, level, pretty_print) + outfile.write('<%sstatus-description>%s</%sstatus-description>%s' % (namespace_, self.gds_format_string(quote_xml(self.status_description).encode(ExternalEncoding), input_name='status-description'), namespace_, eol_)) + if self.admin_state is not None: + showIndent(outfile, level, pretty_print) + outfile.write('<%sadmin-state>%s</%sadmin-state>%s' % (namespace_, self.gds_format_boolean(self.gds_str_lower(str(self.admin_state)), input_name='admin-state'), namespace_, eol_)) + if self.protocol is not None: + showIndent(outfile, level, pretty_print) + outfile.write('<%sprotocol>%s</%sprotocol>%s' % (namespace_, self.gds_format_string(quote_xml(self.protocol).encode(ExternalEncoding), input_name='protocol'), namespace_, eol_)) + if self.protocol_port is not None: + showIndent(outfile, level, pretty_print) + outfile.write('<%sprotocol-port>%s</%sprotocol-port>%s' % (namespace_, self.gds_format_integer(self.protocol_port, input_name='protocol-port'), namespace_, eol_)) + if self.connection_limit is not None: + showIndent(outfile, level, pretty_print) + outfile.write('<%sconnection-limit>%s</%sconnection-limit>%s' % (namespace_, self.gds_format_integer(self.connection_limit, input_name='connection-limit'), namespace_, eol_)) + if self.subnet_id is not None: + showIndent(outfile, level, pretty_print) + outfile.write('<%ssubnet-id>%s</%ssubnet-id>%s' % (namespace_, self.gds_format_string(quote_xml(self.subnet_id).encode(ExternalEncoding), input_name='subnet-id'), namespace_, eol_)) + if self.persistence_cookie_name is not None: + showIndent(outfile, level, pretty_print) + outfile.write('<%spersistence-cookie-name>%s</%spersistence-cookie-name>%s' % (namespace_, self.gds_format_string(quote_xml(self.persistence_cookie_name).encode(ExternalEncoding), input_name='persistence-cookie-name'), namespace_, eol_)) + if self.persistence_type is not None: + showIndent(outfile, level, pretty_print) + outfile.write('<%spersistence-type>%s</%spersistence-type>%s' % (namespace_, self.gds_format_string(quote_xml(self.persistence_type).encode(ExternalEncoding), input_name='persistence-type'), namespace_, eol_)) + def hasContent_(self): + if ( + self.address is not None or + self.status is not None or + self.status_description is not None or + self.admin_state is not None or + self.protocol is not None or + self.protocol_port is not None or + self.connection_limit is not None or + self.subnet_id is not None or + self.persistence_cookie_name is not None or + self.persistence_type is not None + ): + return True + else: + return False + def exportLiteral(self, outfile, level, name_='VirtualIpType'): + level += 1 + self.exportLiteralAttributes(outfile, level, [], name_) + if self.hasContent_(): + self.exportLiteralChildren(outfile, level, name_) + def exportLiteralAttributes(self, outfile, level, already_processed, name_): + pass + def exportLiteralChildren(self, outfile, level, name_): + if self.address is not None: + showIndent(outfile, level) + outfile.write('address=%s,\n' % quote_python(self.address).encode(ExternalEncoding)) + if self.status is not None: + showIndent(outfile, level) + outfile.write('status=%s,\n' % quote_python(self.status).encode(ExternalEncoding)) + if self.status_description is not None: + showIndent(outfile, level) + outfile.write('status_description=%s,\n' % quote_python(self.status_description).encode(ExternalEncoding)) + if self.admin_state is not None: + showIndent(outfile, level) + outfile.write('admin_state=%s,\n' % self.admin_state) + if self.protocol is not None: + showIndent(outfile, level) + outfile.write('protocol=%s,\n' % quote_python(self.protocol).encode(ExternalEncoding)) + if self.protocol_port is not None: + showIndent(outfile, level) + outfile.write('protocol_port=%d,\n' % self.protocol_port) + if self.connection_limit is not None: + showIndent(outfile, level) + outfile.write('connection_limit=%d,\n' % self.connection_limit) + if self.subnet_id is not None: + showIndent(outfile, level) + outfile.write('subnet_id=%s,\n' % quote_python(self.subnet_id).encode(ExternalEncoding)) + if self.persistence_cookie_name is not None: + showIndent(outfile, level) + outfile.write('persistence_cookie_name=%s,\n' % quote_python(self.persistence_cookie_name).encode(ExternalEncoding)) + if self.persistence_type is not None: + showIndent(outfile, level) + outfile.write('persistence_type=%s,\n' % quote_python(self.persistence_type).encode(ExternalEncoding)) + def exportDict(self, name_='VirtualIpType'): + obj_json = json.dumps(self, default=lambda o: dict((k, v) for k, v in o.__dict__.iteritems())) + obj_dict = json.loads(obj_json) + return {name_: obj_dict} + def build(self, node): + self.buildAttributes(node, node.attrib, []) + for child in node: + nodeName_ = Tag_pattern_.match(child.tag).groups()[-1] + self.buildChildren(child, node, nodeName_) + def buildAttributes(self, node, attrs, already_processed): + pass + def buildChildren(self, child_, node, nodeName_, fromsubclass_=False): + if nodeName_ == 'address': + address_ = child_.text + address_ = self.gds_validate_string(address_, node, 'address') + self.address = address_ + self.validate_IpAddressType(self.address) # validate type IpAddressType + elif nodeName_ == 'status': + status_ = child_.text + status_ = self.gds_validate_string(status_, node, 'status') + self.status = status_ + elif nodeName_ == 'status-description': + status_description_ = child_.text + status_description_ = self.gds_validate_string(status_description_, node, 'status_description') + self.status_description = status_description_ + elif nodeName_ == 'admin-state': + sval_ = child_.text + if sval_ in ('true', '1'): + ival_ = True + elif sval_ in ('false', '0'): + ival_ = False + else: + raise_parse_error(child_, 'requires boolean') + ival_ = self.gds_validate_boolean(ival_, node, 'admin_state') + self.admin_state = ival_ + elif nodeName_ == 'protocol': + protocol_ = child_.text + protocol_ = self.gds_validate_string(protocol_, node, 'protocol') + self.protocol = protocol_ + self.validate_LoadbalancerProtocolType(self.protocol) # validate type LoadbalancerProtocolType + elif nodeName_ == 'protocol-port': + sval_ = child_.text + try: + ival_ = int(sval_) + except (TypeError, ValueError), exp: + raise_parse_error(child_, 'requires integer: %s' % exp) + ival_ = self.gds_validate_integer(ival_, node, 'protocol_port') + self.protocol_port = ival_ + elif nodeName_ == 'connection-limit': + sval_ = child_.text + try: + ival_ = int(sval_) + except (TypeError, ValueError), exp: + raise_parse_error(child_, 'requires integer: %s' % exp) + ival_ = self.gds_validate_integer(ival_, node, 'connection_limit') + self.connection_limit = ival_ + elif nodeName_ == 'subnet-id': + subnet_id_ = child_.text + subnet_id_ = self.gds_validate_string(subnet_id_, node, 'subnet_id') + self.subnet_id = subnet_id_ + self.validate_UuidStringType(self.subnet_id) # validate type UuidStringType + elif nodeName_ == 'persistence-cookie-name': + persistence_cookie_name_ = child_.text + persistence_cookie_name_ = self.gds_validate_string(persistence_cookie_name_, node, 'persistence_cookie_name') + self.persistence_cookie_name = persistence_cookie_name_ + elif nodeName_ == 'persistence-type': + persistence_type_ = child_.text + persistence_type_ = self.gds_validate_string(persistence_type_, node, 'persistence_type') + self.persistence_type = persistence_type_ + self.validate_SessionPersistenceType(self.persistence_type) # validate type SessionPersistenceType +# end class VirtualIpType + + +class BgpRouterParams(GeneratedsSuper): + """ + BgpRouterParams class definition from :doc:`vnc_cfg.xsd` + """ + subclass = None + superclass = None + def __init__(self, vendor=None, autonomous_system=None, identifier=None, address=None, port=None, hold_time=90, address_families=None, auth_data=None, local_autonomous_system=None, **kwargs): + self.vendor = vendor + self.autonomous_system = autonomous_system + self.identifier = identifier + self.address = address + self.port = port + self.hold_time = hold_time + if isinstance(address_families, dict): + obj = AddressFamilies(**address_families) + self.address_families = obj + else: + self.address_families = address_families + if isinstance(auth_data, dict): + obj = AuthenticationData(**auth_data) + self.auth_data = obj + else: + self.auth_data = auth_data + self.local_autonomous_system = local_autonomous_system + def factory(*args_, **kwargs_): + if BgpRouterParams.subclass: + return BgpRouterParams.subclass(*args_, **kwargs_) + else: + return BgpRouterParams(*args_, **kwargs_) + factory = staticmethod(factory) + def get_vendor(self): return self.vendor + def set_vendor(self, vendor): self.vendor = vendor + def get_autonomous_system(self): return self.autonomous_system + def set_autonomous_system(self, autonomous_system): self.autonomous_system = autonomous_system + def get_identifier(self): return self.identifier + def set_identifier(self, identifier): self.identifier = identifier + def validate_IpAddress(self, value): + # Validate type IpAddress, a restriction on xsd:string. + pass + def get_address(self): return self.address + def set_address(self, address): self.address = address + def get_port(self): return self.port + def set_port(self, port): self.port = port + def get_hold_time(self): return self.hold_time + def set_hold_time(self, hold_time): self.hold_time = hold_time + def validate_BgpHoldTime(self, value): + # Validate type BgpHoldTime, a restriction on xsd:integer. + error = False + if isinstance(value, list): + v_int = map(int, value) + v1, v2 = min(v_int), max(v_int) + else: + v1, v2 = int(value), int(value) + error = (1 > v1) + error |= (v2 > 65535) + if error: + raise ValueError("BgpHoldTime must be in the range 1-65535") + def get_address_families(self): return self.address_families + def set_address_families(self, address_families): self.address_families = address_families + def get_auth_data(self): return self.auth_data + def set_auth_data(self, auth_data): self.auth_data = auth_data + def get_local_autonomous_system(self): return self.local_autonomous_system + def set_local_autonomous_system(self, local_autonomous_system): self.local_autonomous_system = local_autonomous_system + def __eq__(self, other): + if isinstance(other, self.__class__): + return (self.vendor == other.vendor and + self.autonomous_system == other.autonomous_system and + self.identifier == other.identifier and + self.address == other.address and + self.port == other.port and + self.hold_time == other.hold_time and + self.address_families == other.address_families and + self.auth_data == other.auth_data and + self.local_autonomous_system == other.local_autonomous_system) + return NotImplemented + def __ne__(self, other): + if isinstance(other, self.__class__): + return not self.__eq__(other) + return NotImplemented + + @classmethod + def populate (cls, *a, **kwa): + obj = cls (*a, **kwa) + obj.set_vendor (obj.populate_string ("vendor")) + obj.set_autonomous_system (obj.populate_integer ("autonomous_system")) + obj.set_identifier (obj.populate_string ("identifier")) + obj.set_address (obj.populate_string ("address")) + obj.set_port (obj.populate_integer ("port")) + obj.set_hold_time (obj.populate_integer ("hold_time")) + obj.set_address_families (AddressFamilies.populate ()) + obj.set_auth_data (AuthenticationData.populate ()) + obj.set_local_autonomous_system (obj.populate_integer ("local_autonomous_system")) + return obj + def export(self, outfile, level=1, namespace_='', name_='BgpRouterParams', namespacedef_='', pretty_print=True): + if pretty_print: + eol_ = '\n' + else: + eol_ = '' + showIndent(outfile, level, pretty_print) + outfile.write('<%s%s%s' % (namespace_, name_, namespacedef_ and ' ' + namespacedef_ or '', )) + already_processed = [] + self.exportAttributes(outfile, level, already_processed, namespace_, name_='BgpRouterParams') + if self.hasContent_(): + outfile.write('>%s' % (eol_, )) + self.exportChildren(outfile, level + 1, namespace_, name_, pretty_print=pretty_print) + showIndent(outfile, level, pretty_print) + outfile.write('</%s%s>%s' % (namespace_, name_, eol_)) + else: + outfile.write('/>%s' % (eol_, )) + def exportAttributes(self, outfile, level, already_processed, namespace_='', name_='BgpRouterParams'): + pass + def exportChildren(self, outfile, level, namespace_='', name_='BgpRouterParams', fromsubclass_=False, pretty_print=True): + if pretty_print: + eol_ = '\n' + else: + eol_ = '' + if self.vendor is not None: + showIndent(outfile, level, pretty_print) + outfile.write('<%svendor>%s</%svendor>%s' % (namespace_, self.gds_format_string(quote_xml(self.vendor).encode(ExternalEncoding), input_name='vendor'), namespace_, eol_)) + if self.autonomous_system is not None: + showIndent(outfile, level, pretty_print) + outfile.write('<%sautonomous-system>%s</%sautonomous-system>%s' % (namespace_, self.gds_format_integer(self.autonomous_system, input_name='autonomous-system'), namespace_, eol_)) + if self.identifier is not None: + showIndent(outfile, level, pretty_print) + outfile.write('<%sidentifier>%s</%sidentifier>%s' % (namespace_, self.gds_format_string(quote_xml(self.identifier).encode(ExternalEncoding), input_name='identifier'), namespace_, eol_)) + if self.address is not None: + showIndent(outfile, level, pretty_print) + outfile.write('<%saddress>%s</%saddress>%s' % (namespace_, self.gds_format_string(quote_xml(self.address).encode(ExternalEncoding), input_name='address'), namespace_, eol_)) + if self.port is not None: + showIndent(outfile, level, pretty_print) + outfile.write('<%sport>%s</%sport>%s' % (namespace_, self.gds_format_integer(self.port, input_name='port'), namespace_, eol_)) + if self.hold_time is not None: + showIndent(outfile, level, pretty_print) + outfile.write('<%shold-time>%s</%shold-time>%s' % (namespace_, self.gds_format_integer(self.hold_time, input_name='hold-time'), namespace_, eol_)) + if self.address_families is not None: + self.address_families.export(outfile, level, namespace_, name_='address-families', pretty_print=pretty_print) + if self.auth_data is not None: + self.auth_data.export(outfile, level, namespace_, name_='auth-data', pretty_print=pretty_print) + if self.local_autonomous_system is not None: + showIndent(outfile, level, pretty_print) + outfile.write('<%slocal-autonomous-system>%s</%slocal-autonomous-system>%s' % (namespace_, self.gds_format_integer(self.local_autonomous_system, input_name='local-autonomous-system'), namespace_, eol_)) + def hasContent_(self): + if ( + self.vendor is not None or + self.autonomous_system is not None or + self.identifier is not None or + self.address is not None or + self.port is not None or + self.hold_time is not None or + self.address_families is not None or + self.auth_data is not None or + self.local_autonomous_system is not None + ): + return True + else: + return False + def exportLiteral(self, outfile, level, name_='BgpRouterParams'): + level += 1 + self.exportLiteralAttributes(outfile, level, [], name_) + if self.hasContent_(): + self.exportLiteralChildren(outfile, level, name_) + def exportLiteralAttributes(self, outfile, level, already_processed, name_): + pass + def exportLiteralChildren(self, outfile, level, name_): + if self.vendor is not None: + showIndent(outfile, level) + outfile.write('vendor=%s,\n' % quote_python(self.vendor).encode(ExternalEncoding)) + if self.autonomous_system is not None: + showIndent(outfile, level) + outfile.write('autonomous_system=%d,\n' % self.autonomous_system) + if self.identifier is not None: + showIndent(outfile, level) + outfile.write('identifier=%s,\n' % quote_python(self.identifier).encode(ExternalEncoding)) + if self.address is not None: + showIndent(outfile, level) + outfile.write('address=%s,\n' % quote_python(self.address).encode(ExternalEncoding)) + if self.port is not None: + showIndent(outfile, level) + outfile.write('port=%d,\n' % self.port) + if self.hold_time is not None: + showIndent(outfile, level) + outfile.write('hold_time=%d,\n' % self.hold_time) + if self.address_families is not None: + showIndent(outfile, level) + outfile.write('address_families=model_.AddressFamilies(\n') + self.address_families.exportLiteral(outfile, level, name_='address_families') + showIndent(outfile, level) + outfile.write('),\n') + if self.auth_data is not None: + showIndent(outfile, level) + outfile.write('auth_data=model_.AuthenticationData(\n') + self.auth_data.exportLiteral(outfile, level, name_='auth_data') + showIndent(outfile, level) + outfile.write('),\n') + if self.local_autonomous_system is not None: + showIndent(outfile, level) + outfile.write('local_autonomous_system=%d,\n' % self.local_autonomous_system) + def exportDict(self, name_='BgpRouterParams'): + obj_json = json.dumps(self, default=lambda o: dict((k, v) for k, v in o.__dict__.iteritems())) + obj_dict = json.loads(obj_json) + return {name_: obj_dict} + def build(self, node): + self.buildAttributes(node, node.attrib, []) + for child in node: + nodeName_ = Tag_pattern_.match(child.tag).groups()[-1] + self.buildChildren(child, node, nodeName_) + def buildAttributes(self, node, attrs, already_processed): + pass + def buildChildren(self, child_, node, nodeName_, fromsubclass_=False): + if nodeName_ == 'vendor': + vendor_ = child_.text + vendor_ = self.gds_validate_string(vendor_, node, 'vendor') + self.vendor = vendor_ + elif nodeName_ == 'autonomous-system': + sval_ = child_.text + try: + ival_ = int(sval_) + except (TypeError, ValueError), exp: + raise_parse_error(child_, 'requires integer: %s' % exp) + ival_ = self.gds_validate_integer(ival_, node, 'autonomous_system') + self.autonomous_system = ival_ + elif nodeName_ == 'identifier': + identifier_ = child_.text + identifier_ = self.gds_validate_string(identifier_, node, 'identifier') + self.identifier = identifier_ + self.validate_IpAddress(self.identifier) # validate type IpAddress + elif nodeName_ == 'address': + address_ = child_.text + address_ = self.gds_validate_string(address_, node, 'address') + self.address = address_ + self.validate_IpAddress(self.address) # validate type IpAddress + elif nodeName_ == 'port': + sval_ = child_.text + try: + ival_ = int(sval_) + except (TypeError, ValueError), exp: + raise_parse_error(child_, 'requires integer: %s' % exp) + ival_ = self.gds_validate_integer(ival_, node, 'port') + self.port = ival_ + elif nodeName_ == 'hold-time': + sval_ = child_.text + try: + ival_ = int(sval_) + except (TypeError, ValueError), exp: + raise_parse_error(child_, 'requires integer: %s' % exp) + ival_ = self.gds_validate_integer(ival_, node, 'hold_time') + self.hold_time = ival_ + self.validate_BgpHoldTime(self.hold_time) # validate type BgpHoldTime + elif nodeName_ == 'address-families': + obj_ = AddressFamilies.factory() + obj_.build(child_) + self.set_address_families(obj_) + elif nodeName_ == 'auth-data': + obj_ = AuthenticationData.factory() + obj_.build(child_) + self.set_auth_data(obj_) + elif nodeName_ == 'local-autonomous-system': + sval_ = child_.text + try: + ival_ = int(sval_) + except (TypeError, ValueError), exp: + raise_parse_error(child_, 'requires integer: %s' % exp) + ival_ = self.gds_validate_integer(ival_, node, 'local_autonomous_system') + self.local_autonomous_system = ival_ +# end class BgpRouterParams + + +class instance_bgp_router(GeneratedsSuper): + """ + instance_bgp_router class definition from :doc:`vnc_cfg.xsd` + """ + subclass = None + superclass = None + def __init__(self, **kwargs): + pass + def factory(*args_, **kwargs_): + if instance_bgp_router.subclass: + return instance_bgp_router.subclass(*args_, **kwargs_) + else: + return instance_bgp_router(*args_, **kwargs_) + factory = staticmethod(factory) + def __eq__(self, other): return True + def __ne__(self, other): return False + @classmethod + def populate (cls, *a, **kwa): + obj = cls (*a, **kwa) + return obj + def export(self, outfile, level=1, namespace_='', name_='instance-bgp-router', namespacedef_='', pretty_print=True): + if pretty_print: + eol_ = '\n' + else: + eol_ = '' + showIndent(outfile, level, pretty_print) + outfile.write('<%s%s%s' % (namespace_, name_, namespacedef_ and ' ' + namespacedef_ or '', )) + already_processed = [] + self.exportAttributes(outfile, level, already_processed, namespace_, name_='instance-bgp-router') + if self.hasContent_(): + outfile.write('>%s' % (eol_, )) + self.exportChildren(outfile, level + 1, namespace_, name_, pretty_print=pretty_print) + outfile.write('</%s%s>%s' % (namespace_, name_, eol_)) + else: + outfile.write('/>%s' % (eol_, )) + def exportAttributes(self, outfile, level, already_processed, namespace_='', name_='instance-bgp-router'): + pass + def exportChildren(self, outfile, level, namespace_='', name_='instance-bgp-router', fromsubclass_=False, pretty_print=True): + pass + def hasContent_(self): + if ( + + ): + return True + else: + return False + def exportLiteral(self, outfile, level, name_='instance-bgp-router'): + level += 1 + self.exportLiteralAttributes(outfile, level, [], name_) + if self.hasContent_(): + self.exportLiteralChildren(outfile, level, name_) + def exportLiteralAttributes(self, outfile, level, already_processed, name_): + pass + def exportLiteralChildren(self, outfile, level, name_): + pass + def exportDict(self, name_='instance-bgp-router'): + obj_json = json.dumps(self, default=lambda o: dict((k, v) for k, v in o.__dict__.iteritems())) + obj_dict = json.loads(obj_json) + return {name_: obj_dict} + def build(self, node): + self.buildAttributes(node, node.attrib, []) + for child in node: + nodeName_ = Tag_pattern_.match(child.tag).groups()[-1] + self.buildChildren(child, node, nodeName_) + def buildAttributes(self, node, attrs, already_processed): + pass + def buildChildren(self, child_, node, nodeName_, fromsubclass_=False): + pass +# end class instance_bgp_router + + +class BgpPeeringAttributes(GeneratedsSuper): + """ + BgpPeeringAttributes class definition from :doc:`vnc_cfg.xsd` + """ + subclass = None + superclass = None + def __init__(self, session=None, **kwargs): + if (session is None) or (session == []): + self.session = [] + else: + if isinstance(session[0], dict): + objs = [BgpSession(**elem) for elem in session] + self.session = objs + else: + self.session = session + def factory(*args_, **kwargs_): + if BgpPeeringAttributes.subclass: + return BgpPeeringAttributes.subclass(*args_, **kwargs_) + else: + return BgpPeeringAttributes(*args_, **kwargs_) + factory = staticmethod(factory) + def get_session(self): return self.session + def set_session(self, session): self.session = session + def add_session(self, value): self.session.append(value) + def insert_session(self, index, value): self.session[index] = value + def delete_session(self, value): self.session.remove(value) + def __eq__(self, other): + if isinstance(other, self.__class__): + return (self.session == other.session) + return NotImplemented + def __ne__(self, other): + if isinstance(other, self.__class__): + return not self.__eq__(other) + return NotImplemented + + @classmethod + def populate (cls, *a, **kwa): + obj = cls (*a, **kwa) + obj.set_session ([BgpSession.populate ()]) + return obj + def export(self, outfile, level=1, namespace_='', name_='BgpPeeringAttributes', namespacedef_='', pretty_print=True): + if pretty_print: + eol_ = '\n' + else: + eol_ = '' + showIndent(outfile, level, pretty_print) + outfile.write('<%s%s%s' % (namespace_, name_, namespacedef_ and ' ' + namespacedef_ or '', )) + already_processed = [] + self.exportAttributes(outfile, level, already_processed, namespace_, name_='BgpPeeringAttributes') + if self.hasContent_(): + outfile.write('>%s' % (eol_, )) + self.exportChildren(outfile, level + 1, namespace_, name_, pretty_print=pretty_print) + showIndent(outfile, level, pretty_print) + outfile.write('</%s%s>%s' % (namespace_, name_, eol_)) + else: + outfile.write('/>%s' % (eol_, )) + def exportAttributes(self, outfile, level, already_processed, namespace_='', name_='BgpPeeringAttributes'): + pass + def exportChildren(self, outfile, level, namespace_='', name_='BgpPeeringAttributes', fromsubclass_=False, pretty_print=True): + if pretty_print: + eol_ = '\n' + else: + eol_ = '' + for session_ in self.session: + if isinstance(session_, dict): + session_ = BgpSession(**session_) + session_.export(outfile, level, namespace_, name_='session', pretty_print=pretty_print) + def hasContent_(self): + if ( + self.session + ): + return True + else: + return False + def exportLiteral(self, outfile, level, name_='BgpPeeringAttributes'): + level += 1 + self.exportLiteralAttributes(outfile, level, [], name_) + if self.hasContent_(): + self.exportLiteralChildren(outfile, level, name_) + def exportLiteralAttributes(self, outfile, level, already_processed, name_): + pass + def exportLiteralChildren(self, outfile, level, name_): + showIndent(outfile, level) + outfile.write('session=[\n') + level += 1 + for session_ in self.session: + showIndent(outfile, level) + outfile.write('model_.BgpSession(\n') + session_.exportLiteral(outfile, level, name_='BgpSession') + showIndent(outfile, level) + outfile.write('),\n') + level -= 1 + showIndent(outfile, level) + outfile.write('],\n') + def exportDict(self, name_='BgpPeeringAttributes'): + obj_json = json.dumps(self, default=lambda o: dict((k, v) for k, v in o.__dict__.iteritems())) + obj_dict = json.loads(obj_json) + return {name_: obj_dict} + def build(self, node): + self.buildAttributes(node, node.attrib, []) + for child in node: + nodeName_ = Tag_pattern_.match(child.tag).groups()[-1] + self.buildChildren(child, node, nodeName_) + def buildAttributes(self, node, attrs, already_processed): + pass + def buildChildren(self, child_, node, nodeName_, fromsubclass_=False): + if nodeName_ == 'session': + obj_ = BgpSession.factory() + obj_.build(child_) + self.session.append(obj_) +# end class BgpPeeringAttributes + + +class BgpSession(GeneratedsSuper): + """ + BgpSession class definition from :doc:`vnc_cfg.xsd` + """ + subclass = None + superclass = None + def __init__(self, uuid=None, attributes=None, **kwargs): + self.uuid = uuid + if (attributes is None) or (attributes == []): + self.attributes = [] + else: + if isinstance(attributes[0], dict): + objs = [BgpSessionAttributes(**elem) for elem in attributes] + self.attributes = objs + else: + self.attributes = attributes + def factory(*args_, **kwargs_): + if BgpSession.subclass: + return BgpSession.subclass(*args_, **kwargs_) + else: + return BgpSession(*args_, **kwargs_) + factory = staticmethod(factory) + def get_uuid(self): return self.uuid + def set_uuid(self, uuid): self.uuid = uuid + def get_attributes(self): return self.attributes + def set_attributes(self, attributes): self.attributes = attributes + def add_attributes(self, value): self.attributes.append(value) + def insert_attributes(self, index, value): self.attributes[index] = value + def delete_attributes(self, value): self.attributes.remove(value) + def __eq__(self, other): + if isinstance(other, self.__class__): + return (self.uuid == other.uuid and + self.attributes == other.attributes) + return NotImplemented + def __ne__(self, other): + if isinstance(other, self.__class__): + return not self.__eq__(other) + return NotImplemented + + @classmethod + def populate (cls, *a, **kwa): + obj = cls (*a, **kwa) + obj.set_uuid (obj.populate_string ("uuid")) + obj.set_attributes ([BgpSessionAttributes.populate ()]) + return obj + def export(self, outfile, level=1, namespace_='', name_='BgpSession', namespacedef_='', pretty_print=True): + if pretty_print: + eol_ = '\n' + else: + eol_ = '' + showIndent(outfile, level, pretty_print) + outfile.write('<%s%s%s' % (namespace_, name_, namespacedef_ and ' ' + namespacedef_ or '', )) + already_processed = [] + self.exportAttributes(outfile, level, already_processed, namespace_, name_='BgpSession') + if self.hasContent_(): + outfile.write('>%s' % (eol_, )) + self.exportChildren(outfile, level + 1, namespace_, name_, pretty_print=pretty_print) + showIndent(outfile, level, pretty_print) + outfile.write('</%s%s>%s' % (namespace_, name_, eol_)) + else: + outfile.write('/>%s' % (eol_, )) + def exportAttributes(self, outfile, level, already_processed, namespace_='', name_='BgpSession'): + pass + def exportChildren(self, outfile, level, namespace_='', name_='BgpSession', fromsubclass_=False, pretty_print=True): + if pretty_print: + eol_ = '\n' + else: + eol_ = '' + if self.uuid is not None: + showIndent(outfile, level, pretty_print) + outfile.write('<%suuid>%s</%suuid>%s' % (namespace_, self.gds_format_string(quote_xml(self.uuid).encode(ExternalEncoding), input_name='uuid'), namespace_, eol_)) + for attributes_ in self.attributes: + if isinstance(attributes_, dict): + attributes_ = BgpSessionAttributes(**attributes_) + attributes_.export(outfile, level, namespace_, name_='attributes', pretty_print=pretty_print) + def hasContent_(self): + if ( + self.uuid is not None or + self.attributes + ): + return True + else: + return False + def exportLiteral(self, outfile, level, name_='BgpSession'): + level += 1 + self.exportLiteralAttributes(outfile, level, [], name_) + if self.hasContent_(): + self.exportLiteralChildren(outfile, level, name_) + def exportLiteralAttributes(self, outfile, level, already_processed, name_): + pass + def exportLiteralChildren(self, outfile, level, name_): + if self.uuid is not None: + showIndent(outfile, level) + outfile.write('uuid=%s,\n' % quote_python(self.uuid).encode(ExternalEncoding)) + showIndent(outfile, level) + outfile.write('attributes=[\n') + level += 1 + for attributes_ in self.attributes: + showIndent(outfile, level) + outfile.write('model_.BgpSessionAttributes(\n') + attributes_.exportLiteral(outfile, level, name_='BgpSessionAttributes') + showIndent(outfile, level) + outfile.write('),\n') + level -= 1 + showIndent(outfile, level) + outfile.write('],\n') + def exportDict(self, name_='BgpSession'): + obj_json = json.dumps(self, default=lambda o: dict((k, v) for k, v in o.__dict__.iteritems())) + obj_dict = json.loads(obj_json) + return {name_: obj_dict} + def build(self, node): + self.buildAttributes(node, node.attrib, []) + for child in node: + nodeName_ = Tag_pattern_.match(child.tag).groups()[-1] + self.buildChildren(child, node, nodeName_) + def buildAttributes(self, node, attrs, already_processed): + pass + def buildChildren(self, child_, node, nodeName_, fromsubclass_=False): + if nodeName_ == 'uuid': + uuid_ = child_.text + uuid_ = self.gds_validate_string(uuid_, node, 'uuid') + self.uuid = uuid_ + elif nodeName_ == 'attributes': + obj_ = BgpSessionAttributes.factory() + obj_.build(child_) + self.attributes.append(obj_) +# end class BgpSession + + +class BgpSessionAttributes(GeneratedsSuper): + """ + BgpSessionAttributes class definition from :doc:`vnc_cfg.xsd` + """ + subclass = None + superclass = None + def __init__(self, bgp_router=None, address_families=None, auth_data=None, **kwargs): + self.bgp_router = bgp_router + if isinstance(address_families, dict): + obj = AddressFamilies(**address_families) + self.address_families = obj + else: + self.address_families = address_families + if isinstance(auth_data, dict): + obj = AuthenticationData(**auth_data) + self.auth_data = obj + else: + self.auth_data = auth_data + def factory(*args_, **kwargs_): + if BgpSessionAttributes.subclass: + return BgpSessionAttributes.subclass(*args_, **kwargs_) + else: + return BgpSessionAttributes(*args_, **kwargs_) + factory = staticmethod(factory) + def get_bgp_router(self): return self.bgp_router + def set_bgp_router(self, bgp_router): self.bgp_router = bgp_router + def get_address_families(self): return self.address_families + def set_address_families(self, address_families): self.address_families = address_families + def get_auth_data(self): return self.auth_data + def set_auth_data(self, auth_data): self.auth_data = auth_data + def __eq__(self, other): + if isinstance(other, self.__class__): + return (self.bgp_router == other.bgp_router and + self.address_families == other.address_families and + self.auth_data == other.auth_data) + return NotImplemented + def __ne__(self, other): + if isinstance(other, self.__class__): + return not self.__eq__(other) + return NotImplemented + + @classmethod + def populate (cls, *a, **kwa): + obj = cls (*a, **kwa) + obj.set_bgp_router (obj.populate_string ("bgp_router")) + obj.set_address_families (AddressFamilies.populate ()) + obj.set_auth_data (AuthenticationData.populate ()) + return obj + def export(self, outfile, level=1, namespace_='', name_='BgpSessionAttributes', namespacedef_='', pretty_print=True): + if pretty_print: + eol_ = '\n' + else: + eol_ = '' + showIndent(outfile, level, pretty_print) + outfile.write('<%s%s%s' % (namespace_, name_, namespacedef_ and ' ' + namespacedef_ or '', )) + already_processed = [] + self.exportAttributes(outfile, level, already_processed, namespace_, name_='BgpSessionAttributes') + if self.hasContent_(): + outfile.write('>%s' % (eol_, )) + self.exportChildren(outfile, level + 1, namespace_, name_, pretty_print=pretty_print) + showIndent(outfile, level, pretty_print) + outfile.write('</%s%s>%s' % (namespace_, name_, eol_)) + else: + outfile.write('/>%s' % (eol_, )) + def exportAttributes(self, outfile, level, already_processed, namespace_='', name_='BgpSessionAttributes'): + pass + def exportChildren(self, outfile, level, namespace_='', name_='BgpSessionAttributes', fromsubclass_=False, pretty_print=True): + if pretty_print: + eol_ = '\n' + else: + eol_ = '' + if self.bgp_router is not None: + showIndent(outfile, level, pretty_print) + outfile.write('<%sbgp-router>%s</%sbgp-router>%s' % (namespace_, self.gds_format_string(quote_xml(self.bgp_router).encode(ExternalEncoding), input_name='bgp-router'), namespace_, eol_)) + if self.address_families is not None: + self.address_families.export(outfile, level, namespace_, name_='address-families', pretty_print=pretty_print) + if self.auth_data is not None: + self.auth_data.export(outfile, level, namespace_, name_='auth-data', pretty_print=pretty_print) + def hasContent_(self): + if ( + self.bgp_router is not None or + self.address_families is not None or + self.auth_data is not None + ): + return True + else: + return False + def exportLiteral(self, outfile, level, name_='BgpSessionAttributes'): + level += 1 + self.exportLiteralAttributes(outfile, level, [], name_) + if self.hasContent_(): + self.exportLiteralChildren(outfile, level, name_) + def exportLiteralAttributes(self, outfile, level, already_processed, name_): + pass + def exportLiteralChildren(self, outfile, level, name_): + if self.bgp_router is not None: + showIndent(outfile, level) + outfile.write('bgp_router=%s,\n' % quote_python(self.bgp_router).encode(ExternalEncoding)) + if self.address_families is not None: + showIndent(outfile, level) + outfile.write('address_families=model_.AddressFamilies(\n') + self.address_families.exportLiteral(outfile, level, name_='address_families') + showIndent(outfile, level) + outfile.write('),\n') + if self.auth_data is not None: + showIndent(outfile, level) + outfile.write('auth_data=model_.AuthenticationData(\n') + self.auth_data.exportLiteral(outfile, level, name_='auth_data') + showIndent(outfile, level) + outfile.write('),\n') + def exportDict(self, name_='BgpSessionAttributes'): + obj_json = json.dumps(self, default=lambda o: dict((k, v) for k, v in o.__dict__.iteritems())) + obj_dict = json.loads(obj_json) + return {name_: obj_dict} + def build(self, node): + self.buildAttributes(node, node.attrib, []) + for child in node: + nodeName_ = Tag_pattern_.match(child.tag).groups()[-1] + self.buildChildren(child, node, nodeName_) + def buildAttributes(self, node, attrs, already_processed): + pass + def buildChildren(self, child_, node, nodeName_, fromsubclass_=False): + if nodeName_ == 'bgp-router': + bgp_router_ = child_.text + bgp_router_ = self.gds_validate_string(bgp_router_, node, 'bgp_router') + self.bgp_router = bgp_router_ + elif nodeName_ == 'address-families': + obj_ = AddressFamilies.factory() + obj_.build(child_) + self.set_address_families(obj_) + elif nodeName_ == 'auth-data': + obj_ = AuthenticationData.factory() + obj_.build(child_) + self.set_auth_data(obj_) +# end class BgpSessionAttributes + + +class AddressFamilies(GeneratedsSuper): + """ + AddressFamilies class definition from :doc:`vnc_cfg.xsd` + """ + subclass = None + superclass = None + def __init__(self, family=None, **kwargs): + if (family is None) or (family == []): + self.family = [] + else: + self.family = family + def factory(*args_, **kwargs_): + if AddressFamilies.subclass: + return AddressFamilies.subclass(*args_, **kwargs_) + else: + return AddressFamilies(*args_, **kwargs_) + factory = staticmethod(factory) + def get_family(self): return self.family + def set_family(self, family): self.family = family + def add_family(self, value): self.family.append(value) + def insert_family(self, index, value): self.family[index] = value + def delete_family(self, value): self.family.remove(value) + def validate_AddressFamily(self, value): + # Validate type AddressFamily, a restriction on xsd:string. + error = False + if isinstance(value, list): + error = set(value) - set([u'inet', u'inet-vpn', u'e-vpn', u'erm-vpn', u'route-target', u'inet6-vpn']) + else: + error = value not in [u'inet', u'inet-vpn', u'e-vpn', u'erm-vpn', u'route-target', u'inet6-vpn'] + if error: + raise ValueError("AddressFamily must be one of [u'inet', u'inet-vpn', u'e-vpn', u'erm-vpn', u'route-target', u'inet6-vpn']") + def __eq__(self, other): + if isinstance(other, self.__class__): + return (self.family == other.family) + return NotImplemented + def __ne__(self, other): + if isinstance(other, self.__class__): + return not self.__eq__(other) + return NotImplemented + + @classmethod + def populate (cls, *a, **kwa): + obj = cls (*a, **kwa) + obj.set_family ([obj.populate_string ("family")]) + return obj + def export(self, outfile, level=1, namespace_='', name_='AddressFamilies', namespacedef_='', pretty_print=True): + if pretty_print: + eol_ = '\n' + else: + eol_ = '' + showIndent(outfile, level, pretty_print) + outfile.write('<%s%s%s' % (namespace_, name_, namespacedef_ and ' ' + namespacedef_ or '', )) + already_processed = [] + self.exportAttributes(outfile, level, already_processed, namespace_, name_='AddressFamilies') + if self.hasContent_(): + outfile.write('>%s' % (eol_, )) + self.exportChildren(outfile, level + 1, namespace_, name_, pretty_print=pretty_print) + showIndent(outfile, level, pretty_print) + outfile.write('</%s%s>%s' % (namespace_, name_, eol_)) + else: + outfile.write('/>%s' % (eol_, )) + def exportAttributes(self, outfile, level, already_processed, namespace_='', name_='AddressFamilies'): + pass + def exportChildren(self, outfile, level, namespace_='', name_='AddressFamilies', fromsubclass_=False, pretty_print=True): + if pretty_print: + eol_ = '\n' + else: + eol_ = '' + for family_ in self.family: + showIndent(outfile, level, pretty_print) + outfile.write('<%sfamily>%s</%sfamily>%s' % (namespace_, self.gds_format_string(quote_xml(family_).encode(ExternalEncoding), input_name='family'), namespace_, eol_)) + def hasContent_(self): + if ( + self.family + ): + return True + else: + return False + def exportLiteral(self, outfile, level, name_='AddressFamilies'): + level += 1 + self.exportLiteralAttributes(outfile, level, [], name_) + if self.hasContent_(): + self.exportLiteralChildren(outfile, level, name_) + def exportLiteralAttributes(self, outfile, level, already_processed, name_): + pass + def exportLiteralChildren(self, outfile, level, name_): + showIndent(outfile, level) + outfile.write('family=[\n') + level += 1 + for family_ in self.family: + showIndent(outfile, level) + outfile.write('%s,\n' % quote_python(family_).encode(ExternalEncoding)) + level -= 1 + showIndent(outfile, level) + outfile.write('],\n') + def exportDict(self, name_='AddressFamilies'): + obj_json = json.dumps(self, default=lambda o: dict((k, v) for k, v in o.__dict__.iteritems())) + obj_dict = json.loads(obj_json) + return {name_: obj_dict} + def build(self, node): + self.buildAttributes(node, node.attrib, []) + for child in node: + nodeName_ = Tag_pattern_.match(child.tag).groups()[-1] + self.buildChildren(child, node, nodeName_) + def buildAttributes(self, node, attrs, already_processed): + pass + def buildChildren(self, child_, node, nodeName_, fromsubclass_=False): + if nodeName_ == 'family': + family_ = child_.text + family_ = self.gds_validate_string(family_, node, 'family') + self.family.append(family_) + self.validate_AddressFamily(self.family) # validate type AddressFamily +# end class AddressFamilies + + +class AuthenticationKeyItem(GeneratedsSuper): + """ + AuthenticationKeyItem class definition from :doc:`vnc_cfg.xsd` + """ + subclass = None + superclass = None + def __init__(self, key_id=None, key=None, **kwargs): + self.key_id = key_id + self.key = key + def factory(*args_, **kwargs_): + if AuthenticationKeyItem.subclass: + return AuthenticationKeyItem.subclass(*args_, **kwargs_) + else: + return AuthenticationKeyItem(*args_, **kwargs_) + factory = staticmethod(factory) + def get_key_id(self): return self.key_id + def set_key_id(self, key_id): self.key_id = key_id + def validate_AuthenticationKeyId(self, value): + # Validate type AuthenticationKeyId, a restriction on xsd:integer. + error = False + if isinstance(value, list): + v_int = map(int, value) + v1, v2 = min(v_int), max(v_int) + else: + v1, v2 = int(value), int(value) + error = (0 > v1) + error |= (v2 > 63) + if error: + raise ValueError("AuthenticationKeyId must be in the range 0-63") + def get_key(self): return self.key + def set_key(self, key): self.key = key + def __eq__(self, other): + if isinstance(other, self.__class__): + return (self.key_id == other.key_id and + self.key == other.key) + return NotImplemented + def __ne__(self, other): + if isinstance(other, self.__class__): + return not self.__eq__(other) + return NotImplemented + + @classmethod + def populate (cls, *a, **kwa): + obj = cls (*a, **kwa) + obj.set_key_id (obj.populate_integer ("key_id")) + obj.set_key (obj.populate_string ("key")) + return obj + def export(self, outfile, level=1, namespace_='', name_='AuthenticationKeyItem', namespacedef_='', pretty_print=True): + if pretty_print: + eol_ = '\n' + else: + eol_ = '' + showIndent(outfile, level, pretty_print) + outfile.write('<%s%s%s' % (namespace_, name_, namespacedef_ and ' ' + namespacedef_ or '', )) + already_processed = [] + self.exportAttributes(outfile, level, already_processed, namespace_, name_='AuthenticationKeyItem') + if self.hasContent_(): + outfile.write('>%s' % (eol_, )) + self.exportChildren(outfile, level + 1, namespace_, name_, pretty_print=pretty_print) + showIndent(outfile, level, pretty_print) + outfile.write('</%s%s>%s' % (namespace_, name_, eol_)) + else: + outfile.write('/>%s' % (eol_, )) + def exportAttributes(self, outfile, level, already_processed, namespace_='', name_='AuthenticationKeyItem'): + pass + def exportChildren(self, outfile, level, namespace_='', name_='AuthenticationKeyItem', fromsubclass_=False, pretty_print=True): + if pretty_print: + eol_ = '\n' + else: + eol_ = '' + if self.key_id is not None: + showIndent(outfile, level, pretty_print) + outfile.write('<%skey-id>%s</%skey-id>%s' % (namespace_, self.gds_format_integer(self.key_id, input_name='key-id'), namespace_, eol_)) + if self.key is not None: + showIndent(outfile, level, pretty_print) + outfile.write('<%skey>%s</%skey>%s' % (namespace_, self.gds_format_string(quote_xml(self.key).encode(ExternalEncoding), input_name='key'), namespace_, eol_)) + def hasContent_(self): + if ( + self.key_id is not None or + self.key is not None + ): + return True + else: + return False + def exportLiteral(self, outfile, level, name_='AuthenticationKeyItem'): + level += 1 + self.exportLiteralAttributes(outfile, level, [], name_) + if self.hasContent_(): + self.exportLiteralChildren(outfile, level, name_) + def exportLiteralAttributes(self, outfile, level, already_processed, name_): + pass + def exportLiteralChildren(self, outfile, level, name_): + if self.key_id is not None: + showIndent(outfile, level) + outfile.write('key_id=%d,\n' % self.key_id) + if self.key is not None: + showIndent(outfile, level) + outfile.write('key=%s,\n' % quote_python(self.key).encode(ExternalEncoding)) + def exportDict(self, name_='AuthenticationKeyItem'): + obj_json = json.dumps(self, default=lambda o: dict((k, v) for k, v in o.__dict__.iteritems())) + obj_dict = json.loads(obj_json) + return {name_: obj_dict} + def build(self, node): + self.buildAttributes(node, node.attrib, []) + for child in node: + nodeName_ = Tag_pattern_.match(child.tag).groups()[-1] + self.buildChildren(child, node, nodeName_) + def buildAttributes(self, node, attrs, already_processed): + pass + def buildChildren(self, child_, node, nodeName_, fromsubclass_=False): + if nodeName_ == 'key-id': + sval_ = child_.text + try: + ival_ = int(sval_) + except (TypeError, ValueError), exp: + raise_parse_error(child_, 'requires integer: %s' % exp) + ival_ = self.gds_validate_integer(ival_, node, 'key_id') + self.key_id = ival_ + self.validate_AuthenticationKeyId(self.key_id) # validate type AuthenticationKeyId + elif nodeName_ == 'key': + key_ = child_.text + key_ = self.gds_validate_string(key_, node, 'key') + self.key = key_ +# end class AuthenticationKeyItem + + +class AuthenticationData(GeneratedsSuper): + """ + AuthenticationData class definition from :doc:`vnc_cfg.xsd` + """ + subclass = None + superclass = None + def __init__(self, key_type=None, key_items=None, **kwargs): + self.key_type = key_type + if (key_items is None) or (key_items == []): + self.key_items = [] + else: + if isinstance(key_items[0], dict): + objs = [AuthenticationKeyItem(**elem) for elem in key_items] + self.key_items = objs + else: + self.key_items = key_items + def factory(*args_, **kwargs_): + if AuthenticationData.subclass: + return AuthenticationData.subclass(*args_, **kwargs_) + else: + return AuthenticationData(*args_, **kwargs_) + factory = staticmethod(factory) + def get_key_type(self): return self.key_type + def set_key_type(self, key_type): self.key_type = key_type + def validate_AuthenticationKeyType(self, value): + # Validate type AuthenticationKeyType, a restriction on xsd:string. + error = False + if isinstance(value, list): + error = set(value) - set([u'md5']) + else: + error = value not in [u'md5'] + if error: + raise ValueError("AuthenticationKeyType must be one of [u'md5']") + def get_key_items(self): return self.key_items + def set_key_items(self, key_items): self.key_items = key_items + def add_key_items(self, value): self.key_items.append(value) + def insert_key_items(self, index, value): self.key_items[index] = value + def delete_key_items(self, value): self.key_items.remove(value) + def __eq__(self, other): + if isinstance(other, self.__class__): + return (self.key_type == other.key_type and + self.key_items == other.key_items) + return NotImplemented + def __ne__(self, other): + if isinstance(other, self.__class__): + return not self.__eq__(other) + return NotImplemented + + @classmethod + def populate (cls, *a, **kwa): + obj = cls (*a, **kwa) + obj.set_key_type (obj.populate_string ("key_type")) + obj.set_key_items ([AuthenticationKeyItem.populate ()]) + return obj + def export(self, outfile, level=1, namespace_='', name_='AuthenticationData', namespacedef_='', pretty_print=True): + if pretty_print: + eol_ = '\n' + else: + eol_ = '' + showIndent(outfile, level, pretty_print) + outfile.write('<%s%s%s' % (namespace_, name_, namespacedef_ and ' ' + namespacedef_ or '', )) + already_processed = [] + self.exportAttributes(outfile, level, already_processed, namespace_, name_='AuthenticationData') + if self.hasContent_(): + outfile.write('>%s' % (eol_, )) + self.exportChildren(outfile, level + 1, namespace_, name_, pretty_print=pretty_print) + showIndent(outfile, level, pretty_print) + outfile.write('</%s%s>%s' % (namespace_, name_, eol_)) + else: + outfile.write('/>%s' % (eol_, )) + def exportAttributes(self, outfile, level, already_processed, namespace_='', name_='AuthenticationData'): + pass + def exportChildren(self, outfile, level, namespace_='', name_='AuthenticationData', fromsubclass_=False, pretty_print=True): + if pretty_print: + eol_ = '\n' + else: + eol_ = '' + if self.key_type is not None: + showIndent(outfile, level, pretty_print) + outfile.write('<%skey-type>%s</%skey-type>%s' % (namespace_, self.gds_format_string(quote_xml(self.key_type).encode(ExternalEncoding), input_name='key-type'), namespace_, eol_)) + for key_items_ in self.key_items: + if isinstance(key_items_, dict): + key_items_ = AuthenticationKeyItem(**key_items_) + key_items_.export(outfile, level, namespace_, name_='key-items', pretty_print=pretty_print) + def hasContent_(self): + if ( + self.key_type is not None or + self.key_items + ): + return True + else: + return False + def exportLiteral(self, outfile, level, name_='AuthenticationData'): + level += 1 + self.exportLiteralAttributes(outfile, level, [], name_) + if self.hasContent_(): + self.exportLiteralChildren(outfile, level, name_) + def exportLiteralAttributes(self, outfile, level, already_processed, name_): + pass + def exportLiteralChildren(self, outfile, level, name_): + if self.key_type is not None: + showIndent(outfile, level) + outfile.write('key_type=%s,\n' % quote_python(self.key_type).encode(ExternalEncoding)) + showIndent(outfile, level) + outfile.write('key_items=[\n') + level += 1 + for key_items_ in self.key_items: + showIndent(outfile, level) + outfile.write('model_.AuthenticationKeyItem(\n') + key_items_.exportLiteral(outfile, level, name_='AuthenticationKeyItem') + showIndent(outfile, level) + outfile.write('),\n') + level -= 1 + showIndent(outfile, level) + outfile.write('],\n') + def exportDict(self, name_='AuthenticationData'): + obj_json = json.dumps(self, default=lambda o: dict((k, v) for k, v in o.__dict__.iteritems())) + obj_dict = json.loads(obj_json) + return {name_: obj_dict} + def build(self, node): + self.buildAttributes(node, node.attrib, []) + for child in node: + nodeName_ = Tag_pattern_.match(child.tag).groups()[-1] + self.buildChildren(child, node, nodeName_) + def buildAttributes(self, node, attrs, already_processed): + pass + def buildChildren(self, child_, node, nodeName_, fromsubclass_=False): + if nodeName_ == 'key-type': + key_type_ = child_.text + key_type_ = self.gds_validate_string(key_type_, node, 'key_type') + self.key_type = key_type_ + self.validate_AuthenticationKeyType(self.key_type) # validate type AuthenticationKeyType + elif nodeName_ == 'key-items': + obj_ = AuthenticationKeyItem.factory() + obj_.build(child_) + self.key_items.append(obj_) +# end class AuthenticationData + + +class ServiceChainInfo(GeneratedsSuper): + """ + ServiceChainInfo class definition from :doc:`vnc_cfg.xsd` + """ + subclass = None + superclass = None + def __init__(self, routing_instance=None, prefix=None, service_chain_address=None, service_instance=None, source_routing_instance=None, **kwargs): + self.routing_instance = routing_instance + if (prefix is None) or (prefix == []): + self.prefix = [] + else: + self.prefix = prefix + self.service_chain_address = service_chain_address + self.service_instance = service_instance + self.source_routing_instance = source_routing_instance + def factory(*args_, **kwargs_): + if ServiceChainInfo.subclass: + return ServiceChainInfo.subclass(*args_, **kwargs_) + else: + return ServiceChainInfo(*args_, **kwargs_) + factory = staticmethod(factory) + def get_routing_instance(self): return self.routing_instance + def set_routing_instance(self, routing_instance): self.routing_instance = routing_instance + def get_prefix(self): return self.prefix + def set_prefix(self, prefix): self.prefix = prefix + def add_prefix(self, value): self.prefix.append(value) + def insert_prefix(self, index, value): self.prefix[index] = value + def delete_prefix(self, value): self.prefix.remove(value) + def get_service_chain_address(self): return self.service_chain_address + def set_service_chain_address(self, service_chain_address): self.service_chain_address = service_chain_address + def validate_IpAddress(self, value): + # Validate type IpAddress, a restriction on xsd:string. + pass + def get_service_instance(self): return self.service_instance + def set_service_instance(self, service_instance): self.service_instance = service_instance + def get_source_routing_instance(self): return self.source_routing_instance + def set_source_routing_instance(self, source_routing_instance): self.source_routing_instance = source_routing_instance + def __eq__(self, other): + if isinstance(other, self.__class__): + return (self.routing_instance == other.routing_instance and + self.prefix == other.prefix and + self.service_chain_address == other.service_chain_address and + self.service_instance == other.service_instance and + self.source_routing_instance == other.source_routing_instance) + return NotImplemented + def __ne__(self, other): + if isinstance(other, self.__class__): + return not self.__eq__(other) + return NotImplemented + + @classmethod + def populate (cls, *a, **kwa): + obj = cls (*a, **kwa) + obj.set_routing_instance (obj.populate_string ("routing_instance")) + obj.set_prefix ([obj.populate_string ("prefix")]) + obj.set_service_chain_address (obj.populate_string ("service_chain_address")) + obj.set_service_instance (obj.populate_string ("service_instance")) + obj.set_source_routing_instance (obj.populate_string ("source_routing_instance")) + return obj + def export(self, outfile, level=1, namespace_='', name_='ServiceChainInfo', namespacedef_='', pretty_print=True): + if pretty_print: + eol_ = '\n' + else: + eol_ = '' + showIndent(outfile, level, pretty_print) + outfile.write('<%s%s%s' % (namespace_, name_, namespacedef_ and ' ' + namespacedef_ or '', )) + already_processed = [] + self.exportAttributes(outfile, level, already_processed, namespace_, name_='ServiceChainInfo') + if self.hasContent_(): + outfile.write('>%s' % (eol_, )) + self.exportChildren(outfile, level + 1, namespace_, name_, pretty_print=pretty_print) + showIndent(outfile, level, pretty_print) + outfile.write('</%s%s>%s' % (namespace_, name_, eol_)) + else: + outfile.write('/>%s' % (eol_, )) + def exportAttributes(self, outfile, level, already_processed, namespace_='', name_='ServiceChainInfo'): + pass + def exportChildren(self, outfile, level, namespace_='', name_='ServiceChainInfo', fromsubclass_=False, pretty_print=True): + if pretty_print: + eol_ = '\n' + else: + eol_ = '' + if self.routing_instance is not None: + showIndent(outfile, level, pretty_print) + outfile.write('<%srouting-instance>%s</%srouting-instance>%s' % (namespace_, self.gds_format_string(quote_xml(self.routing_instance).encode(ExternalEncoding), input_name='routing-instance'), namespace_, eol_)) + for prefix_ in self.prefix: + showIndent(outfile, level, pretty_print) + outfile.write('<%sprefix>%s</%sprefix>%s' % (namespace_, self.gds_format_string(quote_xml(prefix_).encode(ExternalEncoding), input_name='prefix'), namespace_, eol_)) + if self.service_chain_address is not None: + showIndent(outfile, level, pretty_print) + outfile.write('<%sservice-chain-address>%s</%sservice-chain-address>%s' % (namespace_, self.gds_format_string(quote_xml(self.service_chain_address).encode(ExternalEncoding), input_name='service-chain-address'), namespace_, eol_)) + if self.service_instance is not None: + showIndent(outfile, level, pretty_print) + outfile.write('<%sservice-instance>%s</%sservice-instance>%s' % (namespace_, self.gds_format_string(quote_xml(self.service_instance).encode(ExternalEncoding), input_name='service-instance'), namespace_, eol_)) + if self.source_routing_instance is not None: + showIndent(outfile, level, pretty_print) + outfile.write('<%ssource-routing-instance>%s</%ssource-routing-instance>%s' % (namespace_, self.gds_format_string(quote_xml(self.source_routing_instance).encode(ExternalEncoding), input_name='source-routing-instance'), namespace_, eol_)) + def hasContent_(self): + if ( + self.routing_instance is not None or + self.prefix or + self.service_chain_address is not None or + self.service_instance is not None or + self.source_routing_instance is not None + ): + return True + else: + return False + def exportLiteral(self, outfile, level, name_='ServiceChainInfo'): + level += 1 + self.exportLiteralAttributes(outfile, level, [], name_) + if self.hasContent_(): + self.exportLiteralChildren(outfile, level, name_) + def exportLiteralAttributes(self, outfile, level, already_processed, name_): + pass + def exportLiteralChildren(self, outfile, level, name_): + if self.routing_instance is not None: + showIndent(outfile, level) + outfile.write('routing_instance=%s,\n' % quote_python(self.routing_instance).encode(ExternalEncoding)) + showIndent(outfile, level) + outfile.write('prefix=[\n') + level += 1 + for prefix_ in self.prefix: + showIndent(outfile, level) + outfile.write('%s,\n' % quote_python(prefix_).encode(ExternalEncoding)) + level -= 1 + showIndent(outfile, level) + outfile.write('],\n') + if self.service_chain_address is not None: + showIndent(outfile, level) + outfile.write('service_chain_address=%s,\n' % quote_python(self.service_chain_address).encode(ExternalEncoding)) + if self.service_instance is not None: + showIndent(outfile, level) + outfile.write('service_instance=%s,\n' % quote_python(self.service_instance).encode(ExternalEncoding)) + if self.source_routing_instance is not None: + showIndent(outfile, level) + outfile.write('source_routing_instance=%s,\n' % quote_python(self.source_routing_instance).encode(ExternalEncoding)) + def exportDict(self, name_='ServiceChainInfo'): + obj_json = json.dumps(self, default=lambda o: dict((k, v) for k, v in o.__dict__.iteritems())) + obj_dict = json.loads(obj_json) + return {name_: obj_dict} + def build(self, node): + self.buildAttributes(node, node.attrib, []) + for child in node: + nodeName_ = Tag_pattern_.match(child.tag).groups()[-1] + self.buildChildren(child, node, nodeName_) + def buildAttributes(self, node, attrs, already_processed): + pass + def buildChildren(self, child_, node, nodeName_, fromsubclass_=False): + if nodeName_ == 'routing-instance': + routing_instance_ = child_.text + routing_instance_ = self.gds_validate_string(routing_instance_, node, 'routing_instance') + self.routing_instance = routing_instance_ + elif nodeName_ == 'prefix': + prefix_ = child_.text + prefix_ = self.gds_validate_string(prefix_, node, 'prefix') + self.prefix.append(prefix_) + elif nodeName_ == 'service-chain-address': + service_chain_address_ = child_.text + service_chain_address_ = self.gds_validate_string(service_chain_address_, node, 'service_chain_address') + self.service_chain_address = service_chain_address_ + self.validate_IpAddress(self.service_chain_address) # validate type IpAddress + elif nodeName_ == 'service-instance': + service_instance_ = child_.text + service_instance_ = self.gds_validate_string(service_instance_, node, 'service_instance') + self.service_instance = service_instance_ + elif nodeName_ == 'source-routing-instance': + source_routing_instance_ = child_.text + source_routing_instance_ = self.gds_validate_string(source_routing_instance_, node, 'source_routing_instance') + self.source_routing_instance = source_routing_instance_ +# end class ServiceChainInfo + + +class StaticRouteType(GeneratedsSuper): + """ + StaticRouteType class definition from :doc:`vnc_cfg.xsd` + """ + subclass = None + superclass = None + def __init__(self, prefix=None, next_hop=None, route_target=None, **kwargs): + self.prefix = prefix + self.next_hop = next_hop + if (route_target is None) or (route_target == []): + self.route_target = [] + else: + self.route_target = route_target + def factory(*args_, **kwargs_): + if StaticRouteType.subclass: + return StaticRouteType.subclass(*args_, **kwargs_) + else: + return StaticRouteType(*args_, **kwargs_) + factory = staticmethod(factory) + def get_prefix(self): return self.prefix + def set_prefix(self, prefix): self.prefix = prefix + def get_next_hop(self): return self.next_hop + def set_next_hop(self, next_hop): self.next_hop = next_hop + def get_route_target(self): return self.route_target + def set_route_target(self, route_target): self.route_target = route_target + def add_route_target(self, value): self.route_target.append(value) + def insert_route_target(self, index, value): self.route_target[index] = value + def delete_route_target(self, value): self.route_target.remove(value) + def __eq__(self, other): + if isinstance(other, self.__class__): + return (self.prefix == other.prefix and + self.next_hop == other.next_hop and + self.route_target == other.route_target) + return NotImplemented + def __ne__(self, other): + if isinstance(other, self.__class__): + return not self.__eq__(other) + return NotImplemented + + @classmethod + def populate (cls, *a, **kwa): + obj = cls (*a, **kwa) + obj.set_prefix (obj.populate_string ("prefix")) + obj.set_next_hop (obj.populate_string ("next_hop")) + obj.set_route_target ([obj.populate_string ("route_target")]) + return obj + def export(self, outfile, level=1, namespace_='', name_='StaticRouteType', namespacedef_='', pretty_print=True): + if pretty_print: + eol_ = '\n' + else: + eol_ = '' + showIndent(outfile, level, pretty_print) + outfile.write('<%s%s%s' % (namespace_, name_, namespacedef_ and ' ' + namespacedef_ or '', )) + already_processed = [] + self.exportAttributes(outfile, level, already_processed, namespace_, name_='StaticRouteType') + if self.hasContent_(): + outfile.write('>%s' % (eol_, )) + self.exportChildren(outfile, level + 1, namespace_, name_, pretty_print=pretty_print) + showIndent(outfile, level, pretty_print) + outfile.write('</%s%s>%s' % (namespace_, name_, eol_)) + else: + outfile.write('/>%s' % (eol_, )) + def exportAttributes(self, outfile, level, already_processed, namespace_='', name_='StaticRouteType'): + pass + def exportChildren(self, outfile, level, namespace_='', name_='StaticRouteType', fromsubclass_=False, pretty_print=True): + if pretty_print: + eol_ = '\n' + else: + eol_ = '' + if self.prefix is not None: + showIndent(outfile, level, pretty_print) + outfile.write('<%sprefix>%s</%sprefix>%s' % (namespace_, self.gds_format_string(quote_xml(self.prefix).encode(ExternalEncoding), input_name='prefix'), namespace_, eol_)) + if self.next_hop is not None: + showIndent(outfile, level, pretty_print) + outfile.write('<%snext-hop>%s</%snext-hop>%s' % (namespace_, self.gds_format_string(quote_xml(self.next_hop).encode(ExternalEncoding), input_name='next-hop'), namespace_, eol_)) + for route_target_ in self.route_target: + showIndent(outfile, level, pretty_print) + outfile.write('<%sroute-target>%s</%sroute-target>%s' % (namespace_, self.gds_format_string(quote_xml(route_target_).encode(ExternalEncoding), input_name='route-target'), namespace_, eol_)) + def hasContent_(self): + if ( + self.prefix is not None or + self.next_hop is not None or + self.route_target + ): + return True + else: + return False + def exportLiteral(self, outfile, level, name_='StaticRouteType'): + level += 1 + self.exportLiteralAttributes(outfile, level, [], name_) + if self.hasContent_(): + self.exportLiteralChildren(outfile, level, name_) + def exportLiteralAttributes(self, outfile, level, already_processed, name_): + pass + def exportLiteralChildren(self, outfile, level, name_): + if self.prefix is not None: + showIndent(outfile, level) + outfile.write('prefix=%s,\n' % quote_python(self.prefix).encode(ExternalEncoding)) + if self.next_hop is not None: + showIndent(outfile, level) + outfile.write('next_hop=%s,\n' % quote_python(self.next_hop).encode(ExternalEncoding)) + showIndent(outfile, level) + outfile.write('route_target=[\n') + level += 1 + for route_target_ in self.route_target: + showIndent(outfile, level) + outfile.write('%s,\n' % quote_python(route_target_).encode(ExternalEncoding)) + level -= 1 + showIndent(outfile, level) + outfile.write('],\n') + def exportDict(self, name_='StaticRouteType'): + obj_json = json.dumps(self, default=lambda o: dict((k, v) for k, v in o.__dict__.iteritems())) + obj_dict = json.loads(obj_json) + return {name_: obj_dict} + def build(self, node): + self.buildAttributes(node, node.attrib, []) + for child in node: + nodeName_ = Tag_pattern_.match(child.tag).groups()[-1] + self.buildChildren(child, node, nodeName_) + def buildAttributes(self, node, attrs, already_processed): + pass + def buildChildren(self, child_, node, nodeName_, fromsubclass_=False): + if nodeName_ == 'prefix': + prefix_ = child_.text + prefix_ = self.gds_validate_string(prefix_, node, 'prefix') + self.prefix = prefix_ + elif nodeName_ == 'next-hop': + next_hop_ = child_.text + next_hop_ = self.gds_validate_string(next_hop_, node, 'next_hop') + self.next_hop = next_hop_ + elif nodeName_ == 'route-target': + route_target_ = child_.text + route_target_ = self.gds_validate_string(route_target_, node, 'route_target') + self.route_target.append(route_target_) +# end class StaticRouteType + + +class StaticRouteEntriesType(GeneratedsSuper): + """ + StaticRouteEntriesType class definition from :doc:`vnc_cfg.xsd` + """ + subclass = None + superclass = None + def __init__(self, route=None, **kwargs): + if (route is None) or (route == []): + self.route = [] + else: + if isinstance(route[0], dict): + objs = [StaticRouteType(**elem) for elem in route] + self.route = objs + else: + self.route = route + def factory(*args_, **kwargs_): + if StaticRouteEntriesType.subclass: + return StaticRouteEntriesType.subclass(*args_, **kwargs_) + else: + return StaticRouteEntriesType(*args_, **kwargs_) + factory = staticmethod(factory) + def get_route(self): return self.route + def set_route(self, route): self.route = route + def add_route(self, value): self.route.append(value) + def insert_route(self, index, value): self.route[index] = value + def delete_route(self, value): self.route.remove(value) + def __eq__(self, other): + if isinstance(other, self.__class__): + return (self.route == other.route) + return NotImplemented + def __ne__(self, other): + if isinstance(other, self.__class__): + return not self.__eq__(other) + return NotImplemented + + @classmethod + def populate (cls, *a, **kwa): + obj = cls (*a, **kwa) + obj.set_route ([StaticRouteType.populate ()]) + return obj + def export(self, outfile, level=1, namespace_='', name_='StaticRouteEntriesType', namespacedef_='', pretty_print=True): + if pretty_print: + eol_ = '\n' + else: + eol_ = '' + showIndent(outfile, level, pretty_print) + outfile.write('<%s%s%s' % (namespace_, name_, namespacedef_ and ' ' + namespacedef_ or '', )) + already_processed = [] + self.exportAttributes(outfile, level, already_processed, namespace_, name_='StaticRouteEntriesType') + if self.hasContent_(): + outfile.write('>%s' % (eol_, )) + self.exportChildren(outfile, level + 1, namespace_, name_, pretty_print=pretty_print) + showIndent(outfile, level, pretty_print) + outfile.write('</%s%s>%s' % (namespace_, name_, eol_)) + else: + outfile.write('/>%s' % (eol_, )) + def exportAttributes(self, outfile, level, already_processed, namespace_='', name_='StaticRouteEntriesType'): + pass + def exportChildren(self, outfile, level, namespace_='', name_='StaticRouteEntriesType', fromsubclass_=False, pretty_print=True): + if pretty_print: + eol_ = '\n' + else: + eol_ = '' + for route_ in self.route: + if isinstance(route_, dict): + route_ = StaticRouteType(**route_) + route_.export(outfile, level, namespace_, name_='route', pretty_print=pretty_print) + def hasContent_(self): + if ( + self.route + ): + return True + else: + return False + def exportLiteral(self, outfile, level, name_='StaticRouteEntriesType'): + level += 1 + self.exportLiteralAttributes(outfile, level, [], name_) + if self.hasContent_(): + self.exportLiteralChildren(outfile, level, name_) + def exportLiteralAttributes(self, outfile, level, already_processed, name_): + pass + def exportLiteralChildren(self, outfile, level, name_): + showIndent(outfile, level) + outfile.write('route=[\n') + level += 1 + for route_ in self.route: + showIndent(outfile, level) + outfile.write('model_.StaticRouteType(\n') + route_.exportLiteral(outfile, level, name_='StaticRouteType') + showIndent(outfile, level) + outfile.write('),\n') + level -= 1 + showIndent(outfile, level) + outfile.write('],\n') + def exportDict(self, name_='StaticRouteEntriesType'): + obj_json = json.dumps(self, default=lambda o: dict((k, v) for k, v in o.__dict__.iteritems())) + obj_dict = json.loads(obj_json) + return {name_: obj_dict} + def build(self, node): + self.buildAttributes(node, node.attrib, []) + for child in node: + nodeName_ = Tag_pattern_.match(child.tag).groups()[-1] + self.buildChildren(child, node, nodeName_) + def buildAttributes(self, node, attrs, already_processed): + pass + def buildChildren(self, child_, node, nodeName_, fromsubclass_=False): + if nodeName_ == 'route': + obj_ = StaticRouteType.factory() + obj_.build(child_) + self.route.append(obj_) +# end class StaticRouteEntriesType + + +class ProtocolBgpType(GeneratedsSuper): + """ + ProtocolBgpType class definition from :doc:`vnc_cfg.xsd` + """ + subclass = None + superclass = None + def __init__(self, **kwargs): + pass + def factory(*args_, **kwargs_): + if ProtocolBgpType.subclass: + return ProtocolBgpType.subclass(*args_, **kwargs_) + else: + return ProtocolBgpType(*args_, **kwargs_) + factory = staticmethod(factory) + def __eq__(self, other): return True + def __ne__(self, other): return False + @classmethod + def populate (cls, *a, **kwa): + obj = cls (*a, **kwa) + return obj + def export(self, outfile, level=1, namespace_='', name_='ProtocolBgpType', namespacedef_='', pretty_print=True): + if pretty_print: + eol_ = '\n' + else: + eol_ = '' + showIndent(outfile, level, pretty_print) + outfile.write('<%s%s%s' % (namespace_, name_, namespacedef_ and ' ' + namespacedef_ or '', )) + already_processed = [] + self.exportAttributes(outfile, level, already_processed, namespace_, name_='ProtocolBgpType') + if self.hasContent_(): + outfile.write('>%s' % (eol_, )) + self.exportChildren(outfile, level + 1, namespace_, name_, pretty_print=pretty_print) + outfile.write('</%s%s>%s' % (namespace_, name_, eol_)) + else: + outfile.write('/>%s' % (eol_, )) + def exportAttributes(self, outfile, level, already_processed, namespace_='', name_='ProtocolBgpType'): + pass + def exportChildren(self, outfile, level, namespace_='', name_='ProtocolBgpType', fromsubclass_=False, pretty_print=True): + pass + def hasContent_(self): + if ( + + ): + return True + else: + return False + def exportLiteral(self, outfile, level, name_='ProtocolBgpType'): + level += 1 + self.exportLiteralAttributes(outfile, level, [], name_) + if self.hasContent_(): + self.exportLiteralChildren(outfile, level, name_) + def exportLiteralAttributes(self, outfile, level, already_processed, name_): + pass + def exportLiteralChildren(self, outfile, level, name_): + pass + def exportDict(self, name_='ProtocolBgpType'): + obj_json = json.dumps(self, default=lambda o: dict((k, v) for k, v in o.__dict__.iteritems())) + obj_dict = json.loads(obj_json) + return {name_: obj_dict} + def build(self, node): + self.buildAttributes(node, node.attrib, []) + for child in node: + nodeName_ = Tag_pattern_.match(child.tag).groups()[-1] + self.buildChildren(child, node, nodeName_) + def buildAttributes(self, node, attrs, already_processed): + pass + def buildChildren(self, child_, node, nodeName_, fromsubclass_=False): + pass +# end class ProtocolBgpType + + +class ProtocolOspfType(GeneratedsSuper): + """ + ProtocolOspfType class definition from :doc:`vnc_cfg.xsd` + """ + subclass = None + superclass = None + def __init__(self, area=None, **kwargs): + self.area = area + def factory(*args_, **kwargs_): + if ProtocolOspfType.subclass: + return ProtocolOspfType.subclass(*args_, **kwargs_) + else: + return ProtocolOspfType(*args_, **kwargs_) + factory = staticmethod(factory) + def get_area(self): return self.area + def set_area(self, area): self.area = area + def __eq__(self, other): + if isinstance(other, self.__class__): + return (self.area == other.area) + return NotImplemented + def __ne__(self, other): + if isinstance(other, self.__class__): + return not self.__eq__(other) + return NotImplemented + + @classmethod + def populate (cls, *a, **kwa): + obj = cls (*a, **kwa) + obj.set_area (obj.populate_integer ("area")) + return obj + def export(self, outfile, level=1, namespace_='', name_='ProtocolOspfType', namespacedef_='', pretty_print=True): + if pretty_print: + eol_ = '\n' + else: + eol_ = '' + showIndent(outfile, level, pretty_print) + outfile.write('<%s%s%s' % (namespace_, name_, namespacedef_ and ' ' + namespacedef_ or '', )) + already_processed = [] + self.exportAttributes(outfile, level, already_processed, namespace_, name_='ProtocolOspfType') + if self.hasContent_(): + outfile.write('>%s' % (eol_, )) + self.exportChildren(outfile, level + 1, namespace_, name_, pretty_print=pretty_print) + showIndent(outfile, level, pretty_print) + outfile.write('</%s%s>%s' % (namespace_, name_, eol_)) + else: + outfile.write('/>%s' % (eol_, )) + def exportAttributes(self, outfile, level, already_processed, namespace_='', name_='ProtocolOspfType'): + pass + def exportChildren(self, outfile, level, namespace_='', name_='ProtocolOspfType', fromsubclass_=False, pretty_print=True): + if pretty_print: + eol_ = '\n' + else: + eol_ = '' + if self.area is not None: + showIndent(outfile, level, pretty_print) + outfile.write('<%sarea>%s</%sarea>%s' % (namespace_, self.gds_format_integer(self.area, input_name='area'), namespace_, eol_)) + def hasContent_(self): + if ( + self.area is not None + ): + return True + else: + return False + def exportLiteral(self, outfile, level, name_='ProtocolOspfType'): + level += 1 + self.exportLiteralAttributes(outfile, level, [], name_) + if self.hasContent_(): + self.exportLiteralChildren(outfile, level, name_) + def exportLiteralAttributes(self, outfile, level, already_processed, name_): + pass + def exportLiteralChildren(self, outfile, level, name_): + if self.area is not None: + showIndent(outfile, level) + outfile.write('area=%d,\n' % self.area) + def exportDict(self, name_='ProtocolOspfType'): + obj_json = json.dumps(self, default=lambda o: dict((k, v) for k, v in o.__dict__.iteritems())) + obj_dict = json.loads(obj_json) + return {name_: obj_dict} + def build(self, node): + self.buildAttributes(node, node.attrib, []) + for child in node: + nodeName_ = Tag_pattern_.match(child.tag).groups()[-1] + self.buildChildren(child, node, nodeName_) + def buildAttributes(self, node, attrs, already_processed): + pass + def buildChildren(self, child_, node, nodeName_, fromsubclass_=False): + if nodeName_ == 'area': + sval_ = child_.text + try: + ival_ = int(sval_) + except (TypeError, ValueError), exp: + raise_parse_error(child_, 'requires integer: %s' % exp) + ival_ = self.gds_validate_integer(ival_, node, 'area') + self.area = ival_ +# end class ProtocolOspfType + + +class ProtocolStaticType(GeneratedsSuper): + """ + ProtocolStaticType class definition from :doc:`vnc_cfg.xsd` + """ + subclass = None + superclass = None + def __init__(self, route=None, **kwargs): + if (route is None) or (route == []): + self.route = [] + else: + self.route = route + def factory(*args_, **kwargs_): + if ProtocolStaticType.subclass: + return ProtocolStaticType.subclass(*args_, **kwargs_) + else: + return ProtocolStaticType(*args_, **kwargs_) + factory = staticmethod(factory) + def get_route(self): return self.route + def set_route(self, route): self.route = route + def add_route(self, value): self.route.append(value) + def insert_route(self, index, value): self.route[index] = value + def delete_route(self, value): self.route.remove(value) + def __eq__(self, other): + if isinstance(other, self.__class__): + return (self.route == other.route) + return NotImplemented + def __ne__(self, other): + if isinstance(other, self.__class__): + return not self.__eq__(other) + return NotImplemented + + @classmethod + def populate (cls, *a, **kwa): + obj = cls (*a, **kwa) + obj.set_route ([obj.populate_string ("route")]) + return obj + def export(self, outfile, level=1, namespace_='', name_='ProtocolStaticType', namespacedef_='', pretty_print=True): + if pretty_print: + eol_ = '\n' + else: + eol_ = '' + showIndent(outfile, level, pretty_print) + outfile.write('<%s%s%s' % (namespace_, name_, namespacedef_ and ' ' + namespacedef_ or '', )) + already_processed = [] + self.exportAttributes(outfile, level, already_processed, namespace_, name_='ProtocolStaticType') + if self.hasContent_(): + outfile.write('>%s' % (eol_, )) + self.exportChildren(outfile, level + 1, namespace_, name_, pretty_print=pretty_print) + showIndent(outfile, level, pretty_print) + outfile.write('</%s%s>%s' % (namespace_, name_, eol_)) + else: + outfile.write('/>%s' % (eol_, )) + def exportAttributes(self, outfile, level, already_processed, namespace_='', name_='ProtocolStaticType'): + pass + def exportChildren(self, outfile, level, namespace_='', name_='ProtocolStaticType', fromsubclass_=False, pretty_print=True): + if pretty_print: + eol_ = '\n' + else: + eol_ = '' + for route_ in self.route: + showIndent(outfile, level, pretty_print) + outfile.write('<%sroute>%s</%sroute>%s' % (namespace_, self.gds_format_string(quote_xml(route_).encode(ExternalEncoding), input_name='route'), namespace_, eol_)) + def hasContent_(self): + if ( + self.route + ): + return True + else: + return False + def exportLiteral(self, outfile, level, name_='ProtocolStaticType'): + level += 1 + self.exportLiteralAttributes(outfile, level, [], name_) + if self.hasContent_(): + self.exportLiteralChildren(outfile, level, name_) + def exportLiteralAttributes(self, outfile, level, already_processed, name_): + pass + def exportLiteralChildren(self, outfile, level, name_): + showIndent(outfile, level) + outfile.write('route=[\n') + level += 1 + for route_ in self.route: + showIndent(outfile, level) + outfile.write('%s,\n' % quote_python(route_).encode(ExternalEncoding)) + level -= 1 + showIndent(outfile, level) + outfile.write('],\n') + def exportDict(self, name_='ProtocolStaticType'): + obj_json = json.dumps(self, default=lambda o: dict((k, v) for k, v in o.__dict__.iteritems())) + obj_dict = json.loads(obj_json) + return {name_: obj_dict} + def build(self, node): + self.buildAttributes(node, node.attrib, []) + for child in node: + nodeName_ = Tag_pattern_.match(child.tag).groups()[-1] + self.buildChildren(child, node, nodeName_) + def buildAttributes(self, node, attrs, already_processed): + pass + def buildChildren(self, child_, node, nodeName_, fromsubclass_=False): + if nodeName_ == 'route': + route_ = child_.text + route_ = self.gds_validate_string(route_, node, 'route') + self.route.append(route_) +# end class ProtocolStaticType + + +class ConnectionType(GeneratedsSuper): + """ + ConnectionType class definition from :doc:`vnc_cfg.xsd` + """ + subclass = None + superclass = None + def __init__(self, **kwargs): + pass + def factory(*args_, **kwargs_): + if ConnectionType.subclass: + return ConnectionType.subclass(*args_, **kwargs_) + else: + return ConnectionType(*args_, **kwargs_) + factory = staticmethod(factory) + def __eq__(self, other): return True + def __ne__(self, other): return False + @classmethod + def populate (cls, *a, **kwa): + obj = cls (*a, **kwa) + return obj + def export(self, outfile, level=1, namespace_='', name_='ConnectionType', namespacedef_='', pretty_print=True): + if pretty_print: + eol_ = '\n' + else: + eol_ = '' + showIndent(outfile, level, pretty_print) + outfile.write('<%s%s%s' % (namespace_, name_, namespacedef_ and ' ' + namespacedef_ or '', )) + already_processed = [] + self.exportAttributes(outfile, level, already_processed, namespace_, name_='ConnectionType') + if self.hasContent_(): + outfile.write('>%s' % (eol_, )) + self.exportChildren(outfile, level + 1, namespace_, name_, pretty_print=pretty_print) + outfile.write('</%s%s>%s' % (namespace_, name_, eol_)) + else: + outfile.write('/>%s' % (eol_, )) + def exportAttributes(self, outfile, level, already_processed, namespace_='', name_='ConnectionType'): + pass + def exportChildren(self, outfile, level, namespace_='', name_='ConnectionType', fromsubclass_=False, pretty_print=True): + pass + def hasContent_(self): + if ( + + ): + return True + else: + return False + def exportLiteral(self, outfile, level, name_='ConnectionType'): + level += 1 + self.exportLiteralAttributes(outfile, level, [], name_) + if self.hasContent_(): + self.exportLiteralChildren(outfile, level, name_) + def exportLiteralAttributes(self, outfile, level, already_processed, name_): + pass + def exportLiteralChildren(self, outfile, level, name_): + pass + def exportDict(self, name_='ConnectionType'): + obj_json = json.dumps(self, default=lambda o: dict((k, v) for k, v in o.__dict__.iteritems())) + obj_dict = json.loads(obj_json) + return {name_: obj_dict} + def build(self, node): + self.buildAttributes(node, node.attrib, []) + for child in node: + nodeName_ = Tag_pattern_.match(child.tag).groups()[-1] + self.buildChildren(child, node, nodeName_) + def buildAttributes(self, node, attrs, already_processed): + pass + def buildChildren(self, child_, node, nodeName_, fromsubclass_=False): + pass +# end class ConnectionType + + +class InstanceTargetType(GeneratedsSuper): + """ + InstanceTargetType class definition from :doc:`vnc_cfg.xsd` + """ + subclass = None + superclass = None + def __init__(self, import_export=None, **kwargs): + self.import_export = import_export + def factory(*args_, **kwargs_): + if InstanceTargetType.subclass: + return InstanceTargetType.subclass(*args_, **kwargs_) + else: + return InstanceTargetType(*args_, **kwargs_) + factory = staticmethod(factory) + def get_import_export(self): return self.import_export + def set_import_export(self, import_export): self.import_export = import_export + def validate_ImportExportType(self, value): + # Validate type ImportExportType, a restriction on xsd:string. + error = False + if isinstance(value, list): + error = set(value) - set([u'import', u'export']) + else: + error = value not in [u'import', u'export'] + if error: + raise ValueError("ImportExportType must be one of [u'import', u'export']") + def __eq__(self, other): + if isinstance(other, self.__class__): + return (self.import_export == other.import_export) + return NotImplemented + def __ne__(self, other): + if isinstance(other, self.__class__): + return not self.__eq__(other) + return NotImplemented + + @classmethod + def populate (cls, *a, **kwa): + obj = cls (*a, **kwa) + obj.set_import_export (obj.populate_string ("import_export")) + return obj + def export(self, outfile, level=1, namespace_='', name_='InstanceTargetType', namespacedef_='', pretty_print=True): + if pretty_print: + eol_ = '\n' + else: + eol_ = '' + showIndent(outfile, level, pretty_print) + outfile.write('<%s%s%s' % (namespace_, name_, namespacedef_ and ' ' + namespacedef_ or '', )) + already_processed = [] + self.exportAttributes(outfile, level, already_processed, namespace_, name_='InstanceTargetType') + if self.hasContent_(): + outfile.write('>%s' % (eol_, )) + self.exportChildren(outfile, level + 1, namespace_, name_, pretty_print=pretty_print) + showIndent(outfile, level, pretty_print) + outfile.write('</%s%s>%s' % (namespace_, name_, eol_)) + else: + outfile.write('/>%s' % (eol_, )) + def exportAttributes(self, outfile, level, already_processed, namespace_='', name_='InstanceTargetType'): + pass + def exportChildren(self, outfile, level, namespace_='', name_='InstanceTargetType', fromsubclass_=False, pretty_print=True): + if pretty_print: + eol_ = '\n' + else: + eol_ = '' + if self.import_export is not None: + showIndent(outfile, level, pretty_print) + outfile.write('<%simport-export>%s</%simport-export>%s' % (namespace_, self.gds_format_string(quote_xml(self.import_export).encode(ExternalEncoding), input_name='import-export'), namespace_, eol_)) + def hasContent_(self): + if ( + self.import_export is not None + ): + return True + else: + return False + def exportLiteral(self, outfile, level, name_='InstanceTargetType'): + level += 1 + self.exportLiteralAttributes(outfile, level, [], name_) + if self.hasContent_(): + self.exportLiteralChildren(outfile, level, name_) + def exportLiteralAttributes(self, outfile, level, already_processed, name_): + pass + def exportLiteralChildren(self, outfile, level, name_): + if self.import_export is not None: + showIndent(outfile, level) + outfile.write('import_export=%s,\n' % quote_python(self.import_export).encode(ExternalEncoding)) + def exportDict(self, name_='InstanceTargetType'): + obj_json = json.dumps(self, default=lambda o: dict((k, v) for k, v in o.__dict__.iteritems())) + obj_dict = json.loads(obj_json) + return {name_: obj_dict} + def build(self, node): + self.buildAttributes(node, node.attrib, []) + for child in node: + nodeName_ = Tag_pattern_.match(child.tag).groups()[-1] + self.buildChildren(child, node, nodeName_) + def buildAttributes(self, node, attrs, already_processed): + pass + def buildChildren(self, child_, node, nodeName_, fromsubclass_=False): + if nodeName_ == 'import-export': + import_export_ = child_.text + import_export_ = self.gds_validate_string(import_export_, node, 'import_export') + self.import_export = import_export_ + self.validate_ImportExportType(self.import_export) # validate type ImportExportType +# end class InstanceTargetType + + +class DefaultProtocolType(GeneratedsSuper): + """ + DefaultProtocolType class definition from :doc:`vnc_cfg.xsd` + """ + subclass = None + superclass = None + def __init__(self, bgp=None, ospf=None, **kwargs): + if isinstance(bgp, dict): + obj = ProtocolBgpType(**bgp) + self.bgp = obj + else: + self.bgp = bgp + if isinstance(ospf, dict): + obj = ProtocolOspfType(**ospf) + self.ospf = obj + else: + self.ospf = ospf + def factory(*args_, **kwargs_): + if DefaultProtocolType.subclass: + return DefaultProtocolType.subclass(*args_, **kwargs_) + else: + return DefaultProtocolType(*args_, **kwargs_) + factory = staticmethod(factory) + def get_bgp(self): return self.bgp + def set_bgp(self, bgp): self.bgp = bgp + def get_ospf(self): return self.ospf + def set_ospf(self, ospf): self.ospf = ospf + def __eq__(self, other): + if isinstance(other, self.__class__): + return (self.bgp == other.bgp and + self.ospf == other.ospf) + return NotImplemented + def __ne__(self, other): + if isinstance(other, self.__class__): + return not self.__eq__(other) + return NotImplemented + + @classmethod + def populate (cls, *a, **kwa): + obj = cls (*a, **kwa) + obj.set_bgp (ProtocolBgpType.populate ()) + obj.set_ospf (ProtocolOspfType.populate ()) + return obj + def export(self, outfile, level=1, namespace_='', name_='DefaultProtocolType', namespacedef_='', pretty_print=True): + if pretty_print: + eol_ = '\n' + else: + eol_ = '' + showIndent(outfile, level, pretty_print) + outfile.write('<%s%s%s' % (namespace_, name_, namespacedef_ and ' ' + namespacedef_ or '', )) + already_processed = [] + self.exportAttributes(outfile, level, already_processed, namespace_, name_='DefaultProtocolType') + if self.hasContent_(): + outfile.write('>%s' % (eol_, )) + self.exportChildren(outfile, level + 1, namespace_, name_, pretty_print=pretty_print) + showIndent(outfile, level, pretty_print) + outfile.write('</%s%s>%s' % (namespace_, name_, eol_)) + else: + outfile.write('/>%s' % (eol_, )) + def exportAttributes(self, outfile, level, already_processed, namespace_='', name_='DefaultProtocolType'): + pass + def exportChildren(self, outfile, level, namespace_='', name_='DefaultProtocolType', fromsubclass_=False, pretty_print=True): + if pretty_print: + eol_ = '\n' + else: + eol_ = '' + if self.bgp is not None: + self.bgp.export(outfile, level, namespace_, name_='bgp', pretty_print=pretty_print) + if self.ospf is not None: + self.ospf.export(outfile, level, namespace_, name_='ospf', pretty_print=pretty_print) + def hasContent_(self): + if ( + self.bgp is not None or + self.ospf is not None + ): + return True + else: + return False + def exportLiteral(self, outfile, level, name_='DefaultProtocolType'): + level += 1 + self.exportLiteralAttributes(outfile, level, [], name_) + if self.hasContent_(): + self.exportLiteralChildren(outfile, level, name_) + def exportLiteralAttributes(self, outfile, level, already_processed, name_): + pass + def exportLiteralChildren(self, outfile, level, name_): + if self.bgp is not None: + showIndent(outfile, level) + outfile.write('bgp=model_.ProtocolBgpType(\n') + self.bgp.exportLiteral(outfile, level, name_='bgp') + showIndent(outfile, level) + outfile.write('),\n') + if self.ospf is not None: + showIndent(outfile, level) + outfile.write('ospf=model_.ProtocolOspfType(\n') + self.ospf.exportLiteral(outfile, level, name_='ospf') + showIndent(outfile, level) + outfile.write('),\n') + def exportDict(self, name_='DefaultProtocolType'): + obj_json = json.dumps(self, default=lambda o: dict((k, v) for k, v in o.__dict__.iteritems())) + obj_dict = json.loads(obj_json) + return {name_: obj_dict} + def build(self, node): + self.buildAttributes(node, node.attrib, []) + for child in node: + nodeName_ = Tag_pattern_.match(child.tag).groups()[-1] + self.buildChildren(child, node, nodeName_) + def buildAttributes(self, node, attrs, already_processed): + pass + def buildChildren(self, child_, node, nodeName_, fromsubclass_=False): + if nodeName_ == 'bgp': + obj_ = ProtocolBgpType.factory() + obj_.build(child_) + self.set_bgp(obj_) + elif nodeName_ == 'ospf': + obj_ = ProtocolOspfType.factory() + obj_.build(child_) + self.set_ospf(obj_) +# end class DefaultProtocolType + + +class BindingType(GeneratedsSuper): + """ + BindingType class definition from :doc:`vnc_cfg.xsd` + """ + subclass = None + superclass = None + def __init__(self, **kwargs): + pass + def factory(*args_, **kwargs_): + if BindingType.subclass: + return BindingType.subclass(*args_, **kwargs_) + else: + return BindingType(*args_, **kwargs_) + factory = staticmethod(factory) + def __eq__(self, other): return True + def __ne__(self, other): return False + @classmethod + def populate (cls, *a, **kwa): + obj = cls (*a, **kwa) + return obj + def export(self, outfile, level=1, namespace_='', name_='BindingType', namespacedef_='', pretty_print=True): + if pretty_print: + eol_ = '\n' + else: + eol_ = '' + showIndent(outfile, level, pretty_print) + outfile.write('<%s%s%s' % (namespace_, name_, namespacedef_ and ' ' + namespacedef_ or '', )) + already_processed = [] + self.exportAttributes(outfile, level, already_processed, namespace_, name_='BindingType') + if self.hasContent_(): + outfile.write('>%s' % (eol_, )) + self.exportChildren(outfile, level + 1, namespace_, name_, pretty_print=pretty_print) + outfile.write('</%s%s>%s' % (namespace_, name_, eol_)) + else: + outfile.write('/>%s' % (eol_, )) + def exportAttributes(self, outfile, level, already_processed, namespace_='', name_='BindingType'): + pass + def exportChildren(self, outfile, level, namespace_='', name_='BindingType', fromsubclass_=False, pretty_print=True): + pass + def hasContent_(self): + if ( + + ): + return True + else: + return False + def exportLiteral(self, outfile, level, name_='BindingType'): + level += 1 + self.exportLiteralAttributes(outfile, level, [], name_) + if self.hasContent_(): + self.exportLiteralChildren(outfile, level, name_) + def exportLiteralAttributes(self, outfile, level, already_processed, name_): + pass + def exportLiteralChildren(self, outfile, level, name_): + pass + def exportDict(self, name_='BindingType'): + obj_json = json.dumps(self, default=lambda o: dict((k, v) for k, v in o.__dict__.iteritems())) + obj_dict = json.loads(obj_json) + return {name_: obj_dict} + def build(self, node): + self.buildAttributes(node, node.attrib, []) + for child in node: + nodeName_ = Tag_pattern_.match(child.tag).groups()[-1] + self.buildChildren(child, node, nodeName_) + def buildAttributes(self, node, attrs, already_processed): + pass + def buildChildren(self, child_, node, nodeName_, fromsubclass_=False): + pass +# end class BindingType + + +class AttachmentAddressType(GeneratedsSuper): + """ + AttachmentAddressType class definition from :doc:`vnc_cfg.xsd` + """ + subclass = None + superclass = None + def __init__(self, **kwargs): + pass + def factory(*args_, **kwargs_): + if AttachmentAddressType.subclass: + return AttachmentAddressType.subclass(*args_, **kwargs_) + else: + return AttachmentAddressType(*args_, **kwargs_) + factory = staticmethod(factory) + def __eq__(self, other): return True + def __ne__(self, other): return False + @classmethod + def populate (cls, *a, **kwa): + obj = cls (*a, **kwa) + return obj + def export(self, outfile, level=1, namespace_='', name_='AttachmentAddressType', namespacedef_='', pretty_print=True): + if pretty_print: + eol_ = '\n' + else: + eol_ = '' + showIndent(outfile, level, pretty_print) + outfile.write('<%s%s%s' % (namespace_, name_, namespacedef_ and ' ' + namespacedef_ or '', )) + already_processed = [] + self.exportAttributes(outfile, level, already_processed, namespace_, name_='AttachmentAddressType') + if self.hasContent_(): + outfile.write('>%s' % (eol_, )) + self.exportChildren(outfile, level + 1, namespace_, name_, pretty_print=pretty_print) + outfile.write('</%s%s>%s' % (namespace_, name_, eol_)) + else: + outfile.write('/>%s' % (eol_, )) + def exportAttributes(self, outfile, level, already_processed, namespace_='', name_='AttachmentAddressType'): + pass + def exportChildren(self, outfile, level, namespace_='', name_='AttachmentAddressType', fromsubclass_=False, pretty_print=True): + pass + def hasContent_(self): + if ( + + ): + return True + else: + return False + def exportLiteral(self, outfile, level, name_='AttachmentAddressType'): + level += 1 + self.exportLiteralAttributes(outfile, level, [], name_) + if self.hasContent_(): + self.exportLiteralChildren(outfile, level, name_) + def exportLiteralAttributes(self, outfile, level, already_processed, name_): + pass + def exportLiteralChildren(self, outfile, level, name_): + pass + def exportDict(self, name_='AttachmentAddressType'): + obj_json = json.dumps(self, default=lambda o: dict((k, v) for k, v in o.__dict__.iteritems())) + obj_dict = json.loads(obj_json) + return {name_: obj_dict} + def build(self, node): + self.buildAttributes(node, node.attrib, []) + for child in node: + nodeName_ = Tag_pattern_.match(child.tag).groups()[-1] + self.buildChildren(child, node, nodeName_) + def buildAttributes(self, node, attrs, already_processed): + pass + def buildChildren(self, child_, node, nodeName_, fromsubclass_=False): + pass +# end class AttachmentAddressType + + +class AttachmentInfoType(GeneratedsSuper): + """ + AttachmentInfoType class definition from :doc:`vnc_cfg.xsd` + """ + subclass = None + superclass = None + def __init__(self, static=None, bgp=None, ospf=None, state=None, **kwargs): + if isinstance(static, dict): + obj = ProtocolStaticType(**static) + self.static = obj + else: + self.static = static + if isinstance(bgp, dict): + obj = ProtocolBgpType(**bgp) + self.bgp = obj + else: + self.bgp = bgp + if isinstance(ospf, dict): + obj = ProtocolOspfType(**ospf) + self.ospf = obj + else: + self.ospf = ospf + self.state = state + def factory(*args_, **kwargs_): + if AttachmentInfoType.subclass: + return AttachmentInfoType.subclass(*args_, **kwargs_) + else: + return AttachmentInfoType(*args_, **kwargs_) + factory = staticmethod(factory) + def get_static(self): return self.static + def set_static(self, static): self.static = static + def get_bgp(self): return self.bgp + def set_bgp(self, bgp): self.bgp = bgp + def get_ospf(self): return self.ospf + def set_ospf(self, ospf): self.ospf = ospf + def get_state(self): return self.state + def set_state(self, state): self.state = state + def __eq__(self, other): + if isinstance(other, self.__class__): + return (self.static == other.static and + self.bgp == other.bgp and + self.ospf == other.ospf and + self.state == other.state) + return NotImplemented + def __ne__(self, other): + if isinstance(other, self.__class__): + return not self.__eq__(other) + return NotImplemented + + @classmethod + def populate (cls, *a, **kwa): + obj = cls (*a, **kwa) + obj.set_static (ProtocolStaticType.populate ()) + obj.set_bgp (ProtocolBgpType.populate ()) + obj.set_ospf (ProtocolOspfType.populate ()) + obj.set_state (obj.populate_string ("state")) + return obj + def export(self, outfile, level=1, namespace_='', name_='AttachmentInfoType', namespacedef_='', pretty_print=True): + if pretty_print: + eol_ = '\n' + else: + eol_ = '' + showIndent(outfile, level, pretty_print) + outfile.write('<%s%s%s' % (namespace_, name_, namespacedef_ and ' ' + namespacedef_ or '', )) + already_processed = [] + self.exportAttributes(outfile, level, already_processed, namespace_, name_='AttachmentInfoType') + if self.hasContent_(): + outfile.write('>%s' % (eol_, )) + self.exportChildren(outfile, level + 1, namespace_, name_, pretty_print=pretty_print) + showIndent(outfile, level, pretty_print) + outfile.write('</%s%s>%s' % (namespace_, name_, eol_)) + else: + outfile.write('/>%s' % (eol_, )) + def exportAttributes(self, outfile, level, already_processed, namespace_='', name_='AttachmentInfoType'): + pass + def exportChildren(self, outfile, level, namespace_='', name_='AttachmentInfoType', fromsubclass_=False, pretty_print=True): + if pretty_print: + eol_ = '\n' + else: + eol_ = '' + if self.static is not None: + self.static.export(outfile, level, namespace_, name_='static', pretty_print=pretty_print) + if self.bgp is not None: + self.bgp.export(outfile, level, namespace_, name_='bgp', pretty_print=pretty_print) + if self.ospf is not None: + self.ospf.export(outfile, level, namespace_, name_='ospf', pretty_print=pretty_print) + if self.state is not None: + showIndent(outfile, level, pretty_print) + outfile.write('<%sstate>%s</%sstate>%s' % (namespace_, self.gds_format_string(quote_xml(self.state).encode(ExternalEncoding), input_name='state'), namespace_, eol_)) + def hasContent_(self): + if ( + self.static is not None or + self.bgp is not None or + self.ospf is not None or + self.state is not None + ): + return True + else: + return False + def exportLiteral(self, outfile, level, name_='AttachmentInfoType'): + level += 1 + self.exportLiteralAttributes(outfile, level, [], name_) + if self.hasContent_(): + self.exportLiteralChildren(outfile, level, name_) + def exportLiteralAttributes(self, outfile, level, already_processed, name_): + pass + def exportLiteralChildren(self, outfile, level, name_): + if self.static is not None: + showIndent(outfile, level) + outfile.write('static=model_.ProtocolStaticType(\n') + self.static.exportLiteral(outfile, level, name_='static') + showIndent(outfile, level) + outfile.write('),\n') + if self.bgp is not None: + showIndent(outfile, level) + outfile.write('bgp=model_.ProtocolBgpType(\n') + self.bgp.exportLiteral(outfile, level, name_='bgp') + showIndent(outfile, level) + outfile.write('),\n') + if self.ospf is not None: + showIndent(outfile, level) + outfile.write('ospf=model_.ProtocolOspfType(\n') + self.ospf.exportLiteral(outfile, level, name_='ospf') + showIndent(outfile, level) + outfile.write('),\n') + if self.state is not None: + showIndent(outfile, level) + outfile.write('state=%s,\n' % quote_python(self.state).encode(ExternalEncoding)) + def exportDict(self, name_='AttachmentInfoType'): + obj_json = json.dumps(self, default=lambda o: dict((k, v) for k, v in o.__dict__.iteritems())) + obj_dict = json.loads(obj_json) + return {name_: obj_dict} + def build(self, node): + self.buildAttributes(node, node.attrib, []) + for child in node: + nodeName_ = Tag_pattern_.match(child.tag).groups()[-1] + self.buildChildren(child, node, nodeName_) + def buildAttributes(self, node, attrs, already_processed): + pass + def buildChildren(self, child_, node, nodeName_, fromsubclass_=False): + if nodeName_ == 'static': + obj_ = ProtocolStaticType.factory() + obj_.build(child_) + self.set_static(obj_) + elif nodeName_ == 'bgp': + obj_ = ProtocolBgpType.factory() + obj_.build(child_) + self.set_bgp(obj_) + elif nodeName_ == 'ospf': + obj_ = ProtocolOspfType.factory() + obj_.build(child_) + self.set_ospf(obj_) + elif nodeName_ == 'state': + state_ = child_.text + state_ = self.gds_validate_string(state_, node, 'state') + self.state = state_ +# end class AttachmentInfoType + + + +__all__ = [ + "AclEntriesType", + "AclRuleType", + "ActionListType", + "AddressFamilies", + "AddressType", + "AllocationPoolType", + "AllowedAddressPair", + "AllowedAddressPairs", + "ApiAccessListType", + "ApiAccessType", + "AttachmentAddressType", + "AttachmentInfoType", + "AuthenticationData", + "AuthenticationKeyItem", + "BgpPeeringAttributes", + "BgpRouterParams", + "BgpSession", + "BgpSessionAttributes", + "BindingType", + "ConnectionType", + "DefaultProtocolType", + "DhcpOptionType", + "DhcpOptionsListType", + "DomainLimitsType", + "EncapsulationPrioritiesType", + "FloatingIpPoolType", + "IdPermsType", + "InstanceTargetType", + "InterfaceMirrorType", + "IpAddressesType", + "IpamDnsAddressType", + "IpamSubnetType", + "IpamType", + "JunosServicePorts", + "KeyValuePair", + "KeyValuePairs", + "LinklocalServiceEntryType", + "LinklocalServicesTypes", + "LoadbalancerHealthmonitorType", + "LoadbalancerMemberType", + "LoadbalancerPoolType", + "MacAddressesType", + "MatchConditionType", + "MirrorActionType", + "PermType", + "PluginProperties", + "PluginProperty", + "PolicyBasedForwardingRuleType", + "PolicyEntriesType", + "PolicyRuleType", + "PortType", + "ProtocolBgpType", + "ProtocolOspfType", + "ProtocolStaticType", + "QuotaType", + "RouteTableType", + "RouteTargetList", + "RouteType", + "SNMPCredentials", + "SequenceType", + "ServiceChainInfo", + "ServiceInstanceInterfaceType", + "ServiceInstanceType", + "ServiceScaleOutType", + "ServiceTemplateInterfaceType", + "ServiceTemplateType", + "StaticRouteEntriesType", + "StaticRouteType", + "SubnetListType", + "SubnetType", + "TimerType", + "UserCredentials", + "UuidType", + "VirtualDnsRecordType", + "VirtualDnsType", + "VirtualIpType", + "VirtualMachineInterfacePropertiesType", + "VirtualNetworkPolicyType", + "VirtualNetworkType", + "VnSubnetsType", + "VrfAssignRuleType", + "VrfAssignTableType", + "config_root_domain", + "config_root_global_system_config", + "customer_attachment_floating_ip", + "customer_attachment_virtual_machine_interface", + "domain_namespace", + "domain_project", + "domain_service_template", + "domain_virtual_DNS", + "floating_ip_pool_floating_ip", + "floating_ip_project", + "floating_ip_virtual_machine_interface", + "global_system_config_analytics_node", + "global_system_config_bgp_router", + "global_system_config_config_node", + "global_system_config_database_node", + "global_system_config_global_vrouter_config", + "global_system_config_physical_router", + "global_system_config_service_appliance_set", + "global_system_config_virtual_router", + "instance_bgp_router", + "instance_ip_virtual_machine_interface", + "instance_ip_virtual_network", + "loadbalancer_pool_loadbalancer_healthmonitor", + "loadbalancer_pool_loadbalancer_member", + "loadbalancer_pool_service_appliance_set", + "loadbalancer_pool_service_instance", + "loadbalancer_pool_virtual_machine_interface", + "logical_interface_virtual_machine_interface", + "logical_router_gateway", + "logical_router_interface", + "logical_router_service_instance", + "logical_router_target", + "network_ipam_virtual_DNS", + "physical_interface_logical_interface", + "physical_router_bgp_router", + "physical_router_logical_interface", + "physical_router_physical_interface", + "physical_router_virtual_network", + "physical_router_virtual_router", + "project_floating_ip_pool", + "project_interface_route_table", + "project_loadbalancer_healthmonitor", + "project_loadbalancer_pool", + "project_logical_router", + "project_network_ipam", + "project_network_policy", + "project_qos_forwarding_class", + "project_qos_queue", + "project_route_table", + "project_security_group", + "project_service_instance", + "project_virtual_ip", + "project_virtual_machine_interface", + "project_virtual_network", + "provider_attachment_virtual_router", + "qos_forwarding_class_qos_queue", + "security_group_access_control_list", + "service_appliance_set_service_appliance", + "service_instance_service_template", + "subnet_virtual_machine_interface", + "virtual_DNS_virtual_DNS_record", + "virtual_ip_loadbalancer_pool", + "virtual_ip_virtual_machine_interface", + "virtual_machine_interface_qos_forwarding_class", + "virtual_machine_interface_route_table", + "virtual_machine_interface_security_group", + "virtual_machine_interface_sub_interface", + "virtual_machine_interface_virtual_machine", + "virtual_machine_interface_virtual_network", + "virtual_machine_service_instance", + "virtual_machine_virtual_machine_interface", + "virtual_network_access_control_list", + "virtual_network_floating_ip_pool", + "virtual_network_qos_forwarding_class", + "virtual_network_route_table", + "virtual_network_routing_instance", + "virtual_router_bgp_router", + "virtual_router_virtual_machine" + ] |