signature
stringlengths 8
3.44k
| body
stringlengths 0
1.41M
| docstring
stringlengths 1
122k
| id
stringlengths 5
17
|
|---|---|---|---|
def _get_last_aggregator_id(self):
|
return self.__last_aggregator_id<EOL>
|
Getter method for last_aggregator_id, mapped from YANG variable /brocade_lag_rpc/get_port_channel_detail/input/last_aggregator_id (interface:portchannel-type)
YANG Description: Aggregator-id value should be given only when previous
response indicates that more records exists. This value
will be the Id of last aggregator received in previous
response.
|
f336775:c0:m6
|
def _set_last_aggregator_id(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, choice=(u'<STR_LIT>', u'<STR_LIT>'), path_helper=self._path_helper, extmethods=self._extmethods, register_paths=False, 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.__last_aggregator_id = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT>
|
Setter method for last_aggregator_id, mapped from YANG variable /brocade_lag_rpc/get_port_channel_detail/input/last_aggregator_id (interface:portchannel-type)
If this variable is read-only (config: false) in the
source YANG file, then _set_last_aggregator_id is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_last_aggregator_id() directly.
YANG Description: Aggregator-id value should be given only when previous
response indicates that more records exists. This value
will be the Id of last aggregator received in previous
response.
|
f336775:c0:m7
|
def _get_aggregator_id(self):
|
return self.__aggregator_id<EOL>
|
Getter method for aggregator_id, mapped from YANG variable /brocade_lag_rpc/get_port_channel_detail/output/lacp/aggregator_id (interface:portchannel-type)
YANG Description: Agreegator id
|
f336776:c0:m3
|
def _set_aggregator_id(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=False, 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.__aggregator_id = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT>
|
Setter method for aggregator_id, mapped from YANG variable /brocade_lag_rpc/get_port_channel_detail/output/lacp/aggregator_id (interface:portchannel-type)
If this variable is read-only (config: false) in the
source YANG file, then _set_aggregator_id is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_aggregator_id() directly.
YANG Description: Agreegator id
|
f336776:c0:m4
|
def _get_aggregator_type(self):
|
return self.__aggregator_type<EOL>
|
Getter method for aggregator_type, mapped from YANG variable /brocade_lag_rpc/get_port_channel_detail/output/lacp/aggregator_type (enumeration)
|
f336776:c0:m6
|
def _set_aggregator_type(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:4>}, u'<STR_LIT>': {'<STR_LIT:value>': <NUM_LIT:3>}, u'<STR_LIT>': {'<STR_LIT:value>': <NUM_LIT:2>}, 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=False, 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.__aggregator_type = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT>
|
Setter method for aggregator_type, mapped from YANG variable /brocade_lag_rpc/get_port_channel_detail/output/lacp/aggregator_type (enumeration)
If this variable is read-only (config: false) in the
source YANG file, then _set_aggregator_type is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_aggregator_type() directly.
|
f336776:c0:m7
|
def _get_isvlag(self):
|
return self.__isvlag<EOL>
|
Getter method for isvlag, mapped from YANG variable /brocade_lag_rpc/get_port_channel_detail/output/lacp/isvlag (boolean)
YANG Description: Specifies if Agreegator is vlag.
|
f336776:c0:m9
|
def _set_isvlag(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=False, 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.__isvlag = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT>
|
Setter method for isvlag, mapped from YANG variable /brocade_lag_rpc/get_port_channel_detail/output/lacp/isvlag (boolean)
If this variable is read-only (config: false) in the
source YANG file, then _set_isvlag is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_isvlag() directly.
YANG Description: Specifies if Agreegator is vlag.
|
f336776:c0:m10
|
def _get_aggregator_mode(self):
|
return self.__aggregator_mode<EOL>
|
Getter method for aggregator_mode, mapped from YANG variable /brocade_lag_rpc/get_port_channel_detail/output/lacp/aggregator_mode (enumeration)
|
f336776:c0:m12
|
def _set_aggregator_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:2>}, u'<STR_LIT:none>': {'<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=False, 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.__aggregator_mode = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT>
|
Setter method for aggregator_mode, mapped from YANG variable /brocade_lag_rpc/get_port_channel_detail/output/lacp/aggregator_mode (enumeration)
If this variable is read-only (config: false) in the
source YANG file, then _set_aggregator_mode is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_aggregator_mode() directly.
|
f336776:c0:m13
|
def _get_admin_key(self):
|
return self.__admin_key<EOL>
|
Getter method for admin_key, mapped from YANG variable /brocade_lag_rpc/get_port_channel_detail/output/lacp/admin_key (lacp-key)
YANG Description: The Admin key
|
f336776:c0:m15
|
def _set_admin_key(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=False, 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.__admin_key = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT>
|
Setter method for admin_key, mapped from YANG variable /brocade_lag_rpc/get_port_channel_detail/output/lacp/admin_key (lacp-key)
If this variable is read-only (config: false) in the
source YANG file, then _set_admin_key is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_admin_key() directly.
YANG Description: The Admin key
|
f336776:c0:m16
|
def _get_oper_key(self):
|
return self.__oper_key<EOL>
|
Getter method for oper_key, mapped from YANG variable /brocade_lag_rpc/get_port_channel_detail/output/lacp/oper_key (lacp-key)
YANG Description: The Opertional key
|
f336776:c0:m18
|
def _set_oper_key(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=False, 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.__oper_key = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT>
|
Setter method for oper_key, mapped from YANG variable /brocade_lag_rpc/get_port_channel_detail/output/lacp/oper_key (lacp-key)
If this variable is read-only (config: false) in the
source YANG file, then _set_oper_key is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_oper_key() directly.
YANG Description: The Opertional key
|
f336776:c0:m19
|
def _get_actor_system_id(self):
|
return self.__actor_system_id<EOL>
|
Getter method for actor_system_id, mapped from YANG variable /brocade_lag_rpc/get_port_channel_detail/output/lacp/actor_system_id (yang:mac-address)
YANG Description: The Actor system id
|
f336776:c0:m21
|
def _set_actor_system_id(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_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=False, 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.__actor_system_id = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT>
|
Setter method for actor_system_id, mapped from YANG variable /brocade_lag_rpc/get_port_channel_detail/output/lacp/actor_system_id (yang:mac-address)
If this variable is read-only (config: false) in the
source YANG file, then _set_actor_system_id is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_actor_system_id() directly.
YANG Description: The Actor system id
|
f336776:c0:m22
|
def _get_partner_system_id(self):
|
return self.__partner_system_id<EOL>
|
Getter method for partner_system_id, mapped from YANG variable /brocade_lag_rpc/get_port_channel_detail/output/lacp/partner_system_id (yang:mac-address)
YANG Description: The Partner system id
|
f336776:c0:m24
|
def _set_partner_system_id(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_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=False, 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.__partner_system_id = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT>
|
Setter method for partner_system_id, mapped from YANG variable /brocade_lag_rpc/get_port_channel_detail/output/lacp/partner_system_id (yang:mac-address)
If this variable is read-only (config: false) in the
source YANG file, then _set_partner_system_id is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_partner_system_id() directly.
YANG Description: The Partner system id
|
f336776:c0:m25
|
def _get_system_priority(self):
|
return self.__system_priority<EOL>
|
Getter method for system_priority, mapped from YANG variable /brocade_lag_rpc/get_port_channel_detail/output/lacp/system_priority (uint32)
YANG Description: The System Priority
|
f336776:c0:m27
|
def _set_system_priority(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=False, 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.__system_priority = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT>
|
Setter method for system_priority, mapped from YANG variable /brocade_lag_rpc/get_port_channel_detail/output/lacp/system_priority (uint32)
If this variable is read-only (config: false) in the
source YANG file, then _set_system_priority is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_system_priority() directly.
YANG Description: The System Priority
|
f336776:c0:m28
|
def _get_partner_oper_priority(self):
|
return self.__partner_oper_priority<EOL>
|
Getter method for partner_oper_priority, mapped from YANG variable /brocade_lag_rpc/get_port_channel_detail/output/lacp/partner_oper_priority (uint32)
YANG Description: The partner operational priority
|
f336776:c0:m30
|
def _set_partner_oper_priority(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=False, 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.__partner_oper_priority = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT>
|
Setter method for partner_oper_priority, mapped from YANG variable /brocade_lag_rpc/get_port_channel_detail/output/lacp/partner_oper_priority (uint32)
If this variable is read-only (config: false) in the
source YANG file, then _set_partner_oper_priority is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_partner_oper_priority() directly.
YANG Description: The partner operational priority
|
f336776:c0:m31
|
def _get_rx_link_count(self):
|
return self.__rx_link_count<EOL>
|
Getter method for rx_link_count, mapped from YANG variable /brocade_lag_rpc/get_port_channel_detail/output/lacp/rx_link_count (uint64)
YANG Description: The RX link counter
|
f336776:c0:m33
|
def _set_rx_link_count(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=long, restriction_dict={'<STR_LIT>': ['<STR_LIT>']}, int_size=<NUM_LIT:64>), is_leaf=True, yang_name="<STR_LIT>", rest_name="<STR_LIT>", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=False, 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.__rx_link_count = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT>
|
Setter method for rx_link_count, mapped from YANG variable /brocade_lag_rpc/get_port_channel_detail/output/lacp/rx_link_count (uint64)
If this variable is read-only (config: false) in the
source YANG file, then _set_rx_link_count is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_rx_link_count() directly.
YANG Description: The RX link counter
|
f336776:c0:m34
|
def _get_tx_link_count(self):
|
return self.__tx_link_count<EOL>
|
Getter method for tx_link_count, mapped from YANG variable /brocade_lag_rpc/get_port_channel_detail/output/lacp/tx_link_count (uint64)
YANG Description: The RX link counter
|
f336776:c0:m36
|
def _set_tx_link_count(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=long, restriction_dict={'<STR_LIT>': ['<STR_LIT>']}, int_size=<NUM_LIT:64>), is_leaf=True, yang_name="<STR_LIT>", rest_name="<STR_LIT>", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=False, 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.__tx_link_count = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT>
|
Setter method for tx_link_count, mapped from YANG variable /brocade_lag_rpc/get_port_channel_detail/output/lacp/tx_link_count (uint64)
If this variable is read-only (config: false) in the
source YANG file, then _set_tx_link_count is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_tx_link_count() directly.
YANG Description: The RX link counter
|
f336776:c0:m37
|
def _get_individual_agg(self):
|
return self.__individual_agg<EOL>
|
Getter method for individual_agg, mapped from YANG variable /brocade_lag_rpc/get_port_channel_detail/output/lacp/individual_agg (uint32)
YANG Description: Individual aggregator
|
f336776:c0:m39
|
def _set_individual_agg(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=long, restriction_dict={'<STR_LIT>': ['<STR_LIT>']}, int_size=<NUM_LIT:32>), is_leaf=True, yang_name="<STR_LIT>", rest_name="<STR_LIT>", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=False, 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.__individual_agg = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT>
|
Setter method for individual_agg, mapped from YANG variable /brocade_lag_rpc/get_port_channel_detail/output/lacp/individual_agg (uint32)
If this variable is read-only (config: false) in the
source YANG file, then _set_individual_agg is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_individual_agg() directly.
YANG Description: Individual aggregator
|
f336776:c0:m40
|
def _get_ready_agg(self):
|
return self.__ready_agg<EOL>
|
Getter method for ready_agg, mapped from YANG variable /brocade_lag_rpc/get_port_channel_detail/output/lacp/ready_agg (uint32)
YANG Description: Individual aggregator
|
f336776:c0:m42
|
def _set_ready_agg(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=long, restriction_dict={'<STR_LIT>': ['<STR_LIT>']}, int_size=<NUM_LIT:32>), is_leaf=True, yang_name="<STR_LIT>", rest_name="<STR_LIT>", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=False, 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.__ready_agg = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT>
|
Setter method for ready_agg, mapped from YANG variable /brocade_lag_rpc/get_port_channel_detail/output/lacp/ready_agg (uint32)
If this variable is read-only (config: false) in the
source YANG file, then _set_ready_agg is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_ready_agg() directly.
YANG Description: Individual aggregator
|
f336776:c0:m43
|
def _get_partner_oper_key(self):
|
return self.__partner_oper_key<EOL>
|
Getter method for partner_oper_key, mapped from YANG variable /brocade_lag_rpc/get_port_channel_detail/output/lacp/partner_oper_key (lacp-key)
YANG Description: The Partner Opertional key
|
f336776:c0:m45
|
def _set_partner_oper_key(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=False, 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.__partner_oper_key = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT>
|
Setter method for partner_oper_key, mapped from YANG variable /brocade_lag_rpc/get_port_channel_detail/output/lacp/partner_oper_key (lacp-key)
If this variable is read-only (config: false) in the
source YANG file, then _set_partner_oper_key is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_partner_oper_key() directly.
YANG Description: The Partner Opertional key
|
f336776:c0:m46
|
def _get_aggr_member(self):
|
return self.__aggr_member<EOL>
|
Getter method for aggr_member, mapped from YANG variable /brocade_lag_rpc/get_port_channel_detail/output/lacp/aggr_member (list)
YANG Description: Describes the aggregator member
details.
|
f336776:c0:m48
|
def _set_aggr_member(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(False,aggr_member.aggr_member, 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:False>', extensions=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=False, extensions=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.__aggr_member = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT>
|
Setter method for aggr_member, mapped from YANG variable /brocade_lag_rpc/get_port_channel_detail/output/lacp/aggr_member (list)
If this variable is read-only (config: false) in the
source YANG file, then _set_aggr_member is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_aggr_member() directly.
YANG Description: Describes the aggregator member
details.
|
f336776:c0:m49
|
def _get_interface_type(self):
|
return self.__interface_type<EOL>
|
Getter method for interface_type, mapped from YANG variable /brocade_lag_rpc/get_port_channel_detail/output/lacp/aggr_member/interface_type (enumeration)
YANG Description: The type of the interface. An 'unknown' type
represents error scenario and should not be used.
|
f336777:c0:m3
|
def _set_interface_type(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:8>}, u'<STR_LIT>': {'<STR_LIT:value>': <NUM_LIT:7>}, u'<STR_LIT>': {'<STR_LIT:value>': <NUM_LIT:12>}, u'<STR_LIT>': {'<STR_LIT:value>': <NUM_LIT:1>}, u'<STR_LIT>': {'<STR_LIT:value>': <NUM_LIT:5>}, u'<STR_LIT>': {'<STR_LIT:value>': <NUM_LIT:11>}, u'<STR_LIT>': {'<STR_LIT:value>': <NUM_LIT:10>}, u'<STR_LIT>': {'<STR_LIT:value>': <NUM_LIT:6>}},), is_leaf=True, yang_name="<STR_LIT>", rest_name="<STR_LIT>", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=False, extensions={u'<STR_LIT>': {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.__interface_type = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT>
|
Setter method for interface_type, mapped from YANG variable /brocade_lag_rpc/get_port_channel_detail/output/lacp/aggr_member/interface_type (enumeration)
If this variable is read-only (config: false) in the
source YANG file, then _set_interface_type is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_interface_type() directly.
YANG Description: The type of the interface. An 'unknown' type
represents error scenario and should not be used.
|
f336777:c0:m4
|
def _get_interface_name(self):
|
return self.__interface_name<EOL>
|
Getter method for interface_name, mapped from YANG variable /brocade_lag_rpc/get_port_channel_detail/output/lacp/aggr_member/interface_name (union)
YANG Description: The Interface value. The interface value is always
interpreted within the context of the value of
'interface-type' leaf:
interface-type interface-name
----------------- --------------------
ethernet slot/port
port-channel Port channel ID
l2vlan Vlan ID
loopback Loopback ID
ve VE Interface ID
unknown Zero-length string.
The value of an 'interface-name' must always be
consistent with the value of the associated
'interface-type'. Attempts to set an interface-name
to a value inconsistent with the associated
'interface-type' must fail with an error.
|
f336777:c0:m6
|
def _set_interface_name(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_dict={'<STR_LIT>': u'<STR_LIT>', '<STR_LIT>': [u'<STR_LIT>']}),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>']}),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=False, extensions={u'<STR_LIT>': {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.__interface_name = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT>
|
Setter method for interface_name, mapped from YANG variable /brocade_lag_rpc/get_port_channel_detail/output/lacp/aggr_member/interface_name (union)
If this variable is read-only (config: false) in the
source YANG file, then _set_interface_name is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_interface_name() directly.
YANG Description: The Interface value. The interface value is always
interpreted within the context of the value of
'interface-type' leaf:
interface-type interface-name
----------------- --------------------
ethernet slot/port
port-channel Port channel ID
l2vlan Vlan ID
loopback Loopback ID
ve VE Interface ID
unknown Zero-length string.
The value of an 'interface-name' must always be
consistent with the value of the associated
'interface-type'. Attempts to set an interface-name
to a value inconsistent with the associated
'interface-type' must fail with an error.
|
f336777:c0:m7
|
def _get_actor_port(self):
|
return self.__actor_port<EOL>
|
Getter method for actor_port, mapped from YANG variable /brocade_lag_rpc/get_port_channel_detail/output/lacp/aggr_member/actor_port (uint64)
YANG Description: The actor port number.
This is valid only in active mode only.
|
f336777:c0:m9
|
def _set_actor_port(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=long, restriction_dict={'<STR_LIT>': ['<STR_LIT>']}, int_size=<NUM_LIT:64>), is_leaf=True, yang_name="<STR_LIT>", rest_name="<STR_LIT>", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=False, 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.__actor_port = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT>
|
Setter method for actor_port, mapped from YANG variable /brocade_lag_rpc/get_port_channel_detail/output/lacp/aggr_member/actor_port (uint64)
If this variable is read-only (config: false) in the
source YANG file, then _set_actor_port is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_actor_port() directly.
YANG Description: The actor port number.
This is valid only in active mode only.
|
f336777:c0:m10
|
def _get_sync(self):
|
return self.__sync<EOL>
|
Getter method for sync, mapped from YANG variable /brocade_lag_rpc/get_port_channel_detail/output/lacp/aggr_member/sync (uint64)
YANG Description: sync-info.
This is valid in active mode only.
|
f336777:c0:m12
|
def _set_sync(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=long, restriction_dict={'<STR_LIT>': ['<STR_LIT>']}, int_size=<NUM_LIT:64>), is_leaf=True, yang_name="<STR_LIT>", rest_name="<STR_LIT>", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=False, 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.__sync = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT>
|
Setter method for sync, mapped from YANG variable /brocade_lag_rpc/get_port_channel_detail/output/lacp/aggr_member/sync (uint64)
If this variable is read-only (config: false) in the
source YANG file, then _set_sync is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_sync() directly.
YANG Description: sync-info.
This is valid in active mode only.
|
f336777:c0:m13
|
def _get_policy_name(self):
|
return self.__policy_name<EOL>
|
Getter method for policy_name, mapped from YANG variable /overlay_policy_map_get_next_cookie_state/policy_name (string)
YANG Description: Overlay Policy Map name
|
f336778:c0:m3
|
def _set_policy_name(self, v, load=False):
|
if hasattr(v, "<STR_LIT>"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(v,base=unicode, is_leaf=True, yang_name="<STR_LIT>", rest_name="<STR_LIT>", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='<STR_LIT>', defining_module='<STR_LIT>', yang_type='<STR_LIT:string>', is_config=False)<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.__policy_name = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT>
|
Setter method for policy_name, mapped from YANG variable /overlay_policy_map_get_next_cookie_state/policy_name (string)
If this variable is read-only (config: false) in the
source YANG file, then _set_policy_name is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_policy_name() directly.
YANG Description: Overlay Policy Map name
|
f336778:c0:m4
|
def _get_seq_id(self):
|
return self.__seq_id<EOL>
|
Getter method for seq_id, mapped from YANG variable /overlay_policy_map_get_next_cookie_state/seq_id (uint32)
YANG Description: Sequence Id
|
f336778:c0:m6
|
def _set_seq_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=long, restriction_dict={'<STR_LIT>': ['<STR_LIT>']}, int_size=<NUM_LIT:32>), is_leaf=True, yang_name="<STR_LIT>", rest_name="<STR_LIT>", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, is_keyval=True, namespace='<STR_LIT>', defining_module='<STR_LIT>', yang_type='<STR_LIT>', is_config=False)<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.__seq_id = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT>
|
Setter method for seq_id, mapped from YANG variable /overlay_policy_map_get_next_cookie_state/seq_id (uint32)
If this variable is read-only (config: false) in the
source YANG file, then _set_seq_id is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_seq_id() directly.
YANG Description: Sequence Id
|
f336778:c0:m7
|
def _get_policy_name(self):
|
return self.__policy_name<EOL>
|
Getter method for policy_name, mapped from YANG variable /overlay_policy_map_state/policy_name (string)
YANG Description: Overlay Policy Map name
|
f336779:c0:m3
|
def _set_policy_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=unicode, is_leaf=True, yang_name="<STR_LIT>", rest_name="<STR_LIT>", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, is_keyval=True, namespace='<STR_LIT>', defining_module='<STR_LIT>', yang_type='<STR_LIT:string>', is_config=False)<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.__policy_name = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT>
|
Setter method for policy_name, mapped from YANG variable /overlay_policy_map_state/policy_name (string)
If this variable is read-only (config: false) in the
source YANG file, then _set_policy_name is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_policy_name() directly.
YANG Description: Overlay Policy Map name
|
f336779:c0:m4
|
def _get_active_on(self):
|
return self.__active_on<EOL>
|
Getter method for active_on, mapped from YANG variable /overlay_policy_map_state/active_on (container)
YANG Description: Active Interfaces
|
f336779:c0:m6
|
def _set_active_on(self, v, load=False):
|
if hasattr(v, "<STR_LIT>"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(v,base=active_on.active_on, 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>': None}}, namespace='<STR_LIT>', defining_module='<STR_LIT>', yang_type='<STR_LIT>', is_config=False)<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.__active_on = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT>
|
Setter method for active_on, mapped from YANG variable /overlay_policy_map_state/active_on (container)
If this variable is read-only (config: false) in the
source YANG file, then _set_active_on is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_active_on() directly.
YANG Description: Active Interfaces
|
f336779:c0:m7
|
def _get_overlay_class(self):
|
return self.__overlay_class<EOL>
|
Getter method for overlay_class, mapped from YANG variable /overlay_policy_map_state/overlay_class (list)
YANG Description: Overlay Class
|
f336779:c0:m9
|
def _set_overlay_class(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>",overlay_class.overlay_class, 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}}), 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}}, namespace='<STR_LIT>', defining_module='<STR_LIT>', yang_type='<STR_LIT:list>', is_config=False)<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.__overlay_class = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT>
|
Setter method for overlay_class, mapped from YANG variable /overlay_policy_map_state/overlay_class (list)
If this variable is read-only (config: false) in the
source YANG file, then _set_overlay_class is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_overlay_class() directly.
YANG Description: Overlay Class
|
f336779:c0:m10
|
def _get_interface_type(self):
|
return self.__interface_type<EOL>
|
Getter method for interface_type, mapped from YANG variable /overlay_policy_map_state/active_on/interface_type (string)
YANG Description: Interface Type
|
f336780:c0:m3
|
def _set_interface_type(self, v, load=False):
|
if hasattr(v, "<STR_LIT>"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(v,base=unicode, is_leaf=True, yang_name="<STR_LIT>", rest_name="<STR_LIT>", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='<STR_LIT>', defining_module='<STR_LIT>', yang_type='<STR_LIT:string>', is_config=False)<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.__interface_type = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT>
|
Setter method for interface_type, mapped from YANG variable /overlay_policy_map_state/active_on/interface_type (string)
If this variable is read-only (config: false) in the
source YANG file, then _set_interface_type is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_interface_type() directly.
YANG Description: Interface Type
|
f336780:c0:m4
|
def _get_interface_name(self):
|
return self.__interface_name<EOL>
|
Getter method for interface_name, mapped from YANG variable /overlay_policy_map_state/active_on/interface_name (string)
YANG Description: Interface Name
|
f336780:c0:m6
|
def _set_interface_name(self, v, load=False):
|
if hasattr(v, "<STR_LIT>"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(v,base=unicode, is_leaf=True, yang_name="<STR_LIT>", rest_name="<STR_LIT>", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='<STR_LIT>', defining_module='<STR_LIT>', yang_type='<STR_LIT:string>', is_config=False)<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.__interface_name = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT>
|
Setter method for interface_name, mapped from YANG variable /overlay_policy_map_state/active_on/interface_name (string)
If this variable is read-only (config: false) in the
source YANG file, then _set_interface_name is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_interface_name() directly.
YANG Description: Interface Name
|
f336780:c0:m7
|
def _get_seq_id(self):
|
return self.__seq_id<EOL>
|
Getter method for seq_id, mapped from YANG variable /overlay_policy_map_state/overlay_class/seq_id (uint32)
YANG Description: Sequence Id
|
f336781:c0:m3
|
def _set_seq_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=long, restriction_dict={'<STR_LIT>': ['<STR_LIT>']}, int_size=<NUM_LIT:32>), is_leaf=True, yang_name="<STR_LIT>", rest_name="<STR_LIT>", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, is_keyval=True, namespace='<STR_LIT>', defining_module='<STR_LIT>', yang_type='<STR_LIT>', is_config=False)<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.__seq_id = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT>
|
Setter method for seq_id, mapped from YANG variable /overlay_policy_map_state/overlay_class/seq_id (uint32)
If this variable is read-only (config: false) in the
source YANG file, then _set_seq_id is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_seq_id() directly.
YANG Description: Sequence Id
|
f336781:c0:m4
|
def _get_overlay_class_name(self):
|
return self.__overlay_class_name<EOL>
|
Getter method for overlay_class_name, mapped from YANG variable /overlay_policy_map_state/overlay_class/overlay_class_name (string)
YANG Description: Overlay Class name
|
f336781:c0:m6
|
def _set_overlay_class_name(self, v, load=False):
|
if hasattr(v, "<STR_LIT>"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(v,base=unicode, is_leaf=True, yang_name="<STR_LIT>", rest_name="<STR_LIT>", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='<STR_LIT>', defining_module='<STR_LIT>', yang_type='<STR_LIT:string>', is_config=False)<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.__overlay_class_name = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT>
|
Setter method for overlay_class_name, mapped from YANG variable /overlay_policy_map_state/overlay_class/overlay_class_name (string)
If this variable is read-only (config: false) in the
source YANG file, then _set_overlay_class_name is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_overlay_class_name() directly.
YANG Description: Overlay Class name
|
f336781:c0:m7
|
def _get_mac_acl_name(self):
|
return self.__mac_acl_name<EOL>
|
Getter method for mac_acl_name, mapped from YANG variable /overlay_policy_map_state/overlay_class/mac_acl_name (string)
YANG Description: Mac Access List name
|
f336781:c0:m9
|
def _set_mac_acl_name(self, v, load=False):
|
if hasattr(v, "<STR_LIT>"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(v,base=unicode, is_leaf=True, yang_name="<STR_LIT>", rest_name="<STR_LIT>", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='<STR_LIT>', defining_module='<STR_LIT>', yang_type='<STR_LIT:string>', is_config=False)<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.__mac_acl_name = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT>
|
Setter method for mac_acl_name, mapped from YANG variable /overlay_policy_map_state/overlay_class/mac_acl_name (string)
If this variable is read-only (config: false) in the
source YANG file, then _set_mac_acl_name is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_mac_acl_name() directly.
YANG Description: Mac Access List name
|
f336781:c0:m10
|
def _get_ip_acl_name(self):
|
return self.__ip_acl_name<EOL>
|
Getter method for ip_acl_name, mapped from YANG variable /overlay_policy_map_state/overlay_class/ip_acl_name (string)
YANG Description: IP Access List name
|
f336781:c0:m12
|
def _set_ip_acl_name(self, v, load=False):
|
if hasattr(v, "<STR_LIT>"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(v,base=unicode, is_leaf=True, yang_name="<STR_LIT>", rest_name="<STR_LIT>", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='<STR_LIT>', defining_module='<STR_LIT>', yang_type='<STR_LIT:string>', is_config=False)<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.__ip_acl_name = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT>
|
Setter method for ip_acl_name, mapped from YANG variable /overlay_policy_map_state/overlay_class/ip_acl_name (string)
If this variable is read-only (config: false) in the
source YANG file, then _set_ip_acl_name is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_ip_acl_name() directly.
YANG Description: IP Access List name
|
f336781:c0:m13
|
def _get_ipv6_acl_name(self):
|
return self.__ipv6_acl_name<EOL>
|
Getter method for ipv6_acl_name, mapped from YANG variable /overlay_policy_map_state/overlay_class/ipv6_acl_name (string)
YANG Description: IPv6 Access List name
|
f336781:c0:m15
|
def _set_ipv6_acl_name(self, v, load=False):
|
if hasattr(v, "<STR_LIT>"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(v,base=unicode, is_leaf=True, yang_name="<STR_LIT>", rest_name="<STR_LIT>", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='<STR_LIT>', defining_module='<STR_LIT>', yang_type='<STR_LIT:string>', is_config=False)<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.__ipv6_acl_name = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT>
|
Setter method for ipv6_acl_name, mapped from YANG variable /overlay_policy_map_state/overlay_class/ipv6_acl_name (string)
If this variable is read-only (config: false) in the
source YANG file, then _set_ipv6_acl_name is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_ipv6_acl_name() directly.
YANG Description: IPv6 Access List name
|
f336781:c0:m16
|
def _get_service_policy_name(self):
|
return self.__service_policy_name<EOL>
|
Getter method for service_policy_name, mapped from YANG variable /overlay_policy_map_state/overlay_class/service_policy_name (string)
YANG Description: Service Policy name
|
f336781:c0:m18
|
def _set_service_policy_name(self, v, load=False):
|
if hasattr(v, "<STR_LIT>"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(v,base=unicode, is_leaf=True, yang_name="<STR_LIT>", rest_name="<STR_LIT>", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='<STR_LIT>', defining_module='<STR_LIT>', yang_type='<STR_LIT:string>', is_config=False)<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.__service_policy_name = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT>
|
Setter method for service_policy_name, mapped from YANG variable /overlay_policy_map_state/overlay_class/service_policy_name (string)
If this variable is read-only (config: false) in the
source YANG file, then _set_service_policy_name is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_service_policy_name() directly.
YANG Description: Service Policy name
|
f336781:c0:m19
|
def _get_qos_mpls(self):
|
return self.__qos_mpls<EOL>
|
Getter method for qos_mpls, mapped from YANG variable /exp_dscp_state/qos_mpls (list)
|
f336782:c0:m3
|
def _set_qos_mpls(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>",qos_mpls.qos_mpls, 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>'}}), 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>'}}, namespace='<STR_LIT>', defining_module='<STR_LIT>', yang_type='<STR_LIT:list>', is_config=False)<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.__qos_mpls = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT>
|
Setter method for qos_mpls, mapped from YANG variable /exp_dscp_state/qos_mpls (list)
If this variable is read-only (config: false) in the
source YANG file, then _set_qos_mpls is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_qos_mpls() directly.
|
f336782:c0:m4
|
def _get_map_type(self):
|
return self.__map_type<EOL>
|
Getter method for map_type, mapped from YANG variable /exp_dscp_state/qos_mpls/map_type (string)
YANG Description: map_type
|
f336783:c0:m3
|
def _set_map_type(self, v, load=False):
|
if hasattr(v, "<STR_LIT>"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(v,base=unicode, is_leaf=True, yang_name="<STR_LIT>", rest_name="<STR_LIT>", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='<STR_LIT>', defining_module='<STR_LIT>', yang_type='<STR_LIT:string>', is_config=False)<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.__map_type = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT>
|
Setter method for map_type, mapped from YANG variable /exp_dscp_state/qos_mpls/map_type (string)
If this variable is read-only (config: false) in the
source YANG file, then _set_map_type is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_map_type() directly.
YANG Description: map_type
|
f336783:c0:m4
|
def _get_map_name(self):
|
return self.__map_name<EOL>
|
Getter method for map_name, mapped from YANG variable /exp_dscp_state/qos_mpls/map_name (string)
YANG Description: map_name
|
f336783:c0:m6
|
def _set_map_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=unicode, is_leaf=True, yang_name="<STR_LIT>", rest_name="<STR_LIT>", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, is_keyval=True, namespace='<STR_LIT>', defining_module='<STR_LIT>', yang_type='<STR_LIT:string>', is_config=False)<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.__map_name = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT>
|
Setter method for map_name, mapped from YANG variable /exp_dscp_state/qos_mpls/map_name (string)
If this variable is read-only (config: false) in the
source YANG file, then _set_map_name is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_map_name() directly.
YANG Description: map_name
|
f336783:c0:m7
|
def _get_enabled_slots(self):
|
return self.__enabled_slots<EOL>
|
Getter method for enabled_slots, mapped from YANG variable /exp_dscp_state/qos_mpls/enabled_slots (string)
YANG Description: enabled_slots
|
f336783:c0:m9
|
def _set_enabled_slots(self, v, load=False):
|
if hasattr(v, "<STR_LIT>"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(v,base=unicode, is_leaf=True, yang_name="<STR_LIT>", rest_name="<STR_LIT>", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='<STR_LIT>', defining_module='<STR_LIT>', yang_type='<STR_LIT:string>', is_config=False)<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.__enabled_slots = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT>
|
Setter method for enabled_slots, mapped from YANG variable /exp_dscp_state/qos_mpls/enabled_slots (string)
If this variable is read-only (config: false) in the
source YANG file, then _set_enabled_slots is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_enabled_slots() directly.
YANG Description: enabled_slots
|
f336783:c0:m10
|
def _get_traffic_class(self):
|
return self.__traffic_class<EOL>
|
Getter method for traffic_class, mapped from YANG variable /exp_dscp_state/qos_mpls/traffic_class (uint32)
YANG Description: traffic-class
|
f336783:c0:m12
|
def _set_traffic_class(self, v, load=False):
|
if hasattr(v, "<STR_LIT>"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(v,base=TypedListType(allowed_type=RestrictedClassType(base_type=long, restriction_dict={'<STR_LIT>': ['<STR_LIT>']}, int_size=<NUM_LIT:32>)), is_leaf=False, yang_name="<STR_LIT>", rest_name="<STR_LIT>", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='<STR_LIT>', defining_module='<STR_LIT>', yang_type='<STR_LIT>', is_config=False)<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.__traffic_class = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT>
|
Setter method for traffic_class, mapped from YANG variable /exp_dscp_state/qos_mpls/traffic_class (uint32)
If this variable is read-only (config: false) in the
source YANG file, then _set_traffic_class is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_traffic_class() directly.
YANG Description: traffic-class
|
f336783:c0:m13
|
def _get_drop_preced(self):
|
return self.__drop_preced<EOL>
|
Getter method for drop_preced, mapped from YANG variable /exp_dscp_state/qos_mpls/drop_preced (uint32)
YANG Description: drop-preced
|
f336783:c0:m15
|
def _set_drop_preced(self, v, load=False):
|
if hasattr(v, "<STR_LIT>"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(v,base=TypedListType(allowed_type=RestrictedClassType(base_type=long, restriction_dict={'<STR_LIT>': ['<STR_LIT>']}, int_size=<NUM_LIT:32>)), is_leaf=False, yang_name="<STR_LIT>", rest_name="<STR_LIT>", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='<STR_LIT>', defining_module='<STR_LIT>', yang_type='<STR_LIT>', is_config=False)<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.__drop_preced = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT>
|
Setter method for drop_preced, mapped from YANG variable /exp_dscp_state/qos_mpls/drop_preced (uint32)
If this variable is read-only (config: false) in the
source YANG file, then _set_drop_preced is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_drop_preced() directly.
YANG Description: drop-preced
|
f336783:c0:m16
|
def _get_exp(self):
|
return self.__exp<EOL>
|
Getter method for exp, mapped from YANG variable /exp_dscp_state/qos_mpls/exp (uint32)
YANG Description: exp-val
|
f336783:c0:m18
|
def _set_exp(self, v, load=False):
|
if hasattr(v, "<STR_LIT>"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(v,base=TypedListType(allowed_type=RestrictedClassType(base_type=long, restriction_dict={'<STR_LIT>': ['<STR_LIT>']}, int_size=<NUM_LIT:32>)), is_leaf=False, yang_name="<STR_LIT>", rest_name="<STR_LIT>", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='<STR_LIT>', defining_module='<STR_LIT>', yang_type='<STR_LIT>', is_config=False)<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.__exp = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT>
|
Setter method for exp, mapped from YANG variable /exp_dscp_state/qos_mpls/exp (uint32)
If this variable is read-only (config: false) in the
source YANG file, then _set_exp is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_exp() directly.
YANG Description: exp-val
|
f336783:c0:m19
|
def _get_dscp(self):
|
return self.__dscp<EOL>
|
Getter method for dscp, mapped from YANG variable /exp_dscp_state/qos_mpls/dscp (uint32)
YANG Description: dscp-val
|
f336783:c0:m21
|
def _set_dscp(self, v, load=False):
|
if hasattr(v, "<STR_LIT>"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(v,base=TypedListType(allowed_type=RestrictedClassType(base_type=long, restriction_dict={'<STR_LIT>': ['<STR_LIT>']}, int_size=<NUM_LIT:32>)), is_leaf=False, yang_name="<STR_LIT>", rest_name="<STR_LIT>", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='<STR_LIT>', defining_module='<STR_LIT>', yang_type='<STR_LIT>', is_config=False)<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.__dscp = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT>
|
Setter method for dscp, mapped from YANG variable /exp_dscp_state/qos_mpls/dscp (uint32)
If this variable is read-only (config: false) in the
source YANG file, then _set_dscp is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_dscp() directly.
YANG Description: dscp-val
|
f336783:c0:m22
|
def _get_exptrafficvalues(self):
|
return self.__exptrafficvalues<EOL>
|
Getter method for exptrafficvalues, mapped from YANG variable /exp_dscp_state/qos_mpls/exptrafficvalues (uint32)
YANG Description: exptrafficvalues
|
f336783:c0:m24
|
def _set_exptrafficvalues(self, v, load=False):
|
if hasattr(v, "<STR_LIT>"):<EOL><INDENT>v = v._utype(v)<EOL><DEDENT>try:<EOL><INDENT>t = YANGDynClass(v,base=TypedListType(allowed_type=RestrictedClassType(base_type=long, restriction_dict={'<STR_LIT>': ['<STR_LIT>']}, int_size=<NUM_LIT:32>)), is_leaf=False, yang_name="<STR_LIT>", rest_name="<STR_LIT>", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='<STR_LIT>', defining_module='<STR_LIT>', yang_type='<STR_LIT>', is_config=False)<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.__exptrafficvalues = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT>
|
Setter method for exptrafficvalues, mapped from YANG variable /exp_dscp_state/qos_mpls/exptrafficvalues (uint32)
If this variable is read-only (config: false) in the
source YANG file, then _set_exptrafficvalues is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_exptrafficvalues() directly.
YANG Description: exptrafficvalues
|
f336783:c0:m25
|
def _get_cluster_id(self):
|
return self.__cluster_id<EOL>
|
Getter method for cluster_id, mapped from YANG variable /show_client_id_df_info_state/cluster_id (uint32)
YANG Description: Cluster ID
|
f336784:c0:m3
|
def _set_cluster_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=long, restriction_dict={'<STR_LIT>': ['<STR_LIT>']}, int_size=<NUM_LIT:32>), is_leaf=True, yang_name="<STR_LIT>", rest_name="<STR_LIT>", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, is_keyval=True, namespace='<STR_LIT>', defining_module='<STR_LIT>', yang_type='<STR_LIT>', is_config=False)<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.__cluster_id = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT>
|
Setter method for cluster_id, mapped from YANG variable /show_client_id_df_info_state/cluster_id (uint32)
If this variable is read-only (config: false) in the
source YANG file, then _set_cluster_id is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_cluster_id() directly.
YANG Description: Cluster ID
|
f336784:c0:m4
|
def _get_client_id(self):
|
return self.__client_id<EOL>
|
Getter method for client_id, mapped from YANG variable /show_client_id_df_info_state/client_id (uint32)
YANG Description: Client Id
|
f336784:c0:m6
|
def _set_client_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=long, restriction_dict={'<STR_LIT>': ['<STR_LIT>']}, int_size=<NUM_LIT:32>), is_leaf=True, yang_name="<STR_LIT>", rest_name="<STR_LIT>", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, is_keyval=True, namespace='<STR_LIT>', defining_module='<STR_LIT>', yang_type='<STR_LIT>', is_config=False)<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.__client_id = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT>
|
Setter method for client_id, mapped from YANG variable /show_client_id_df_info_state/client_id (uint32)
If this variable is read-only (config: false) in the
source YANG file, then _set_client_id is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_client_id() directly.
YANG Description: Client Id
|
f336784:c0:m7
|
def _get_client_state(self):
|
return self.__client_state<EOL>
|
Getter method for client_state, mapped from YANG variable /show_client_id_df_info_state/client_state (boolean)
YANG Description: Client state
|
f336784:c0:m9
|
def _set_client_state(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, namespace='<STR_LIT>', defining_module='<STR_LIT>', yang_type='<STR_LIT>', is_config=False)<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.__client_state = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT>
|
Setter method for client_state, mapped from YANG variable /show_client_id_df_info_state/client_state (boolean)
If this variable is read-only (config: false) in the
source YANG file, then _set_client_state is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_client_state() directly.
YANG Description: Client state
|
f336784:c0:m10
|
def _get_is_all_vlan_elected(self):
|
return self.__is_all_vlan_elected<EOL>
|
Getter method for is_all_vlan_elected, mapped from YANG variable /show_client_id_df_info_state/is_all_vlan_elected (uint32)
YANG Description: All VLANs are elected as DF
|
f336784:c0:m12
|
def _set_is_all_vlan_elected(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=long, restriction_dict={'<STR_LIT>': ['<STR_LIT>']}, int_size=<NUM_LIT:32>), is_leaf=True, yang_name="<STR_LIT>", rest_name="<STR_LIT>", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='<STR_LIT>', defining_module='<STR_LIT>', yang_type='<STR_LIT>', is_config=False)<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.__is_all_vlan_elected = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT>
|
Setter method for is_all_vlan_elected, mapped from YANG variable /show_client_id_df_info_state/is_all_vlan_elected (uint32)
If this variable is read-only (config: false) in the
source YANG file, then _set_is_all_vlan_elected is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_is_all_vlan_elected() directly.
YANG Description: All VLANs are elected as DF
|
f336784:c0:m13
|
def _get_is_df_election_pending(self):
|
return self.__is_df_election_pending<EOL>
|
Getter method for is_df_election_pending, mapped from YANG variable /show_client_id_df_info_state/is_df_election_pending (uint32)
YANG Description: DF election pending
|
f336784:c0:m15
|
def _set_is_df_election_pending(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=long, restriction_dict={'<STR_LIT>': ['<STR_LIT>']}, int_size=<NUM_LIT:32>), is_leaf=True, yang_name="<STR_LIT>", rest_name="<STR_LIT>", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='<STR_LIT>', defining_module='<STR_LIT>', yang_type='<STR_LIT>', is_config=False)<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.__is_df_election_pending = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT>
|
Setter method for is_df_election_pending, mapped from YANG variable /show_client_id_df_info_state/is_df_election_pending (uint32)
If this variable is read-only (config: false) in the
source YANG file, then _set_is_df_election_pending is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_is_df_election_pending() directly.
YANG Description: DF election pending
|
f336784:c0:m16
|
def _get_num_df_vlans(self):
|
return self.__num_df_vlans<EOL>
|
Getter method for num_df_vlans, mapped from YANG variable /show_client_id_df_info_state/num_df_vlans (uint32)
YANG Description: No. of DF Vlans configured
|
f336784:c0:m18
|
def _set_num_df_vlans(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=long, restriction_dict={'<STR_LIT>': ['<STR_LIT>']}, int_size=<NUM_LIT:32>), is_leaf=True, yang_name="<STR_LIT>", rest_name="<STR_LIT>", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='<STR_LIT>', defining_module='<STR_LIT>', yang_type='<STR_LIT>', is_config=False)<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.__num_df_vlans = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT>
|
Setter method for num_df_vlans, mapped from YANG variable /show_client_id_df_info_state/num_df_vlans (uint32)
If this variable is read-only (config: false) in the
source YANG file, then _set_num_df_vlans is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_num_df_vlans() directly.
YANG Description: No. of DF Vlans configured
|
f336784:c0:m19
|
def _get_num_df_bds(self):
|
return self.__num_df_bds<EOL>
|
Getter method for num_df_bds, mapped from YANG variable /show_client_id_df_info_state/num_df_bds (uint32)
YANG Description: No. of DF BDs configured
|
f336784:c0:m21
|
def _set_num_df_bds(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=long, restriction_dict={'<STR_LIT>': ['<STR_LIT>']}, int_size=<NUM_LIT:32>), is_leaf=True, yang_name="<STR_LIT>", rest_name="<STR_LIT>", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, namespace='<STR_LIT>', defining_module='<STR_LIT>', yang_type='<STR_LIT>', is_config=False)<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.__num_df_bds = t<EOL>if hasattr(self, '<STR_LIT>'):<EOL><INDENT>self._set()<EOL><DEDENT>
|
Setter method for num_df_bds, mapped from YANG variable /show_client_id_df_info_state/num_df_bds (uint32)
If this variable is read-only (config: false) in the
source YANG file, then _set_num_df_bds is considered as a private
method. Backends looking to populate this variable should
do so via calling thisObj._set_num_df_bds() directly.
YANG Description: No. of DF BDs configured
|
f336784:c0:m22
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.