signature
stringlengths 8
3.44k
| body
stringlengths 0
1.41M
| docstring
stringlengths 1
122k
| id
stringlengths 5
17
|
|---|---|---|---|
def _get_native_vlan(self):
|
return self.__native_vlan<EOL>
|
Getter method for native_vlan, mapped from YANG variable /interface/homerun/switchport/trunk/tag/native_vlan (empty)
YANG Description: This specifies if the native vlan should be used
for classifying the un-tagged traffic.
|
f336570:c0:m3
|
def _set_native_vlan(self, v, load=False):
|
if hasattr(v, "<STR_LIT>"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(v,base=YANGBool, is_leaf=True, yang_name="<STR_LIT>", rest_name="<STR_LIT>", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions={u'<STR_LIT>': {u'<STR_LIT:info>': u'<STR_LIT>', u'<STR_LIT>': None}}, namespace='<STR_LIT>', defining_module='<STR_LIT>', yang_type='<STR_LIT>', is_config=True)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError({<EOL>'<STR_LIT>': """<STR_LIT>""",<EOL>'<STR_LIT>': "<STR_LIT>",<EOL>'<STR_LIT>': """<STR_LIT>""",<EOL>})<EOL><DEDENT>self.__native_vlan = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT>
|
Setter method for native_vlan, mapped from YANG variable /interface/homerun/switchport/trunk/tag/native_vlan (empty)
If this variable is read-only (config: false) in the
source YANG file, then _set_native_vlan is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_native_vlan() directly.
YANG Description: This specifies if the native vlan should be used
for classifying the un-tagged traffic.
|
f336570:c0:m4
|
def _get_rspan_access_vlan(self):
|
return self.__rspan_access_vlan<EOL>
|
Getter method for rspan_access_vlan, mapped from YANG variable /interface/homerun/switchport/access/rspan_access/rspan_access_vlan (vlan-type)
YANG Description: Specify rspan-vlan id to set as access vlan
|
f336571:c0:m3
|
def _set_rspan_access_vlan(self, v, load=False):
|
if hasattr(v, "<STR_LIT>"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(v,base=RestrictedClassType(base_type=RestrictedClassType(base_type=long, restriction_dict={'<STR_LIT>': ['<STR_LIT>']}, int_size=<NUM_LIT:32>), restriction_dict={'<STR_LIT>': [u'<STR_LIT>']}), default=RestrictedClassType(base_type=long, restriction_dict={'<STR_LIT>': ['<STR_LIT>']}, int_size=<NUM_LIT:32>)(<NUM_LIT:1>), is_leaf=True, yang_name="<STR_LIT>", rest_name="<STR_LIT>", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions={u'<STR_LIT>': {u'<STR_LIT:info>': u'<STR_LIT>', u'<STR_LIT>': u'<STR_LIT>'}}, namespace='<STR_LIT>', defining_module='<STR_LIT>', yang_type='<STR_LIT>', is_config=True)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError({<EOL>'<STR_LIT>': """<STR_LIT>""",<EOL>'<STR_LIT>': "<STR_LIT>",<EOL>'<STR_LIT>': """<STR_LIT>""",<EOL>})<EOL><DEDENT>self.__rspan_access_vlan = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT>
|
Setter method for rspan_access_vlan, mapped from YANG variable /interface/homerun/switchport/access/rspan_access/rspan_access_vlan (vlan-type)
If this variable is read-only (config: false) in the
source YANG file, then _set_rspan_access_vlan is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_rspan_access_vlan() directly.
YANG Description: Specify rspan-vlan id to set as access vlan
|
f336571:c0:m4
|
def _get_accessvlan(self):
|
return self.__accessvlan<EOL>
|
Getter method for accessvlan, mapped from YANG variable /interface/homerun/switchport/access/accessvlan (vlan-type)
YANG Description: This specifies the access vlan for this
interface.
|
f336572:c0:m3
|
def _set_accessvlan(self, v, load=False):
|
if hasattr(v, "<STR_LIT>"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(v,base=RestrictedClassType(base_type=RestrictedClassType(base_type=long, restriction_dict={'<STR_LIT>': ['<STR_LIT>']}, int_size=<NUM_LIT:32>), restriction_dict={'<STR_LIT>': [u'<STR_LIT>']}), is_leaf=True, yang_name="<STR_LIT>", rest_name="<STR_LIT>", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions={u'<STR_LIT>': {u'<STR_LIT>': None, u'<STR_LIT:info>': u'<STR_LIT>', u'<STR_LIT>': u'<STR_LIT>'}}, namespace='<STR_LIT>', defining_module='<STR_LIT>', yang_type='<STR_LIT>', is_config=True)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError({<EOL>'<STR_LIT>': """<STR_LIT>""",<EOL>'<STR_LIT>': "<STR_LIT>",<EOL>'<STR_LIT>': """<STR_LIT>""",<EOL>})<EOL><DEDENT>self.__accessvlan = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT>
|
Setter method for accessvlan, mapped from YANG variable /interface/homerun/switchport/access/accessvlan (vlan-type)
If this variable is read-only (config: false) in the
source YANG file, then _set_accessvlan is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_accessvlan() directly.
YANG Description: This specifies the access vlan for this
interface.
|
f336572:c0:m4
|
def _get_rspan_access(self):
|
return self.__rspan_access<EOL>
|
Getter method for rspan_access, mapped from YANG variable /interface/homerun/switchport/access/rspan_access (container)
YANG Description: The access layer characteristics of this
interface.
|
f336572:c0:m6
|
def _set_rspan_access(self, v, load=False):
|
if hasattr(v, "<STR_LIT>"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(v,base=rspan_access.rspan_access, is_container='<STR_LIT>', presence=False, yang_name="<STR_LIT>", rest_name="<STR_LIT>", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions={u'<STR_LIT>': {u'<STR_LIT:info>': u'<STR_LIT>', u'<STR_LIT>': None, u'<STR_LIT>': None}}, namespace='<STR_LIT>', defining_module='<STR_LIT>', yang_type='<STR_LIT>', is_config=True)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError({<EOL>'<STR_LIT>': """<STR_LIT>""",<EOL>'<STR_LIT>': "<STR_LIT>",<EOL>'<STR_LIT>': """<STR_LIT>""",<EOL>})<EOL><DEDENT>self.__rspan_access = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT>
|
Setter method for rspan_access, mapped from YANG variable /interface/homerun/switchport/access/rspan_access (container)
If this variable is read-only (config: false) in the
source YANG file, then _set_rspan_access is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_rspan_access() directly.
YANG Description: The access layer characteristics of this
interface.
|
f336572:c0:m7
|
def _get_access_vlan_id(self):
|
return self.__access_vlan_id<EOL>
|
Getter method for access_vlan_id, mapped from YANG variable /interface/homerun/switchport/access_mac_vlan_classification/access/vlan/access_vlan_id (vlan-type)
YANG Description: Set the default VLAN for the interface
|
f336573:c0:m3
|
def _set_access_vlan_id(self, v, load=False):
|
parent = getattr(self, "<STR_LIT>", None)<EOL>if parent is not None and load is False:<EOL><INDENT>raise AttributeError("<STR_LIT>" +<EOL>"<STR_LIT>")<EOL><DEDENT>if hasattr(v, "<STR_LIT>"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(v,base=RestrictedClassType(base_type=RestrictedClassType(base_type=long, restriction_dict={'<STR_LIT>': ['<STR_LIT>']}, int_size=<NUM_LIT:32>), restriction_dict={'<STR_LIT>': [u'<STR_LIT>']}), is_leaf=True, yang_name="<STR_LIT>", rest_name="<STR_LIT>", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions={u'<STR_LIT>': {u'<STR_LIT>': None, u'<STR_LIT:info>': u'<STR_LIT>'}}, is_keyval=True, namespace='<STR_LIT>', defining_module='<STR_LIT>', yang_type='<STR_LIT>', is_config=True)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError({<EOL>'<STR_LIT>': """<STR_LIT>""",<EOL>'<STR_LIT>': "<STR_LIT>",<EOL>'<STR_LIT>': """<STR_LIT>""",<EOL>})<EOL><DEDENT>self.__access_vlan_id = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT>
|
Setter method for access_vlan_id, mapped from YANG variable /interface/homerun/switchport/access_mac_vlan_classification/access/vlan/access_vlan_id (vlan-type)
If this variable is read-only (config: false) in the
source YANG file, then _set_access_vlan_id is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_access_vlan_id() directly.
YANG Description: Set the default VLAN for the interface
|
f336573:c0:m4
|
def _get_access_mac_address(self):
|
return self.__access_mac_address<EOL>
|
Getter method for access_mac_address, mapped from YANG variable /interface/homerun/switchport/access_mac_vlan_classification/access/vlan/access_mac_address (mac-address-type)
YANG Description: Associate the Mac address with a vlan
|
f336573:c0:m6
|
def _set_access_mac_address(self, v, load=False):
|
parent = getattr(self, "<STR_LIT>", None)<EOL>if parent is not None and load is False:<EOL><INDENT>raise AttributeError("<STR_LIT>" +<EOL>"<STR_LIT>")<EOL><DEDENT>if hasattr(v, "<STR_LIT>"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(v,base=RestrictedClassType(base_type=unicode, restriction_dict={'<STR_LIT>': u'<STR_LIT>'}), is_leaf=True, yang_name="<STR_LIT>", rest_name="<STR_LIT>", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions={u'<STR_LIT>': {u'<STR_LIT:info>': u'<STR_LIT>', u'<STR_LIT>': u'<STR_LIT>', u'<STR_LIT>': None}}, is_keyval=True, namespace='<STR_LIT>', defining_module='<STR_LIT>', yang_type='<STR_LIT>', is_config=True)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError({<EOL>'<STR_LIT>': """<STR_LIT>""",<EOL>'<STR_LIT>': "<STR_LIT>",<EOL>'<STR_LIT>': """<STR_LIT>""",<EOL>})<EOL><DEDENT>self.__access_mac_address = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT>
|
Setter method for access_mac_address, mapped from YANG variable /interface/homerun/switchport/access_mac_vlan_classification/access/vlan/access_mac_address (mac-address-type)
If this variable is read-only (config: false) in the
source YANG file, then _set_access_mac_address is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_access_mac_address() directly.
YANG Description: Associate the Mac address with a vlan
|
f336573:c0:m7
|
def _get_vlan(self):
|
return self.__vlan<EOL>
|
Getter method for vlan, mapped from YANG variable /interface/homerun/switchport/access_mac_vlan_classification/access/vlan (list)
|
f336574:c0:m3
|
def _set_vlan(self, v, load=False):
|
if hasattr(v, "<STR_LIT>"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(v,base=YANGListType("<STR_LIT>",vlan.vlan, yang_name="<STR_LIT>", rest_name="<STR_LIT>", parent=self, is_container='<STR_LIT:list>', user_ordered=False, path_helper=self._path_helper, yang_keys='<STR_LIT>', extensions={u'<STR_LIT>': {u'<STR_LIT>': None, u'<STR_LIT>': None, u'<STR_LIT>': None}}), is_container='<STR_LIT:list>', yang_name="<STR_LIT>", rest_name="<STR_LIT>", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions={u'<STR_LIT>': {u'<STR_LIT>': None, u'<STR_LIT>': None, u'<STR_LIT>': None}}, namespace='<STR_LIT>', defining_module='<STR_LIT>', yang_type='<STR_LIT:list>', is_config=True)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError({<EOL>'<STR_LIT>': """<STR_LIT>""",<EOL>'<STR_LIT>': "<STR_LIT:list>",<EOL>'<STR_LIT>': """<STR_LIT>""",<EOL>})<EOL><DEDENT>self.__vlan = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT>
|
Setter method for vlan, mapped from YANG variable /interface/homerun/switchport/access_mac_vlan_classification/access/vlan (list)
If this variable is read-only (config: false) in the
source YANG file, then _set_vlan is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_vlan() directly.
|
f336574:c0:m4
|
def _get_access(self):
|
return self.__access<EOL>
|
Getter method for access, mapped from YANG variable /interface/homerun/switchport/access_mac_vlan_classification/access (container)
YANG Description: The access layer characteristics of this
interface.
|
f336575:c0:m3
|
def _set_access(self, v, load=False):
|
if hasattr(v, "<STR_LIT>"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(v,base=access.access, is_container='<STR_LIT>', presence=False, yang_name="<STR_LIT>", rest_name="<STR_LIT>", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions={u'<STR_LIT>': {u'<STR_LIT:info>': u'<STR_LIT>', u'<STR_LIT>': None}}, namespace='<STR_LIT>', defining_module='<STR_LIT>', yang_type='<STR_LIT>', is_config=True)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError({<EOL>'<STR_LIT>': """<STR_LIT>""",<EOL>'<STR_LIT>': "<STR_LIT>",<EOL>'<STR_LIT>': """<STR_LIT>""",<EOL>})<EOL><DEDENT>self.__access = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT>
|
Setter method for access, mapped from YANG variable /interface/homerun/switchport/access_mac_vlan_classification/access (container)
If this variable is read-only (config: false) in the
source YANG file, then _set_access is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_access() directly.
YANG Description: The access layer characteristics of this
interface.
|
f336575:c0:m4
|
def _get_access_vlan_id(self):
|
return self.__access_vlan_id<EOL>
|
Getter method for access_vlan_id, mapped from YANG variable /interface/homerun/switchport/access_mac_rspan_vlan_classification/access/vlan/access_vlan_id (vlan-type)
YANG Description: Set the default VLAN for the interface
|
f336576:c0:m3
|
def _set_access_vlan_id(self, v, load=False):
|
parent = getattr(self, "<STR_LIT>", None)<EOL>if parent is not None and load is False:<EOL><INDENT>raise AttributeError("<STR_LIT>" +<EOL>"<STR_LIT>")<EOL><DEDENT>if hasattr(v, "<STR_LIT>"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(v,base=RestrictedClassType(base_type=RestrictedClassType(base_type=long, restriction_dict={'<STR_LIT>': ['<STR_LIT>']}, int_size=<NUM_LIT:32>), restriction_dict={'<STR_LIT>': [u'<STR_LIT>']}), is_leaf=True, yang_name="<STR_LIT>", rest_name="<STR_LIT>", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions={u'<STR_LIT>': {u'<STR_LIT>': None, u'<STR_LIT:info>': u'<STR_LIT>'}}, is_keyval=True, namespace='<STR_LIT>', defining_module='<STR_LIT>', yang_type='<STR_LIT>', is_config=True)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError({<EOL>'<STR_LIT>': """<STR_LIT>""",<EOL>'<STR_LIT>': "<STR_LIT>",<EOL>'<STR_LIT>': """<STR_LIT>""",<EOL>})<EOL><DEDENT>self.__access_vlan_id = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT>
|
Setter method for access_vlan_id, mapped from YANG variable /interface/homerun/switchport/access_mac_rspan_vlan_classification/access/vlan/access_vlan_id (vlan-type)
If this variable is read-only (config: false) in the
source YANG file, then _set_access_vlan_id is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_access_vlan_id() directly.
YANG Description: Set the default VLAN for the interface
|
f336576:c0:m4
|
def _get_access_mac_address(self):
|
return self.__access_mac_address<EOL>
|
Getter method for access_mac_address, mapped from YANG variable /interface/homerun/switchport/access_mac_rspan_vlan_classification/access/vlan/access_mac_address (mac-address-type)
YANG Description: Associate the Mac address with a vlan
|
f336576:c0:m6
|
def _set_access_mac_address(self, v, load=False):
|
parent = getattr(self, "<STR_LIT>", None)<EOL>if parent is not None and load is False:<EOL><INDENT>raise AttributeError("<STR_LIT>" +<EOL>"<STR_LIT>")<EOL><DEDENT>if hasattr(v, "<STR_LIT>"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(v,base=RestrictedClassType(base_type=unicode, restriction_dict={'<STR_LIT>': u'<STR_LIT>'}), is_leaf=True, yang_name="<STR_LIT>", rest_name="<STR_LIT>", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions={u'<STR_LIT>': {u'<STR_LIT:info>': u'<STR_LIT>', u'<STR_LIT>': u'<STR_LIT>', u'<STR_LIT>': None}}, is_keyval=True, namespace='<STR_LIT>', defining_module='<STR_LIT>', yang_type='<STR_LIT>', is_config=True)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError({<EOL>'<STR_LIT>': """<STR_LIT>""",<EOL>'<STR_LIT>': "<STR_LIT>",<EOL>'<STR_LIT>': """<STR_LIT>""",<EOL>})<EOL><DEDENT>self.__access_mac_address = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT>
|
Setter method for access_mac_address, mapped from YANG variable /interface/homerun/switchport/access_mac_rspan_vlan_classification/access/vlan/access_mac_address (mac-address-type)
If this variable is read-only (config: false) in the
source YANG file, then _set_access_mac_address is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_access_mac_address() directly.
YANG Description: Associate the Mac address with a vlan
|
f336576:c0:m7
|
def _get_vlan(self):
|
return self.__vlan<EOL>
|
Getter method for vlan, mapped from YANG variable /interface/homerun/switchport/access_mac_rspan_vlan_classification/access/vlan (list)
|
f336577:c0:m3
|
def _set_vlan(self, v, load=False):
|
if hasattr(v, "<STR_LIT>"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(v,base=YANGListType("<STR_LIT>",vlan.vlan, yang_name="<STR_LIT>", rest_name="<STR_LIT>", parent=self, is_container='<STR_LIT:list>', user_ordered=False, path_helper=self._path_helper, yang_keys='<STR_LIT>', extensions={u'<STR_LIT>': {u'<STR_LIT>': u'<STR_LIT>', u'<STR_LIT>': None, u'<STR_LIT>': None, u'<STR_LIT>': None, u'<STR_LIT>': u'<STR_LIT>'}}), is_container='<STR_LIT:list>', yang_name="<STR_LIT>", rest_name="<STR_LIT>", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions={u'<STR_LIT>': {u'<STR_LIT>': u'<STR_LIT>', u'<STR_LIT>': None, u'<STR_LIT>': None, u'<STR_LIT>': None, u'<STR_LIT>': u'<STR_LIT>'}}, namespace='<STR_LIT>', defining_module='<STR_LIT>', yang_type='<STR_LIT:list>', is_config=True)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError({<EOL>'<STR_LIT>': """<STR_LIT>""",<EOL>'<STR_LIT>': "<STR_LIT:list>",<EOL>'<STR_LIT>': """<STR_LIT>""",<EOL>})<EOL><DEDENT>self.__vlan = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT>
|
Setter method for vlan, mapped from YANG variable /interface/homerun/switchport/access_mac_rspan_vlan_classification/access/vlan (list)
If this variable is read-only (config: false) in the
source YANG file, then _set_vlan is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_vlan() directly.
|
f336577:c0:m4
|
def _get_access(self):
|
return self.__access<EOL>
|
Getter method for access, mapped from YANG variable /interface/homerun/switchport/access_mac_rspan_vlan_classification/access (container)
YANG Description: The access layer characteristics of this interface.
|
f336578:c0:m3
|
def _set_access(self, v, load=False):
|
if hasattr(v, "<STR_LIT>"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(v,base=access.access, is_container='<STR_LIT>', presence=False, yang_name="<STR_LIT>", rest_name="<STR_LIT>", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions={u'<STR_LIT>': {u'<STR_LIT:info>': u'<STR_LIT>', u'<STR_LIT>': None}}, namespace='<STR_LIT>', defining_module='<STR_LIT>', yang_type='<STR_LIT>', is_config=True)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError({<EOL>'<STR_LIT>': """<STR_LIT>""",<EOL>'<STR_LIT>': "<STR_LIT>",<EOL>'<STR_LIT>': """<STR_LIT>""",<EOL>})<EOL><DEDENT>self.__access = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT>
|
Setter method for access, mapped from YANG variable /interface/homerun/switchport/access_mac_rspan_vlan_classification/access (container)
If this variable is read-only (config: false) in the
source YANG file, then _set_access is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_access() directly.
YANG Description: The access layer characteristics of this interface.
|
f336578:c0:m4
|
def _get_access_vlan_id(self):
|
return self.__access_vlan_id<EOL>
|
Getter method for access_vlan_id, mapped from YANG variable /interface/homerun/switchport/access_mac_group_rspan_vlan_classification/access/vlan/access_vlan_id (vlan-type)
YANG Description: Set the default VLAN for the interface
|
f336579:c0:m3
|
def _set_access_vlan_id(self, v, load=False):
|
parent = getattr(self, "<STR_LIT>", None)<EOL>if parent is not None and load is False:<EOL><INDENT>raise AttributeError("<STR_LIT>" +<EOL>"<STR_LIT>")<EOL><DEDENT>if hasattr(v, "<STR_LIT>"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(v,base=RestrictedClassType(base_type=RestrictedClassType(base_type=long, restriction_dict={'<STR_LIT>': ['<STR_LIT>']}, int_size=<NUM_LIT:32>), restriction_dict={'<STR_LIT>': [u'<STR_LIT>']}), is_leaf=True, yang_name="<STR_LIT>", rest_name="<STR_LIT>", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions={u'<STR_LIT>': {u'<STR_LIT>': None, u'<STR_LIT:info>': u'<STR_LIT>'}}, is_keyval=True, namespace='<STR_LIT>', defining_module='<STR_LIT>', yang_type='<STR_LIT>', is_config=True)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError({<EOL>'<STR_LIT>': """<STR_LIT>""",<EOL>'<STR_LIT>': "<STR_LIT>",<EOL>'<STR_LIT>': """<STR_LIT>""",<EOL>})<EOL><DEDENT>self.__access_vlan_id = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT>
|
Setter method for access_vlan_id, mapped from YANG variable /interface/homerun/switchport/access_mac_group_rspan_vlan_classification/access/vlan/access_vlan_id (vlan-type)
If this variable is read-only (config: false) in the
source YANG file, then _set_access_vlan_id is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_access_vlan_id() directly.
YANG Description: Set the default VLAN for the interface
|
f336579:c0:m4
|
def _get_access_mac_group(self):
|
return self.__access_mac_group<EOL>
|
Getter method for access_mac_group, mapped from YANG variable /interface/homerun/switchport/access_mac_group_rspan_vlan_classification/access/vlan/access_mac_group (mac-group-id-type)
YANG Description: Associate a Mac group with a vlan
|
f336579:c0:m6
|
def _set_access_mac_group(self, v, load=False):
|
parent = getattr(self, "<STR_LIT>", None)<EOL>if parent is not None and load is False:<EOL><INDENT>raise AttributeError("<STR_LIT>" +<EOL>"<STR_LIT>")<EOL><DEDENT>if hasattr(v, "<STR_LIT>"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(v,base=RestrictedClassType(base_type=RestrictedClassType(base_type=long, restriction_dict={'<STR_LIT>': ['<STR_LIT>']}, int_size=<NUM_LIT:32>), restriction_dict={'<STR_LIT>': [u'<STR_LIT>']}), is_leaf=True, yang_name="<STR_LIT>", rest_name="<STR_LIT>", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions={u'<STR_LIT>': {u'<STR_LIT:info>': u'<STR_LIT>', u'<STR_LIT>': u'<STR_LIT>', u'<STR_LIT>': None}}, is_keyval=True, namespace='<STR_LIT>', defining_module='<STR_LIT>', yang_type='<STR_LIT>', is_config=True)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError({<EOL>'<STR_LIT>': """<STR_LIT>""",<EOL>'<STR_LIT>': "<STR_LIT>",<EOL>'<STR_LIT>': """<STR_LIT>""",<EOL>})<EOL><DEDENT>self.__access_mac_group = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT>
|
Setter method for access_mac_group, mapped from YANG variable /interface/homerun/switchport/access_mac_group_rspan_vlan_classification/access/vlan/access_mac_group (mac-group-id-type)
If this variable is read-only (config: false) in the
source YANG file, then _set_access_mac_group is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_access_mac_group() directly.
YANG Description: Associate a Mac group with a vlan
|
f336579:c0:m7
|
def _get_vlan(self):
|
return self.__vlan<EOL>
|
Getter method for vlan, mapped from YANG variable /interface/homerun/switchport/access_mac_group_rspan_vlan_classification/access/vlan (list)
|
f336580:c0:m3
|
def _set_vlan(self, v, load=False):
|
if hasattr(v, "<STR_LIT>"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(v,base=YANGListType("<STR_LIT>",vlan.vlan, yang_name="<STR_LIT>", rest_name="<STR_LIT>", parent=self, is_container='<STR_LIT:list>', user_ordered=False, path_helper=self._path_helper, yang_keys='<STR_LIT>', extensions={u'<STR_LIT>': {u'<STR_LIT>': u'<STR_LIT>', u'<STR_LIT>': None, u'<STR_LIT>': None, u'<STR_LIT>': None, u'<STR_LIT>': u'<STR_LIT>'}}), is_container='<STR_LIT:list>', yang_name="<STR_LIT>", rest_name="<STR_LIT>", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions={u'<STR_LIT>': {u'<STR_LIT>': u'<STR_LIT>', u'<STR_LIT>': None, u'<STR_LIT>': None, u'<STR_LIT>': None, u'<STR_LIT>': u'<STR_LIT>'}}, namespace='<STR_LIT>', defining_module='<STR_LIT>', yang_type='<STR_LIT:list>', is_config=True)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError({<EOL>'<STR_LIT>': """<STR_LIT>""",<EOL>'<STR_LIT>': "<STR_LIT:list>",<EOL>'<STR_LIT>': """<STR_LIT>""",<EOL>})<EOL><DEDENT>self.__vlan = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT>
|
Setter method for vlan, mapped from YANG variable /interface/homerun/switchport/access_mac_group_rspan_vlan_classification/access/vlan (list)
If this variable is read-only (config: false) in the
source YANG file, then _set_vlan is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_vlan() directly.
|
f336580:c0:m4
|
def _get_access(self):
|
return self.__access<EOL>
|
Getter method for access, mapped from YANG variable /interface/homerun/switchport/access_mac_group_rspan_vlan_classification/access (container)
YANG Description: The access layer characteristics of this interface.
|
f336581:c0:m3
|
def _set_access(self, v, load=False):
|
if hasattr(v, "<STR_LIT>"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(v,base=access.access, is_container='<STR_LIT>', presence=False, yang_name="<STR_LIT>", rest_name="<STR_LIT>", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions={u'<STR_LIT>': {u'<STR_LIT:info>': u'<STR_LIT>', u'<STR_LIT>': None}}, namespace='<STR_LIT>', defining_module='<STR_LIT>', yang_type='<STR_LIT>', is_config=True)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError({<EOL>'<STR_LIT>': """<STR_LIT>""",<EOL>'<STR_LIT>': "<STR_LIT>",<EOL>'<STR_LIT>': """<STR_LIT>""",<EOL>})<EOL><DEDENT>self.__access = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT>
|
Setter method for access, mapped from YANG variable /interface/homerun/switchport/access_mac_group_rspan_vlan_classification/access (container)
If this variable is read-only (config: false) in the
source YANG file, then _set_access is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_access() directly.
YANG Description: The access layer characteristics of this interface.
|
f336581:c0:m4
|
def _get_mode(self):
|
return self.__mode<EOL>
|
Getter method for mode, mapped from YANG variable /interface/homerun/switchport/mode (container)
YANG Description: The mode of the Layer2 interface.
|
f336582:c0:m3
|
def _set_mode(self, v, load=False):
|
if hasattr(v, "<STR_LIT>"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(v,base=mode.mode, is_container='<STR_LIT>', presence=False, yang_name="<STR_LIT>", rest_name="<STR_LIT>", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions={u'<STR_LIT>': {u'<STR_LIT:info>': u'<STR_LIT>', u'<STR_LIT>': None}}, namespace='<STR_LIT>', defining_module='<STR_LIT>', yang_type='<STR_LIT>', is_config=True)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError({<EOL>'<STR_LIT>': """<STR_LIT>""",<EOL>'<STR_LIT>': "<STR_LIT>",<EOL>'<STR_LIT>': """<STR_LIT>""",<EOL>})<EOL><DEDENT>self.__mode = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT>
|
Setter method for mode, mapped from YANG variable /interface/homerun/switchport/mode (container)
If this variable is read-only (config: false) in the
source YANG file, then _set_mode is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_mode() directly.
YANG Description: The mode of the Layer2 interface.
|
f336582:c0:m4
|
def _get_port_security(self):
|
return self.__port_security<EOL>
|
Getter method for port_security, mapped from YANG variable /interface/homerun/switchport/port_security (container)
YANG Description: Enable port-security feature
|
f336582:c0:m6
|
def _set_port_security(self, v, load=False):
|
if hasattr(v, "<STR_LIT>"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(v,base=port_security.port_security, is_container='<STR_LIT>', presence=True, yang_name="<STR_LIT>", rest_name="<STR_LIT>", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions={u'<STR_LIT>': {u'<STR_LIT:info>': u'<STR_LIT>', u'<STR_LIT>': u'<STR_LIT>'}}, namespace='<STR_LIT>', defining_module='<STR_LIT>', yang_type='<STR_LIT>', is_config=True)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError({<EOL>'<STR_LIT>': """<STR_LIT>""",<EOL>'<STR_LIT>': "<STR_LIT>",<EOL>'<STR_LIT>': """<STR_LIT>""",<EOL>})<EOL><DEDENT>self.__port_security = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT>
|
Setter method for port_security, mapped from YANG variable /interface/homerun/switchport/port_security (container)
If this variable is read-only (config: false) in the
source YANG file, then _set_port_security is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_port_security() directly.
YANG Description: Enable port-security feature
|
f336582:c0:m7
|
def _get_access(self):
|
return self.__access<EOL>
|
Getter method for access, mapped from YANG variable /interface/homerun/switchport/access (container)
YANG Description: The access layer characteristics of this
interface.
|
f336582:c0:m9
|
def _set_access(self, v, load=False):
|
if hasattr(v, "<STR_LIT>"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(v,base=access.access, is_container='<STR_LIT>', presence=False, yang_name="<STR_LIT>", rest_name="<STR_LIT>", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions={u'<STR_LIT>': {u'<STR_LIT:info>': u'<STR_LIT>', u'<STR_LIT>': None}}, namespace='<STR_LIT>', defining_module='<STR_LIT>', yang_type='<STR_LIT>', is_config=True)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError({<EOL>'<STR_LIT>': """<STR_LIT>""",<EOL>'<STR_LIT>': "<STR_LIT>",<EOL>'<STR_LIT>': """<STR_LIT>""",<EOL>})<EOL><DEDENT>self.__access = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT>
|
Setter method for access, mapped from YANG variable /interface/homerun/switchport/access (container)
If this variable is read-only (config: false) in the
source YANG file, then _set_access is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_access() directly.
YANG Description: The access layer characteristics of this
interface.
|
f336582:c0:m10
|
def _get_access_mac_vlan_classification(self):
|
return self.__access_mac_vlan_classification<EOL>
|
Getter method for access_mac_vlan_classification, mapped from YANG variable /interface/homerun/switchport/access_mac_vlan_classification (container)
|
f336582:c0:m12
|
def _set_access_mac_vlan_classification(self, v, load=False):
|
if hasattr(v, "<STR_LIT>"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(v,base=access_mac_vlan_classification.access_mac_vlan_classification, is_container='<STR_LIT>', presence=False, yang_name="<STR_LIT>", rest_name="<STR_LIT>", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions={u'<STR_LIT>': {u'<STR_LIT>': u'<STR_LIT>', u'<STR_LIT>': u'<STR_LIT>'}}, namespace='<STR_LIT>', defining_module='<STR_LIT>', yang_type='<STR_LIT>', is_config=True)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError({<EOL>'<STR_LIT>': """<STR_LIT>""",<EOL>'<STR_LIT>': "<STR_LIT>",<EOL>'<STR_LIT>': """<STR_LIT>""",<EOL>})<EOL><DEDENT>self.__access_mac_vlan_classification = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT>
|
Setter method for access_mac_vlan_classification, mapped from YANG variable /interface/homerun/switchport/access_mac_vlan_classification (container)
If this variable is read-only (config: false) in the
source YANG file, then _set_access_mac_vlan_classification is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_access_mac_vlan_classification() directly.
|
f336582:c0:m13
|
def _get_access_mac_group_vlan_classification(self):
|
return self.__access_mac_group_vlan_classification<EOL>
|
Getter method for access_mac_group_vlan_classification, mapped from YANG variable /interface/homerun/switchport/access_mac_group_vlan_classification (container)
|
f336582:c0:m15
|
def _set_access_mac_group_vlan_classification(self, v, load=False):
|
if hasattr(v, "<STR_LIT>"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(v,base=access_mac_group_vlan_classification.access_mac_group_vlan_classification, is_container='<STR_LIT>', presence=False, yang_name="<STR_LIT>", rest_name="<STR_LIT>", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions={u'<STR_LIT>': {u'<STR_LIT>': u'<STR_LIT>', u'<STR_LIT>': u'<STR_LIT>'}}, namespace='<STR_LIT>', defining_module='<STR_LIT>', yang_type='<STR_LIT>', is_config=True)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError({<EOL>'<STR_LIT>': """<STR_LIT>""",<EOL>'<STR_LIT>': "<STR_LIT>",<EOL>'<STR_LIT>': """<STR_LIT>""",<EOL>})<EOL><DEDENT>self.__access_mac_group_vlan_classification = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT>
|
Setter method for access_mac_group_vlan_classification, mapped from YANG variable /interface/homerun/switchport/access_mac_group_vlan_classification (container)
If this variable is read-only (config: false) in the
source YANG file, then _set_access_mac_group_vlan_classification is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_access_mac_group_vlan_classification() directly.
|
f336582:c0:m16
|
def _get_trunk(self):
|
return self.__trunk<EOL>
|
Getter method for trunk, mapped from YANG variable /interface/homerun/switchport/trunk (container)
YANG Description: The trunking characteristics of this interface.
|
f336582:c0:m18
|
def _set_trunk(self, v, load=False):
|
if hasattr(v, "<STR_LIT>"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(v,base=trunk.trunk, is_container='<STR_LIT>', presence=False, yang_name="<STR_LIT>", rest_name="<STR_LIT>", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions={u'<STR_LIT>': {u'<STR_LIT:info>': u'<STR_LIT>', u'<STR_LIT>': None, u'<STR_LIT>': None}}, namespace='<STR_LIT>', defining_module='<STR_LIT>', yang_type='<STR_LIT>', is_config=True)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError({<EOL>'<STR_LIT>': """<STR_LIT>""",<EOL>'<STR_LIT>': "<STR_LIT>",<EOL>'<STR_LIT>': """<STR_LIT>""",<EOL>})<EOL><DEDENT>self.__trunk = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT>
|
Setter method for trunk, mapped from YANG variable /interface/homerun/switchport/trunk (container)
If this variable is read-only (config: false) in the
source YANG file, then _set_trunk is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_trunk() directly.
YANG Description: The trunking characteristics of this interface.
|
f336582:c0:m19
|
def _get_access_mac_rspan_vlan_classification(self):
|
return self.__access_mac_rspan_vlan_classification<EOL>
|
Getter method for access_mac_rspan_vlan_classification, mapped from YANG variable /interface/homerun/switchport/access_mac_rspan_vlan_classification (container)
|
f336582:c0:m21
|
def _set_access_mac_rspan_vlan_classification(self, v, load=False):
|
if hasattr(v, "<STR_LIT>"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(v,base=access_mac_rspan_vlan_classification.access_mac_rspan_vlan_classification, is_container='<STR_LIT>', presence=False, yang_name="<STR_LIT>", rest_name="<STR_LIT>", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions={u'<STR_LIT>': {u'<STR_LIT>': u'<STR_LIT>'}}, namespace='<STR_LIT>', defining_module='<STR_LIT>', yang_type='<STR_LIT>', is_config=True)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError({<EOL>'<STR_LIT>': """<STR_LIT>""",<EOL>'<STR_LIT>': "<STR_LIT>",<EOL>'<STR_LIT>': """<STR_LIT>""",<EOL>})<EOL><DEDENT>self.__access_mac_rspan_vlan_classification = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT>
|
Setter method for access_mac_rspan_vlan_classification, mapped from YANG variable /interface/homerun/switchport/access_mac_rspan_vlan_classification (container)
If this variable is read-only (config: false) in the
source YANG file, then _set_access_mac_rspan_vlan_classification is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_access_mac_rspan_vlan_classification() directly.
|
f336582:c0:m22
|
def _get_access_mac_group_rspan_vlan_classification(self):
|
return self.__access_mac_group_rspan_vlan_classification<EOL>
|
Getter method for access_mac_group_rspan_vlan_classification, mapped from YANG variable /interface/homerun/switchport/access_mac_group_rspan_vlan_classification (container)
|
f336582:c0:m24
|
def _set_access_mac_group_rspan_vlan_classification(self, v, load=False):
|
if hasattr(v, "<STR_LIT>"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(v,base=access_mac_group_rspan_vlan_classification.access_mac_group_rspan_vlan_classification, is_container='<STR_LIT>', presence=False, yang_name="<STR_LIT>", rest_name="<STR_LIT>", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions={u'<STR_LIT>': {u'<STR_LIT>': u'<STR_LIT>'}}, namespace='<STR_LIT>', defining_module='<STR_LIT>', yang_type='<STR_LIT>', is_config=True)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError({<EOL>'<STR_LIT>': """<STR_LIT>""",<EOL>'<STR_LIT>': "<STR_LIT>",<EOL>'<STR_LIT>': """<STR_LIT>""",<EOL>})<EOL><DEDENT>self.__access_mac_group_rspan_vlan_classification = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT>
|
Setter method for access_mac_group_rspan_vlan_classification, mapped from YANG variable /interface/homerun/switchport/access_mac_group_rspan_vlan_classification (container)
If this variable is read-only (config: false) in the
source YANG file, then _set_access_mac_group_rspan_vlan_classification is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_access_mac_group_rspan_vlan_classification() directly.
|
f336582:c0:m25
|
def _get_mac_address(self):
|
return self.__mac_address<EOL>
|
Getter method for mac_address, mapped from YANG variable /interface/homerun/switchport/port_security/port_secutiry_mac_address/mac_address (mac-address-type)
YANG Description: Mac Address
|
f336583:c0:m3
|
def _set_mac_address(self, v, load=False):
|
parent = getattr(self, "<STR_LIT>", None)<EOL>if parent is not None and load is False:<EOL><INDENT>raise AttributeError("<STR_LIT>" +<EOL>"<STR_LIT>")<EOL><DEDENT>if hasattr(v, "<STR_LIT>"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(v,base=RestrictedClassType(base_type=unicode, restriction_dict={'<STR_LIT>': u'<STR_LIT>'}), is_leaf=True, yang_name="<STR_LIT>", rest_name="<STR_LIT>", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions={u'<STR_LIT>': {u'<STR_LIT:info>': u'<STR_LIT>', u'<STR_LIT>': None}}, is_keyval=True, namespace='<STR_LIT>', defining_module='<STR_LIT>', yang_type='<STR_LIT>', is_config=True)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError({<EOL>'<STR_LIT>': """<STR_LIT>""",<EOL>'<STR_LIT>': "<STR_LIT>",<EOL>'<STR_LIT>': """<STR_LIT>""",<EOL>})<EOL><DEDENT>self.__mac_address = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT>
|
Setter method for mac_address, mapped from YANG variable /interface/homerun/switchport/port_security/port_secutiry_mac_address/mac_address (mac-address-type)
If this variable is read-only (config: false) in the
source YANG file, then _set_mac_address is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_mac_address() directly.
YANG Description: Mac Address
|
f336583:c0:m4
|
def _get_port_sec_vlan(self):
|
return self.__port_sec_vlan<EOL>
|
Getter method for port_sec_vlan, mapped from YANG variable /interface/homerun/switchport/port_security/port_secutiry_mac_address/port_sec_vlan (vlan-type)
YANG Description: Forwarding vlan
|
f336583:c0:m6
|
def _set_port_sec_vlan(self, v, load=False):
|
parent = getattr(self, "<STR_LIT>", None)<EOL>if parent is not None and load is False:<EOL><INDENT>raise AttributeError("<STR_LIT>" +<EOL>"<STR_LIT>")<EOL><DEDENT>if hasattr(v, "<STR_LIT>"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(v,base=RestrictedClassType(base_type=RestrictedClassType(base_type=long, restriction_dict={'<STR_LIT>': ['<STR_LIT>']}, int_size=<NUM_LIT:32>), restriction_dict={'<STR_LIT>': [u'<STR_LIT>']}), is_leaf=True, yang_name="<STR_LIT>", rest_name="<STR_LIT>", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions={u'<STR_LIT>': {u'<STR_LIT:info>': u'<STR_LIT>', u'<STR_LIT>': u'<STR_LIT>', u'<STR_LIT>': None}}, is_keyval=True, namespace='<STR_LIT>', defining_module='<STR_LIT>', yang_type='<STR_LIT>', is_config=True)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError({<EOL>'<STR_LIT>': """<STR_LIT>""",<EOL>'<STR_LIT>': "<STR_LIT>",<EOL>'<STR_LIT>': """<STR_LIT>""",<EOL>})<EOL><DEDENT>self.__port_sec_vlan = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT>
|
Setter method for port_sec_vlan, mapped from YANG variable /interface/homerun/switchport/port_security/port_secutiry_mac_address/port_sec_vlan (vlan-type)
If this variable is read-only (config: false) in the
source YANG file, then _set_port_sec_vlan is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_port_sec_vlan() directly.
YANG Description: Forwarding vlan
|
f336583:c0:m7
|
def _get_mac_address(self):
|
return self.__mac_address<EOL>
|
Getter method for mac_address, mapped from YANG variable /interface/homerun/switchport/port_security/sticky/port_secutiry_mac_address/mac_address (mac-address-type)
YANG Description: Mac Address
|
f336584:c0:m3
|
def _set_mac_address(self, v, load=False):
|
parent = getattr(self, "<STR_LIT>", None)<EOL>if parent is not None and load is False:<EOL><INDENT>raise AttributeError("<STR_LIT>" +<EOL>"<STR_LIT>")<EOL><DEDENT>if hasattr(v, "<STR_LIT>"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(v,base=RestrictedClassType(base_type=unicode, restriction_dict={'<STR_LIT>': u'<STR_LIT>'}), is_leaf=True, yang_name="<STR_LIT>", rest_name="<STR_LIT>", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions={u'<STR_LIT>': {u'<STR_LIT:info>': u'<STR_LIT>', u'<STR_LIT>': None}}, is_keyval=True, namespace='<STR_LIT>', defining_module='<STR_LIT>', yang_type='<STR_LIT>', is_config=True)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError({<EOL>'<STR_LIT>': """<STR_LIT>""",<EOL>'<STR_LIT>': "<STR_LIT>",<EOL>'<STR_LIT>': """<STR_LIT>""",<EOL>})<EOL><DEDENT>self.__mac_address = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT>
|
Setter method for mac_address, mapped from YANG variable /interface/homerun/switchport/port_security/sticky/port_secutiry_mac_address/mac_address (mac-address-type)
If this variable is read-only (config: false) in the
source YANG file, then _set_mac_address is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_mac_address() directly.
YANG Description: Mac Address
|
f336584:c0:m4
|
def _get_port_sec_vlan(self):
|
return self.__port_sec_vlan<EOL>
|
Getter method for port_sec_vlan, mapped from YANG variable /interface/homerun/switchport/port_security/sticky/port_secutiry_mac_address/port_sec_vlan (vlan-type)
YANG Description: Forwarding vlan
|
f336584:c0:m6
|
def _set_port_sec_vlan(self, v, load=False):
|
parent = getattr(self, "<STR_LIT>", None)<EOL>if parent is not None and load is False:<EOL><INDENT>raise AttributeError("<STR_LIT>" +<EOL>"<STR_LIT>")<EOL><DEDENT>if hasattr(v, "<STR_LIT>"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(v,base=RestrictedClassType(base_type=RestrictedClassType(base_type=long, restriction_dict={'<STR_LIT>': ['<STR_LIT>']}, int_size=<NUM_LIT:32>), restriction_dict={'<STR_LIT>': [u'<STR_LIT>']}), is_leaf=True, yang_name="<STR_LIT>", rest_name="<STR_LIT>", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions={u'<STR_LIT>': {u'<STR_LIT:info>': u'<STR_LIT>', u'<STR_LIT>': u'<STR_LIT>', u'<STR_LIT>': None}}, is_keyval=True, namespace='<STR_LIT>', defining_module='<STR_LIT>', yang_type='<STR_LIT>', is_config=True)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError({<EOL>'<STR_LIT>': """<STR_LIT>""",<EOL>'<STR_LIT>': "<STR_LIT>",<EOL>'<STR_LIT>': """<STR_LIT>""",<EOL>})<EOL><DEDENT>self.__port_sec_vlan = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT>
|
Setter method for port_sec_vlan, mapped from YANG variable /interface/homerun/switchport/port_security/sticky/port_secutiry_mac_address/port_sec_vlan (vlan-type)
If this variable is read-only (config: false) in the
source YANG file, then _set_port_sec_vlan is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_port_sec_vlan() directly.
YANG Description: Forwarding vlan
|
f336584:c0:m7
|
def _get_port_secutiry_mac_address(self):
|
return self.__port_secutiry_mac_address<EOL>
|
Getter method for port_secutiry_mac_address, mapped from YANG variable /interface/homerun/switchport/port_security/sticky/port_secutiry_mac_address (list)
YANG Description: Mac Address commands
|
f336585:c0:m3
|
def _set_port_secutiry_mac_address(self, v, load=False):
|
if hasattr(v, "<STR_LIT>"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(v,base=YANGListType("<STR_LIT>",port_secutiry_mac_address.port_secutiry_mac_address, yang_name="<STR_LIT>", rest_name="<STR_LIT>", parent=self, is_container='<STR_LIT:list>', user_ordered=False, path_helper=self._path_helper, yang_keys='<STR_LIT>', extensions={u'<STR_LIT>': {u'<STR_LIT:info>': u'<STR_LIT>', u'<STR_LIT>': None, u'<STR_LIT>': None, u'<STR_LIT>': u'<STR_LIT>', u'<STR_LIT>': None}}), is_container='<STR_LIT:list>', yang_name="<STR_LIT>", rest_name="<STR_LIT>", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions={u'<STR_LIT>': {u'<STR_LIT:info>': u'<STR_LIT>', u'<STR_LIT>': None, u'<STR_LIT>': None, u'<STR_LIT>': u'<STR_LIT>', u'<STR_LIT>': None}}, namespace='<STR_LIT>', defining_module='<STR_LIT>', yang_type='<STR_LIT:list>', is_config=True)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError({<EOL>'<STR_LIT>': """<STR_LIT>""",<EOL>'<STR_LIT>': "<STR_LIT:list>",<EOL>'<STR_LIT>': """<STR_LIT>""",<EOL>})<EOL><DEDENT>self.__port_secutiry_mac_address = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT>
|
Setter method for port_secutiry_mac_address, mapped from YANG variable /interface/homerun/switchport/port_security/sticky/port_secutiry_mac_address (list)
If this variable is read-only (config: false) in the
source YANG file, then _set_port_secutiry_mac_address is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_port_secutiry_mac_address() directly.
YANG Description: Mac Address commands
|
f336585:c0:m4
|
def _get_port_sec_max(self):
|
return self.__port_sec_max<EOL>
|
Getter method for port_sec_max, mapped from YANG variable /interface/homerun/switchport/port_security/port_sec_max (uint32)
YANG Description: Maximum number of allowed MACs
|
f336586:c0:m3
|
def _set_port_sec_max(self, v, load=False):
|
if hasattr(v, "<STR_LIT>"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(v,base=RestrictedClassType(base_type=RestrictedClassType(base_type=long, restriction_dict={'<STR_LIT>': ['<STR_LIT>']}, int_size=<NUM_LIT:32>), restriction_dict={'<STR_LIT>': [u'<STR_LIT>']}), is_leaf=True, yang_name="<STR_LIT>", rest_name="<STR_LIT>", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions={u'<STR_LIT>': {u'<STR_LIT>': None, u'<STR_LIT:info>': u'<STR_LIT>', u'<STR_LIT>': u'<STR_LIT>', u'<STR_LIT>': u'<STR_LIT>'}}, namespace='<STR_LIT>', defining_module='<STR_LIT>', yang_type='<STR_LIT>', is_config=True)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError({<EOL>'<STR_LIT>': """<STR_LIT>""",<EOL>'<STR_LIT>': "<STR_LIT>",<EOL>'<STR_LIT>': """<STR_LIT>""",<EOL>})<EOL><DEDENT>self.__port_sec_max = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT>
|
Setter method for port_sec_max, mapped from YANG variable /interface/homerun/switchport/port_security/port_sec_max (uint32)
If this variable is read-only (config: false) in the
source YANG file, then _set_port_sec_max is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_port_sec_max() directly.
YANG Description: Maximum number of allowed MACs
|
f336586:c0:m4
|
def _get_port_sec_violation(self):
|
return self.__port_sec_violation<EOL>
|
Getter method for port_sec_violation, mapped from YANG variable /interface/homerun/switchport/port_security/port_sec_violation (port-sec-violation)
YANG Description: Set the action on violation
|
f336586:c0:m6
|
def _set_port_sec_violation(self, v, load=False):
|
if hasattr(v, "<STR_LIT>"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(v,base=RestrictedClassType(base_type=unicode, restriction_type="<STR_LIT>", restriction_arg={u'<STR_LIT>': {'<STR_LIT:value>': <NUM_LIT:1>}, u'<STR_LIT>': {'<STR_LIT:value>': <NUM_LIT:2>}},), is_leaf=True, yang_name="<STR_LIT>", rest_name="<STR_LIT>", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions={u'<STR_LIT>': {u'<STR_LIT>': None, u'<STR_LIT:info>': u'<STR_LIT>', u'<STR_LIT>': u'<STR_LIT>'}}, namespace='<STR_LIT>', defining_module='<STR_LIT>', yang_type='<STR_LIT>', is_config=True)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError({<EOL>'<STR_LIT>': """<STR_LIT>""",<EOL>'<STR_LIT>': "<STR_LIT>",<EOL>'<STR_LIT>': """<STR_LIT>""",<EOL>})<EOL><DEDENT>self.__port_sec_violation = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT>
|
Setter method for port_sec_violation, mapped from YANG variable /interface/homerun/switchport/port_security/port_sec_violation (port-sec-violation)
If this variable is read-only (config: false) in the
source YANG file, then _set_port_sec_violation is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_port_sec_violation() directly.
YANG Description: Set the action on violation
|
f336586:c0:m7
|
def _get_port_secutiry_mac_address(self):
|
return self.__port_secutiry_mac_address<EOL>
|
Getter method for port_secutiry_mac_address, mapped from YANG variable /interface/homerun/switchport/port_security/port_secutiry_mac_address (list)
YANG Description: Mac Address commands
|
f336586:c0:m9
|
def _set_port_secutiry_mac_address(self, v, load=False):
|
if hasattr(v, "<STR_LIT>"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(v,base=YANGListType("<STR_LIT>",port_secutiry_mac_address.port_secutiry_mac_address, yang_name="<STR_LIT>", rest_name="<STR_LIT>", parent=self, is_container='<STR_LIT:list>', user_ordered=False, path_helper=self._path_helper, yang_keys='<STR_LIT>', extensions={u'<STR_LIT>': {u'<STR_LIT:info>': u'<STR_LIT>', u'<STR_LIT>': None, u'<STR_LIT>': None, u'<STR_LIT>': u'<STR_LIT>', u'<STR_LIT>': None}}), is_container='<STR_LIT:list>', yang_name="<STR_LIT>", rest_name="<STR_LIT>", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions={u'<STR_LIT>': {u'<STR_LIT:info>': u'<STR_LIT>', u'<STR_LIT>': None, u'<STR_LIT>': None, u'<STR_LIT>': u'<STR_LIT>', u'<STR_LIT>': None}}, namespace='<STR_LIT>', defining_module='<STR_LIT>', yang_type='<STR_LIT:list>', is_config=True)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError({<EOL>'<STR_LIT>': """<STR_LIT>""",<EOL>'<STR_LIT>': "<STR_LIT:list>",<EOL>'<STR_LIT>': """<STR_LIT>""",<EOL>})<EOL><DEDENT>self.__port_secutiry_mac_address = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT>
|
Setter method for port_secutiry_mac_address, mapped from YANG variable /interface/homerun/switchport/port_security/port_secutiry_mac_address (list)
If this variable is read-only (config: false) in the
source YANG file, then _set_port_secutiry_mac_address is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_port_secutiry_mac_address() directly.
YANG Description: Mac Address commands
|
f336586:c0:m10
|
def _get_sticky(self):
|
return self.__sticky<EOL>
|
Getter method for sticky, mapped from YANG variable /interface/homerun/switchport/port_security/sticky (container)
YANG Description: Sticky MAC
|
f336586:c0:m12
|
def _set_sticky(self, v, load=False):
|
if hasattr(v, "<STR_LIT>"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(v,base=sticky.sticky, is_container='<STR_LIT>', presence=True, yang_name="<STR_LIT>", rest_name="<STR_LIT>", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions={u'<STR_LIT>': {u'<STR_LIT:info>': u'<STR_LIT>', u'<STR_LIT>': u'<STR_LIT>'}}, namespace='<STR_LIT>', defining_module='<STR_LIT>', yang_type='<STR_LIT>', is_config=True)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError({<EOL>'<STR_LIT>': """<STR_LIT>""",<EOL>'<STR_LIT>': "<STR_LIT>",<EOL>'<STR_LIT>': """<STR_LIT>""",<EOL>})<EOL><DEDENT>self.__sticky = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT>
|
Setter method for sticky, mapped from YANG variable /interface/homerun/switchport/port_security/sticky (container)
If this variable is read-only (config: false) in the
source YANG file, then _set_sticky is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_sticky() directly.
YANG Description: Sticky MAC
|
f336586:c0:m13
|
def _get_shutdown_time(self):
|
return self.__shutdown_time<EOL>
|
Getter method for shutdown_time, mapped from YANG variable /interface/homerun/switchport/port_security/shutdown_time (uint32)
YANG Description: Shutdown time for port
|
f336586:c0:m15
|
def _set_shutdown_time(self, v, load=False):
|
if hasattr(v, "<STR_LIT>"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(v,base=RestrictedClassType(base_type=RestrictedClassType(base_type=long, restriction_dict={'<STR_LIT>': ['<STR_LIT>']}, int_size=<NUM_LIT:32>), restriction_dict={'<STR_LIT>': [u'<STR_LIT>']}), is_leaf=True, yang_name="<STR_LIT>", rest_name="<STR_LIT>", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions={u'<STR_LIT>': {u'<STR_LIT:info>': u'<STR_LIT>', u'<STR_LIT>': None}}, namespace='<STR_LIT>', defining_module='<STR_LIT>', yang_type='<STR_LIT>', is_config=True)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError({<EOL>'<STR_LIT>': """<STR_LIT>""",<EOL>'<STR_LIT>': "<STR_LIT>",<EOL>'<STR_LIT>': """<STR_LIT>""",<EOL>})<EOL><DEDENT>self.__shutdown_time = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT>
|
Setter method for shutdown_time, mapped from YANG variable /interface/homerun/switchport/port_security/shutdown_time (uint32)
If this variable is read-only (config: false) in the
source YANG file, then _set_shutdown_time is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_shutdown_time() directly.
YANG Description: Shutdown time for port
|
f336586:c0:m16
|
def _get_vlan_mode(self):
|
return self.__vlan_mode<EOL>
|
Getter method for vlan_mode, mapped from YANG variable /interface/homerun/switchport/mode/vlan_mode (l2-mode-type)
YANG Description: The access/trunk mode of this interface.
|
f336587:c0:m3
|
def _set_vlan_mode(self, v, load=False):
|
if hasattr(v, "<STR_LIT>"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(v,base=RestrictedClassType(base_type=unicode, restriction_type="<STR_LIT>", restriction_arg={u'<STR_LIT>': {'<STR_LIT:value>': <NUM_LIT:1>}, u'<STR_LIT>': {'<STR_LIT:value>': <NUM_LIT:9>}, u'<STR_LIT>': {'<STR_LIT:value>': <NUM_LIT:2>}},), is_leaf=True, yang_name="<STR_LIT>", rest_name="<STR_LIT>", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions={u'<STR_LIT>': {u'<STR_LIT>': None, u'<STR_LIT>': None}}, namespace='<STR_LIT>', defining_module='<STR_LIT>', yang_type='<STR_LIT>', is_config=True)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError({<EOL>'<STR_LIT>': """<STR_LIT>""",<EOL>'<STR_LIT>': "<STR_LIT>",<EOL>'<STR_LIT>': """<STR_LIT>""",<EOL>})<EOL><DEDENT>self.__vlan_mode = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT>
|
Setter method for vlan_mode, mapped from YANG variable /interface/homerun/switchport/mode/vlan_mode (l2-mode-type)
If this variable is read-only (config: false) in the
source YANG file, then _set_vlan_mode is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_vlan_mode() directly.
YANG Description: The access/trunk mode of this interface.
|
f336587:c0:m4
|
def _get_access_vlan_id(self):
|
return self.__access_vlan_id<EOL>
|
Getter method for access_vlan_id, mapped from YANG variable /interface/homerun/switchport/access_mac_group_vlan_classification/access/vlan/access_vlan_id (vlan-type)
YANG Description: Set the default VLAN for the interface
|
f336588:c0:m3
|
def _set_access_vlan_id(self, v, load=False):
|
parent = getattr(self, "<STR_LIT>", None)<EOL>if parent is not None and load is False:<EOL><INDENT>raise AttributeError("<STR_LIT>" +<EOL>"<STR_LIT>")<EOL><DEDENT>if hasattr(v, "<STR_LIT>"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(v,base=RestrictedClassType(base_type=RestrictedClassType(base_type=long, restriction_dict={'<STR_LIT>': ['<STR_LIT>']}, int_size=<NUM_LIT:32>), restriction_dict={'<STR_LIT>': [u'<STR_LIT>']}), is_leaf=True, yang_name="<STR_LIT>", rest_name="<STR_LIT>", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions={u'<STR_LIT>': {u'<STR_LIT>': None, u'<STR_LIT:info>': u'<STR_LIT>'}}, is_keyval=True, namespace='<STR_LIT>', defining_module='<STR_LIT>', yang_type='<STR_LIT>', is_config=True)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError({<EOL>'<STR_LIT>': """<STR_LIT>""",<EOL>'<STR_LIT>': "<STR_LIT>",<EOL>'<STR_LIT>': """<STR_LIT>""",<EOL>})<EOL><DEDENT>self.__access_vlan_id = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT>
|
Setter method for access_vlan_id, mapped from YANG variable /interface/homerun/switchport/access_mac_group_vlan_classification/access/vlan/access_vlan_id (vlan-type)
If this variable is read-only (config: false) in the
source YANG file, then _set_access_vlan_id is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_access_vlan_id() directly.
YANG Description: Set the default VLAN for the interface
|
f336588:c0:m4
|
def _get_access_mac_group(self):
|
return self.__access_mac_group<EOL>
|
Getter method for access_mac_group, mapped from YANG variable /interface/homerun/switchport/access_mac_group_vlan_classification/access/vlan/access_mac_group (mac-group-id-type)
YANG Description: Associate a Mac group with a vlan
|
f336588:c0:m6
|
def _set_access_mac_group(self, v, load=False):
|
parent = getattr(self, "<STR_LIT>", None)<EOL>if parent is not None and load is False:<EOL><INDENT>raise AttributeError("<STR_LIT>" +<EOL>"<STR_LIT>")<EOL><DEDENT>if hasattr(v, "<STR_LIT>"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(v,base=RestrictedClassType(base_type=RestrictedClassType(base_type=long, restriction_dict={'<STR_LIT>': ['<STR_LIT>']}, int_size=<NUM_LIT:32>), restriction_dict={'<STR_LIT>': [u'<STR_LIT>']}), is_leaf=True, yang_name="<STR_LIT>", rest_name="<STR_LIT>", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions={u'<STR_LIT>': {u'<STR_LIT:info>': u'<STR_LIT>', u'<STR_LIT>': u'<STR_LIT>', u'<STR_LIT>': None}}, is_keyval=True, namespace='<STR_LIT>', defining_module='<STR_LIT>', yang_type='<STR_LIT>', is_config=True)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError({<EOL>'<STR_LIT>': """<STR_LIT>""",<EOL>'<STR_LIT>': "<STR_LIT>",<EOL>'<STR_LIT>': """<STR_LIT>""",<EOL>})<EOL><DEDENT>self.__access_mac_group = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT>
|
Setter method for access_mac_group, mapped from YANG variable /interface/homerun/switchport/access_mac_group_vlan_classification/access/vlan/access_mac_group (mac-group-id-type)
If this variable is read-only (config: false) in the
source YANG file, then _set_access_mac_group is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_access_mac_group() directly.
YANG Description: Associate a Mac group with a vlan
|
f336588:c0:m7
|
def _get_vlan(self):
|
return self.__vlan<EOL>
|
Getter method for vlan, mapped from YANG variable /interface/homerun/switchport/access_mac_group_vlan_classification/access/vlan (list)
|
f336589:c0:m3
|
def _set_vlan(self, v, load=False):
|
if hasattr(v, "<STR_LIT>"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(v,base=YANGListType("<STR_LIT>",vlan.vlan, yang_name="<STR_LIT>", rest_name="<STR_LIT>", parent=self, is_container='<STR_LIT:list>', user_ordered=False, path_helper=self._path_helper, yang_keys='<STR_LIT>', extensions={u'<STR_LIT>': {u'<STR_LIT>': None, u'<STR_LIT>': None, u'<STR_LIT>': None}}), is_container='<STR_LIT:list>', yang_name="<STR_LIT>", rest_name="<STR_LIT>", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions={u'<STR_LIT>': {u'<STR_LIT>': None, u'<STR_LIT>': None, u'<STR_LIT>': None}}, namespace='<STR_LIT>', defining_module='<STR_LIT>', yang_type='<STR_LIT:list>', is_config=True)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError({<EOL>'<STR_LIT>': """<STR_LIT>""",<EOL>'<STR_LIT>': "<STR_LIT:list>",<EOL>'<STR_LIT>': """<STR_LIT>""",<EOL>})<EOL><DEDENT>self.__vlan = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT>
|
Setter method for vlan, mapped from YANG variable /interface/homerun/switchport/access_mac_group_vlan_classification/access/vlan (list)
If this variable is read-only (config: false) in the
source YANG file, then _set_vlan is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_vlan() directly.
|
f336589:c0:m4
|
def _get_access(self):
|
return self.__access<EOL>
|
Getter method for access, mapped from YANG variable /interface/homerun/switchport/access_mac_group_vlan_classification/access (container)
YANG Description: The access layer characteristics of this
interface.
|
f336590:c0:m3
|
def _set_access(self, v, load=False):
|
if hasattr(v, "<STR_LIT>"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(v,base=access.access, is_container='<STR_LIT>', presence=False, yang_name="<STR_LIT>", rest_name="<STR_LIT>", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions={u'<STR_LIT>': {u'<STR_LIT:info>': u'<STR_LIT>', u'<STR_LIT>': None}}, namespace='<STR_LIT>', defining_module='<STR_LIT>', yang_type='<STR_LIT>', is_config=True)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError({<EOL>'<STR_LIT>': """<STR_LIT>""",<EOL>'<STR_LIT>': "<STR_LIT>",<EOL>'<STR_LIT>': """<STR_LIT>""",<EOL>})<EOL><DEDENT>self.__access = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT>
|
Setter method for access, mapped from YANG variable /interface/homerun/switchport/access_mac_group_vlan_classification/access (container)
If this variable is read-only (config: false) in the
source YANG file, then _set_access is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_access() directly.
YANG Description: The access layer characteristics of this
interface.
|
f336590:c0:m4
|
def _get_remove_all_track_interfaces(self):
|
return self.__remove_all_track_interfaces<EOL>
|
Getter method for remove_all_track_interfaces, mapped from YANG variable /interface/homerun/track/remove/remove_all_track_interfaces (empty)
YANG Description: Remove Link State Tracking configuration from this interface
|
f336591:c0:m3
|
def _set_remove_all_track_interfaces(self, v, load=False):
|
if hasattr(v, "<STR_LIT>"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(v,base=YANGBool, is_leaf=True, yang_name="<STR_LIT>", rest_name="<STR_LIT:all>", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions={u'<STR_LIT>': {u'<STR_LIT:info>': u'<STR_LIT>', u'<STR_LIT>': u'<STR_LIT:all>'}}, namespace='<STR_LIT>', defining_module='<STR_LIT>', yang_type='<STR_LIT>', is_config=True)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError({<EOL>'<STR_LIT>': """<STR_LIT>""",<EOL>'<STR_LIT>': "<STR_LIT>",<EOL>'<STR_LIT>': """<STR_LIT>""",<EOL>})<EOL><DEDENT>self.__remove_all_track_interfaces = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT>
|
Setter method for remove_all_track_interfaces, mapped from YANG variable /interface/homerun/track/remove/remove_all_track_interfaces (empty)
If this variable is read-only (config: false) in the
source YANG file, then _set_remove_all_track_interfaces is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_remove_all_track_interfaces() directly.
YANG Description: Remove Link State Tracking configuration from this interface
|
f336591:c0:m4
|
def _get_track_interface_type(self):
|
return self.__track_interface_type<EOL>
|
Getter method for track_interface_type, mapped from YANG variable /interface/homerun/track/interface/track_interface_type (enumeration)
|
f336592:c0:m3
|
def _set_track_interface_type(self, v, load=False):
|
parent = getattr(self, "<STR_LIT>", None)<EOL>if parent is not None and load is False:<EOL><INDENT>raise AttributeError("<STR_LIT>" +<EOL>"<STR_LIT>")<EOL><DEDENT>if hasattr(v, "<STR_LIT>"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(v,base=RestrictedClassType(base_type=unicode, restriction_type="<STR_LIT>", restriction_arg={u'<STR_LIT>': {'<STR_LIT:value>': <NUM_LIT:0>}, u'<STR_LIT>': {'<STR_LIT:value>': <NUM_LIT:1>}},), is_leaf=True, yang_name="<STR_LIT>", rest_name="<STR_LIT>", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions={u'<STR_LIT>': {u'<STR_LIT>': None}}, is_keyval=True, namespace='<STR_LIT>', defining_module='<STR_LIT>', yang_type='<STR_LIT>', is_config=True)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError({<EOL>'<STR_LIT>': """<STR_LIT>""",<EOL>'<STR_LIT>': "<STR_LIT>",<EOL>'<STR_LIT>': """<STR_LIT>""",<EOL>})<EOL><DEDENT>self.__track_interface_type = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT>
|
Setter method for track_interface_type, mapped from YANG variable /interface/homerun/track/interface/track_interface_type (enumeration)
If this variable is read-only (config: false) in the
source YANG file, then _set_track_interface_type is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_track_interface_type() directly.
|
f336592:c0:m4
|
def _get_track_interface_name(self):
|
return self.__track_interface_name<EOL>
|
Getter method for track_interface_name, mapped from YANG variable /interface/homerun/track/interface/track_interface_name (string)
YANG Description: Interface name
|
f336592:c0:m6
|
def _set_track_interface_name(self, v, load=False):
|
parent = getattr(self, "<STR_LIT>", None)<EOL>if parent is not None and load is False:<EOL><INDENT>raise AttributeError("<STR_LIT>" +<EOL>"<STR_LIT>")<EOL><DEDENT>if hasattr(v, "<STR_LIT>"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(v,base=RestrictedClassType(base_type=unicode, restriction_dict={'<STR_LIT>': u'<STR_LIT>'}), is_leaf=True, yang_name="<STR_LIT>", rest_name="<STR_LIT>", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions={u'<STR_LIT>': {u'<STR_LIT:info>': u'<STR_LIT>', u'<STR_LIT>': None}}, is_keyval=True, namespace='<STR_LIT>', defining_module='<STR_LIT>', yang_type='<STR_LIT:string>', is_config=True)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError({<EOL>'<STR_LIT>': """<STR_LIT>""",<EOL>'<STR_LIT>': "<STR_LIT:string>",<EOL>'<STR_LIT>': """<STR_LIT>""",<EOL>})<EOL><DEDENT>self.__track_interface_name = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT>
|
Setter method for track_interface_name, mapped from YANG variable /interface/homerun/track/interface/track_interface_name (string)
If this variable is read-only (config: false) in the
source YANG file, then _set_track_interface_name is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_track_interface_name() directly.
YANG Description: Interface name
|
f336592:c0:m7
|
def _get_track_enable(self):
|
return self.__track_enable<EOL>
|
Getter method for track_enable, mapped from YANG variable /interface/homerun/track/track_enable (empty)
YANG Description: Enable tracking interface
|
f336593:c0:m3
|
def _set_track_enable(self, v, load=False):
|
if hasattr(v, "<STR_LIT>"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(v,base=YANGBool, is_leaf=True, yang_name="<STR_LIT>", rest_name="<STR_LIT>", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions={u'<STR_LIT>': {u'<STR_LIT>': None, u'<STR_LIT:info>': u'<STR_LIT>', u'<STR_LIT>': u'<STR_LIT>', u'<STR_LIT>': None}}, namespace='<STR_LIT>', defining_module='<STR_LIT>', yang_type='<STR_LIT>', is_config=True)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError({<EOL>'<STR_LIT>': """<STR_LIT>""",<EOL>'<STR_LIT>': "<STR_LIT>",<EOL>'<STR_LIT>': """<STR_LIT>""",<EOL>})<EOL><DEDENT>self.__track_enable = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT>
|
Setter method for track_enable, mapped from YANG variable /interface/homerun/track/track_enable (empty)
If this variable is read-only (config: false) in the
source YANG file, then _set_track_enable is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_track_enable() directly.
YANG Description: Enable tracking interface
|
f336593:c0:m4
|
def _get_min_link(self):
|
return self.__min_link<EOL>
|
Getter method for min_link, mapped from YANG variable /interface/homerun/track/min_link (uint32)
YANG Description: Min link
|
f336593:c0:m6
|
def _set_min_link(self, v, load=False):
|
if hasattr(v, "<STR_LIT>"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(v,base=RestrictedClassType(base_type=RestrictedClassType(base_type=long, restriction_dict={'<STR_LIT>': ['<STR_LIT>']}, int_size=<NUM_LIT:32>), restriction_dict={'<STR_LIT>': [u'<STR_LIT>']}), is_leaf=True, yang_name="<STR_LIT>", rest_name="<STR_LIT>", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions={u'<STR_LIT>': {u'<STR_LIT>': None, u'<STR_LIT:info>': u'<STR_LIT>', u'<STR_LIT>': None}}, namespace='<STR_LIT>', defining_module='<STR_LIT>', yang_type='<STR_LIT>', is_config=True)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError({<EOL>'<STR_LIT>': """<STR_LIT>""",<EOL>'<STR_LIT>': "<STR_LIT>",<EOL>'<STR_LIT>': """<STR_LIT>""",<EOL>})<EOL><DEDENT>self.__min_link = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT>
|
Setter method for min_link, mapped from YANG variable /interface/homerun/track/min_link (uint32)
If this variable is read-only (config: false) in the
source YANG file, then _set_min_link is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_min_link() directly.
YANG Description: Min link
|
f336593:c0:m7
|
def _get_interface(self):
|
return self.__interface<EOL>
|
Getter method for interface, mapped from YANG variable /interface/homerun/track/interface (list)
YANG Description: Interface or Port-channel to be tracked
|
f336593:c0:m9
|
def _set_interface(self, v, load=False):
|
if hasattr(v, "<STR_LIT>"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(v,base=YANGListType("<STR_LIT>",interface.interface, yang_name="<STR_LIT>", rest_name="<STR_LIT>", parent=self, is_container='<STR_LIT:list>', user_ordered=False, path_helper=self._path_helper, yang_keys='<STR_LIT>', extensions={u'<STR_LIT>': {u'<STR_LIT>': None, u'<STR_LIT>': None, u'<STR_LIT>': None, u'<STR_LIT:info>': u'<STR_LIT>', u'<STR_LIT>': u'<STR_LIT>'}}), is_container='<STR_LIT:list>', yang_name="<STR_LIT>", rest_name="<STR_LIT>", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions={u'<STR_LIT>': {u'<STR_LIT>': None, u'<STR_LIT>': None, u'<STR_LIT>': None, u'<STR_LIT:info>': u'<STR_LIT>', u'<STR_LIT>': u'<STR_LIT>'}}, namespace='<STR_LIT>', defining_module='<STR_LIT>', yang_type='<STR_LIT:list>', is_config=True)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError({<EOL>'<STR_LIT>': """<STR_LIT>""",<EOL>'<STR_LIT>': "<STR_LIT:list>",<EOL>'<STR_LIT>': """<STR_LIT>""",<EOL>})<EOL><DEDENT>self.__interface = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT>
|
Setter method for interface, mapped from YANG variable /interface/homerun/track/interface (list)
If this variable is read-only (config: false) in the
source YANG file, then _set_interface is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_interface() directly.
YANG Description: Interface or Port-channel to be tracked
|
f336593:c0:m10
|
def _get_remove_(self):
|
return self.__remove_<EOL>
|
Getter method for remove_, mapped from YANG variable /interface/homerun/track/remove (container)
YANG Description: Remove Link State Tracking configuration from this interface
|
f336593:c0:m12
|
def _set_remove_(self, v, load=False):
|
if hasattr(v, "<STR_LIT>"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(v,base=remove_.remove_, is_container='<STR_LIT>', presence=False, yang_name="<STR_LIT>", rest_name="<STR_LIT>", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions={u'<STR_LIT>': {u'<STR_LIT:info>': u'<STR_LIT>', u'<STR_LIT>': None}}, namespace='<STR_LIT>', defining_module='<STR_LIT>', yang_type='<STR_LIT>', is_config=True)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError({<EOL>'<STR_LIT>': """<STR_LIT>""",<EOL>'<STR_LIT>': "<STR_LIT>",<EOL>'<STR_LIT>': """<STR_LIT>""",<EOL>})<EOL><DEDENT>self.__remove_ = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT>
|
Setter method for remove_, mapped from YANG variable /interface/homerun/track/remove (container)
If this variable is read-only (config: false) in the
source YANG file, then _set_remove_ is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_remove_() directly.
YANG Description: Remove Link State Tracking configuration from this interface
|
f336593:c0:m13
|
def _get_min_tx(self):
|
return self.__min_tx<EOL>
|
Getter method for min_tx, mapped from YANG variable /interface/homerun/bfd/interval/min_tx (bfd-tx-interval-type)
YANG Description: Configure BFD desired min transmit interval in milliseconds.
|
f336594:c0:m3
|
def _set_min_tx(self, v, load=False):
|
if hasattr(v, "<STR_LIT>"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(v,base=RestrictedClassType(base_type=RestrictedClassType(base_type=long, restriction_dict={'<STR_LIT>': ['<STR_LIT>']}, int_size=<NUM_LIT:32>), restriction_dict={'<STR_LIT>': [u'<STR_LIT>']}), is_leaf=True, yang_name="<STR_LIT>", rest_name="<STR_LIT>", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions={u'<STR_LIT>': {u'<STR_LIT:info>': u'<STR_LIT>', u'<STR_LIT>': None, u'<STR_LIT>': None}}, namespace='<STR_LIT>', defining_module='<STR_LIT>', yang_type='<STR_LIT>', is_config=True)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError({<EOL>'<STR_LIT>': """<STR_LIT>""",<EOL>'<STR_LIT>': "<STR_LIT>",<EOL>'<STR_LIT>': """<STR_LIT>""",<EOL>})<EOL><DEDENT>self.__min_tx = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT>
|
Setter method for min_tx, mapped from YANG variable /interface/homerun/bfd/interval/min_tx (bfd-tx-interval-type)
If this variable is read-only (config: false) in the
source YANG file, then _set_min_tx is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_min_tx() directly.
YANG Description: Configure BFD desired min transmit interval in milliseconds.
|
f336594:c0:m4
|
def _get_min_rx(self):
|
return self.__min_rx<EOL>
|
Getter method for min_rx, mapped from YANG variable /interface/homerun/bfd/interval/min_rx (bfd-rx-interval-type)
YANG Description: Configure BFD required min receive interval in milliseconds.
|
f336594:c0:m6
|
def _set_min_rx(self, v, load=False):
|
if hasattr(v, "<STR_LIT>"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(v,base=RestrictedClassType(base_type=RestrictedClassType(base_type=long, restriction_dict={'<STR_LIT>': ['<STR_LIT>']}, int_size=<NUM_LIT:32>), restriction_dict={'<STR_LIT>': [u'<STR_LIT>']}), is_leaf=True, yang_name="<STR_LIT>", rest_name="<STR_LIT>", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions={u'<STR_LIT>': {u'<STR_LIT:info>': u'<STR_LIT>', u'<STR_LIT>': None}}, namespace='<STR_LIT>', defining_module='<STR_LIT>', yang_type='<STR_LIT>', is_config=True)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError({<EOL>'<STR_LIT>': """<STR_LIT>""",<EOL>'<STR_LIT>': "<STR_LIT>",<EOL>'<STR_LIT>': """<STR_LIT>""",<EOL>})<EOL><DEDENT>self.__min_rx = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT>
|
Setter method for min_rx, mapped from YANG variable /interface/homerun/bfd/interval/min_rx (bfd-rx-interval-type)
If this variable is read-only (config: false) in the
source YANG file, then _set_min_rx is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_min_rx() directly.
YANG Description: Configure BFD required min receive interval in milliseconds.
|
f336594:c0:m7
|
def _get_multiplier(self):
|
return self.__multiplier<EOL>
|
Getter method for multiplier, mapped from YANG variable /interface/homerun/bfd/interval/multiplier (bfd-multiplier-type)
YANG Description: Configure BFD detection time multiplier.
|
f336594:c0:m9
|
def _set_multiplier(self, v, load=False):
|
if hasattr(v, "<STR_LIT>"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(v,base=RestrictedClassType(base_type=RestrictedClassType(base_type=long, restriction_dict={'<STR_LIT>': ['<STR_LIT>']}, int_size=<NUM_LIT:32>), restriction_dict={'<STR_LIT>': [u'<STR_LIT>']}), is_leaf=True, yang_name="<STR_LIT>", rest_name="<STR_LIT>", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions={u'<STR_LIT>': {u'<STR_LIT>': None, u'<STR_LIT:info>': u'<STR_LIT>'}}, namespace='<STR_LIT>', defining_module='<STR_LIT>', yang_type='<STR_LIT>', is_config=True)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError({<EOL>'<STR_LIT>': """<STR_LIT>""",<EOL>'<STR_LIT>': "<STR_LIT>",<EOL>'<STR_LIT>': """<STR_LIT>""",<EOL>})<EOL><DEDENT>self.__multiplier = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT>
|
Setter method for multiplier, mapped from YANG variable /interface/homerun/bfd/interval/multiplier (bfd-multiplier-type)
If this variable is read-only (config: false) in the
source YANG file, then _set_multiplier is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_multiplier() directly.
YANG Description: Configure BFD detection time multiplier.
|
f336594:c0:m10
|
def _get_interval(self):
|
return self.__interval<EOL>
|
Getter method for interval, mapped from YANG variable /interface/homerun/bfd/interval (container)
YANG Description: Configure BFD desired min transmit interval in milliseconds.
|
f336595:c0:m3
|
def _set_interval(self, v, load=False):
|
if hasattr(v, "<STR_LIT>"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(v,base=interval.interval, is_container='<STR_LIT>', presence=False, yang_name="<STR_LIT>", rest_name="<STR_LIT>", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions={u'<STR_LIT>': {u'<STR_LIT:info>': u'<STR_LIT>', u'<STR_LIT>': None, u'<STR_LIT>': None, u'<STR_LIT>': None}}, namespace='<STR_LIT>', defining_module='<STR_LIT>', yang_type='<STR_LIT>', is_config=True)<EOL><DEDENT>except (TypeError, ValueError):<EOL><INDENT>raise ValueError({<EOL>'<STR_LIT>': """<STR_LIT>""",<EOL>'<STR_LIT>': "<STR_LIT>",<EOL>'<STR_LIT>': """<STR_LIT>""",<EOL>})<EOL><DEDENT>self.__interval = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT>
|
Setter method for interval, mapped from YANG variable /interface/homerun/bfd/interval (container)
If this variable is read-only (config: false) in the
source YANG file, then _set_interval is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_interval() directly.
YANG Description: Configure BFD desired min transmit interval in milliseconds.
|
f336595:c0:m4
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.