def process_media_event(npu, port, pas_media_obj):
try:
media_id = pas_media_obj.get_attr_data('base-pas/media/port')
display_str = pas_media_obj.get_attr_data(
'base-pas/media/display-string')
except:
nas_if.log_info(
"Media event without enough attributes to determine default media settings"
)
return
if_name = if_config.if_config_get_by_npu_port(npu, port)
if if_name is None:
nas_if.log_err("Interface Name: None")
return False
config = if_config.if_config_get(if_name)
port = fp.find_front_panel_port(config.fp_port)
pas_media_obj.add_attr('dell-if/if/interfaces/interface/speed',
config.get_speed())
pas_media_obj.add_attr('base-if-phy/physical/speed',
fp.get_max_port_speed(port))
config.set_media_obj(pas_media_obj)
return True
def get_npu_port_from_fp(fp_port, sub_port):
nas_if.log_info(
'Trying to get npu port based on front-panel %d subport %d' %
(fp_port, sub_port))
port_obj = fp.find_front_panel_port(fp_port)
if port_obj == None:
raise ValueError('Front-panel-port %d not found in cache' % fp_port)
br_mode = port_obj.get_breakout_mode()
nas_if.log_info('Cached breakout mode of front panel port %s is %s' %
(str(fp_port), str(br_mode)))
lane_id = nas_comm.subport_to_lane(br_mode, sub_port)
if lane_id == None:
raise ValueError('Failed to get lane id from br_mode %d subport %d' %
(br_mode, sub_port))
if isinstance(lane_id, tuple):
lane_id, flag = lane_id
nas_if.log_info('Get lane id %d with extended condition %s' %
(lane_id, flag))
npu_id = port_obj.npu
hw_port = port_obj.hwports[lane_id]
nas_if.log_info('Front panel port %d lane %d hw-port %d' %
(fp_port, lane_id, hw_port))
port_list = port_utils.get_phy_port_list()
port_id = port_utils.hw_port_to_phy_port(port_list, npu_id, hw_port)
if port_id == -1:
raise ValueError(
'There is no physical mapped to hw_port %d for subport %d' %
(hw_port, sub_port))
return (npu_id, port_id, hw_port)
def get_mac_offset_from_fp(fp_port, sub_port, fp_cache=None):
nas_if.log_info(
'Trying to get npu port based on front-panel %d subport %d' %
(fp_port, sub_port))
if fp_cache is None:
# Use local front-panel-port db
port_obj = fp.find_front_panel_port(fp_port)
if port_obj is None:
raise ValueError('Front-panel-port %d not found in cache' %
fp_port)
br_mode = port_obj.get_breakout_mode()
mac_offset = port_obj.mac_offset
else:
cps_port_obj = fp_cache.get(fp_port)
if cps_port_obj is None:
raise ValueError('Front-panel-port %d not found in cps cache' %
fp_port)
br_mode = nas_if.get_cps_attr(cps_port_obj, _fp_attr('breakout-mode'))
mac_offset = nas_if.get_cps_attr(cps_port_obj, _fp_attr('mac-offset'))
if br_mode is None or mac_offset is None:
raise ValueError('Mandatory attributes not found in cps object')
nas_if.log_info('Cached breakout mode of front panel port %d is %d' %
(fp_port, br_mode))
lane_id = nas_comm.subport_to_lane(br_mode, sub_port)
if lane_id is None:
raise ValueError('Failed to get lane id from br_mode %d subport %d' %
(br_mode, sub_port))
if isinstance(lane_id, tuple):
lane_id, flag = lane_id
nas_if.log_info('Get lane id %d with extended condition %s' %
(lane_id, flag))
return mac_offset + lane_id
def set_fp_port_config(fr_port, br_mode, phy_port_speed, phy_mode):
nas_if.log_info(
'Front-panel-port %d config request: br_mode %s speed %s phy_mode %s' %
(fr_port, br_mode, phy_port_speed, phy_mode))
fp_port_obj = fp.find_front_panel_port(fr_port)
if fp_port_obj is None:
nas_if.log_err('Front-panel-port %d not found' % fr_port)
return False
npu = fp_port_obj.npu
if phy_mode == None:
phy_mode = nas_comm.yang.get_value('ether', 'yang-phy-mode')
#Check if breakout mode is same as current breakout mode
if (br_mode == fp_port_obj.get_breakout_mode()
and fp_port_obj.get_phy_mode() == phy_mode
and fp_port_obj.get_port_speed() == phy_port_speed):
nas_if.log_info('FP config is same as current config')
return True
#check if breakout mode is supported by the FP port ( not now)
# TODO
port_list = port_utils.get_phy_port_list()
#convert FP port to Hwport list ( control port)
hwports = fp_port_obj.hwports[:]
deleted_phy_ports = {}
for hwport in hwports:
phy_port_obj = port_utils.get_phy_port_by_hw_port(
port_list, npu, hwport)
if phy_port_obj == None:
continue
if port_utils.cps_del_nas_port(phy_port_obj):
port_utils.del_phy_port(port_list, phy_port_obj)
deleted_phy_ports[hwport] = phy_port_obj
else:
nas_if.log_err('Failed to delete physical port')
return False
# Create new phy ports based on the new breakout mode
created_phy_ports = {}
if port_utils.create_nas_ports(npu, hwports, br_mode, phy_port_speed,
phy_mode, fr_port,
created_phy_ports) == True:
for port in created_phy_ports:
port_utils.add_phy_port(port_list, created_phy_ports[port])
else:
nas_if.log_err(
'Failed to create physical port, rollback to previous status')
port_utils.rollback_port_add_del(port_list, created_phy_ports,
deleted_phy_ports,
fp_port_obj.get_port_speed(),
fp_port_obj.get_phy_mode())
return False
#set new breakout mode and new port speed
fp_port_obj.set_breakout_mode(br_mode)
fp_port_obj.set_port_speed(phy_port_speed)
send_fp_event(fp_port_obj)
return True
def create_hg_cps_obj(hg_obj):
'''Method to create a Hybrid Group object'''
if hg_obj is None:
return None
obj = cps_object.CPSObject(
module='base-pg/dell-pg/port-groups/hybrid-group',
qual='target',
data={
hg_utils.hg_attr('id'): hg_obj.name,
hg_utils.hg_attr('profile'):
hg_obj.get_hybrid_group_profile_mode()
})
for fpp_idx, fpp_num in enumerate(hg_obj.get_fp_ports()):
port = fp.find_front_panel_port(fpp_num)
obj.add_embed_attr([hg_utils.hg_attr('port'),
str(fpp_idx), 'port-id'], str(fpp_num), 6)
obj.add_embed_attr(
[hg_utils.hg_attr('port'),
str(fpp_idx), 'phy-mode'], port.get_phy_mode(), 6)
obj.add_embed_attr(
[hg_utils.hg_attr('port'),
str(fpp_idx), 'breakout-mode'], port.get_breakout_mode(), 6)
obj.add_embed_attr(
[hg_utils.hg_attr('port'),
str(fpp_idx), 'port-speed'], port.get_port_speed(), 6)
return obj
def set_cb(methods, params):
obj = cps_object.CPSObject(obj=params['change'])
if params['operation'] != 'rpc':
return False
fr_port = obj.get_attr_data(_breakout_i_attr('front-panel-port'))
mode = obj.get_attr_data(_breakout_i_attr('breakout-mode'))
port_obj = fp.find_front_panel_port(fr_port)
if port_obj is None:
return False
m = get_phy_port_cache()
npu = port_obj.npu
control_port = hw_port_to_nas_port(m, npu, port_obj.control_port())
if control_port == -1:
return False
port_list = []
if mode == 2: # breakout - 1->4
port_list.append(control_port)
if mode == 4: # breakin 4->1
for i in port_obj.hwports:
port_list.append(hw_port_to_nas_port(m, npu, i))
for i in port_list:
if i == -1:
nas_if.log_err(
"Invalid port list detected.. not able to complete operation ")
nas_if.log_err(port_list)
return False
breakout_req = cps_object.CPSObject(
module='base-if-phy/set-breakout-mode',
data={
'base-if-phy/set-breakout-mode/input/breakout-mode': mode,
'base-if-phy/set-breakout-mode/input/npu-id': npu,
'base-if-phy/set-breakout-mode/input/port-id': control_port,
'base-if-phy/set-breakout-mode/input/effected-port': port_list
})
tr = cps_utils.CPSTransaction([('rpc', breakout_req.get())])
if tr.commit() == False:
return False
return True
def _get_default_speed(config):
''' Method to retrieve minimum of port speed and media speed '''
# Retrieve media default speed for mode as media_speed
media_type = config.get_media_type()
if media_type is None:
return None
media_speed = media.get_default_media_setting(media_type, 'speed')
# Retreive port default speed for mode as fp_speed. fp_speed is the max speed supported on the port
fp_port = fp.find_front_panel_port(config.get_fp_port())
fp_speed = fp_port.get_port_speed()
# Return min(port_speed, media_speed)
return _get_min_speed(media_speed, fp_speed)
def _get_default_speed(config):
''' Method to retrieve minimum of port speed and media speed '''
# Retrieve media default speed for mode as media_speed
intf_phy_mode = nas_comm.yang.get_value(config.get_ietf_intf_type(),
'ietf-type-2-phy-mode')
media_speed = media_config.Speed().get_setting(config.get_media_obj(),
intf_phy_mode)
# Retreive port default speed for mode as fp_speed. fp_speed is the max speed supported on the port
fp_port = fp.find_front_panel_port(config.get_fp_port())
fp_speed = fp_port.get_port_speed()
# Return min(port_speed, media_speed)
return _get_min_speed(media_speed, fp_speed)
def set_fp_to_hwp_mapping(fr_port, br_mode, port_speed, phy_mode, hwports):
# If hwports is empty then delete all phy ports under the FP and set the hwport list to NOne
port_detail = fp.find_front_panel_port(fr_port)
if port_detail == None:
return False
hwp_list = port_detail.get_hwports()
port_list = port_utils.get_phy_port_list()
if len(hwports) == 0:
npu = port_detail.npu
if hwp_list != None:
for hwp in hwp_list:
phy_obj = port_utils.get_phy_port_by_hw_port(
port_list, npu, hwp)
if phy_obj != None:
# delete the physical port
ret = port_utils.cps_del_nas_port(phy_obj)
if ret == False:
nas_if.log_err(' failed to delete Phy port')
return False
# Delete hwp to phy port mapping
port_utils.del_phy_port(port_list, phy_obj)
hwports += hwp_list
# set the hw port list to None
port_detail.set_hwports(None)
# set breakout mode to None
port_detail.set_breakout_mode(None)
return True
else:
# hwports is not empty. It means add the hwport to the fp port
# create phy port corresponding to the hwport
# check if hwport list is empty
if hwp_list != None and len(hwp_list) > 0:
# hw port list is not empty, return False
print 'port list is not empty'
return False
port_detail.set_hwports(hwports)
# Now create phy ports base on the new hw port list.
ret = set_fp_port_config(fr_port, br_mode, port_speed, phy_mode)
if not ret:
# Rollback
port_detail.set_hwports(None)
return ret
return True
def get_npu_hwport_id_from_fp_obj(cps_obj):
try:
npu_id = cps_obj.get_attr_data(npu_attr_name)
except ValueError:
print 'Input object does not contain npu id attribute'
return None
port_id = None
try:
port_id = cps_obj.get_attr_data(port_attr_name)
except ValueError:
pass
if port_id == None:
try:
front_panel_port = cps_obj.get_attr_data(fp_port_attr_name)
subport_id = cps_obj.get_attr_data(subport_attr_name)
except ValueError:
print 'front_panel_port or subport not specified'
return None
port_obj = fp.find_front_panel_port(front_panel_port)
if port_obj == None:
print 'Invalid front panel port id %d' % front_panel_port
return None
if subport_id >= len(port_obj.hwports):
print 'Invalid subport id %d' % subport_id
return None
hw_port = port_obj.hwports[subport_id]
m = get_phy_port_cache()
port_id = hw_port_to_nas_port(m, npu_id, hw_port)
if port_id == -1:
print 'There is no physical mapped to hw_port %d' % hw_port
return None
cps_obj.add_attr(port_attr_name, port_id)
else:
m = get_phy_port_cache()
ph_key = get_phy_port_cache_keys(npu_id, port_id)
if not ph_key in m:
print 'Physical port object not found'
return None
hw_port = m[ph_key].get_attr_data('hardware-port-id')
return (npu_id, hw_port)
def _if_update_config(op, obj):
if_name = None
npu_id = None
port_id = None
negotiation = None
speed = None
duplex = None
media_type = None
breakout_mode = None
try:
if_name = obj.get_attr_data(ifname_attr_name)
except:
# check for media_type change event obj
nas_if.log_info('process media event, op %s' % op)
return(if_handle_set_media_type(op, obj))
nas_if.log_info('update config for %s: op %s' % (if_name, op))
npu_port_found = True
try:
npu_id = obj.get_attr_data(npu_attr_name)
port_id = obj.get_attr_data(port_attr_name)
except:
npu_port_found = False
if op == 'create':
# if config is cached only for physical interface
if_type = if_config.get_intf_type(obj)
if if_type != 'front-panel':
return True
ietf_intf_type = nas_if.get_cps_attr(obj,nas_comm.get_value(nas_comm.attr_name,'intf_type'))
config = if_config.IF_CONFIG(if_name, ietf_intf_type)
if if_config.if_config_add(if_name, config) == False:
nas_if.log_err(' interface config already present for ' + str(if_name))
nas_if.log_info(' interface config added successfully for ' + str(if_name))
if (nas_if.get_cps_attr(obj, negotiation_attr_name) is None):
obj.add_attr(negotiation_attr_name, _yang_auto_neg)
config = if_config.if_config_get(if_name)
if config is None:
nas_if.log_info(' interface not present in if config list' + str(if_name))
return True
if npu_port_found:
#NPU port attribute only found in create or associate/disassociate request
nas_if.log_info(' set npu %s and port %s to if config' % (str(npu_id), str(port_id)))
config.set_npu_port(npu_id, port_id)
if op == 'set' or op == 'create':
force_update = False
if npu_port_found:
if npu_id != None or port_id != None:
#for create or assiociate request
fp_port = nas_if.get_cps_attr(obj, fp_port_attr_name)
subport_id = nas_if.get_cps_attr(obj, subport_attr_name)
config.set_fp_port(fp_port)
config.set_subport_id(subport_id)
fp_obj = fp.find_front_panel_port(fp_port)
if fp_obj != None:
config.set_cfg_speed(fp_obj.get_port_speed())
config.set_breakout_mode(fp_obj.get_breakout_mode())
obj.add_attr(supported_autoneg, fp_obj.get_supported_autoneg())
else:
nas_if.log_err('Unable to find front panel object for port %d' % fp_port)
#read media type from PAS
media_type = _get_if_media_type(fp_port)
nas_if.log_info(' set media_type %s to if config for fp %d' % (
str(media_type), fp_port));
config.set_media_type(media_type)
if check_if_media_supported(media_type, config) != True:
config.set_is_media_supported(False)
nas_if.log_err(' Plugged-in media is not supported for ' + str(if_name))
return True
if check_if_media_support_phy_mode(media_type, config) != True:
config.set_is_media_supported(False)
nas_if.log_err(' Plugged-in media does not support configured phy mode for %s' %
if_name)
return True
config.set_is_media_supported(True)
obj.add_attr(media_type_attr_name, media_type)
_if_init_config(obj, config)
if op != 'create':
# for the case of interface associate, force attribute update
force_update = True
else:
#for disassociate request
nas_if.log_info(' reset breakout_mode and media type in if config')
config.set_breakout_mode(None)
config.set_media_type(None)
if not(_fp_identification_led_handle(obj)):
nas_if.log_err('Setting identification led failed')
return False
if config.get_is_media_supported() == False:
nas_if.log_info('media type not supported')
# Do not do any further processing based on the media connected
return True
negotiation = nas_if.get_cps_attr(obj, negotiation_attr_name)
speed = nas_if.get_cps_attr(obj, speed_attr_name)
duplex = nas_if.get_cps_attr(obj, duplex_attr_name)
# update the new speed, duplex and autoneg in the config. If
# autoneg, speed or duplex is auto then fetch default value and replace in the cps object
# do not set auto speed in case of breakout mode.
# In case of ethernet mode, set default speed only in case of breakout mode 1x1
# in case of FC mode, set the default speed of the media.
if speed != None and (force_update or speed != config.get_speed()):
if _set_speed(speed, config, obj) == False:
nas_if.log_err('failed to set speed')
return False
# in case of negotiation, add autoneg attribute to on or off or default autoneg
# if negotiation== auto
if negotiation != None and (force_update or negotiation != config.get_negotiation()):
_set_autoneg(negotiation, config, obj)
if duplex != None and (force_update or duplex != config.get_duplex()):
_set_duplex(duplex, config, obj)
fec_mode = nas_if.get_cps_attr(obj, fec_mode_attr_name)
if op == 'create' or (fec_mode != None and
(force_update or fec_mode != config.get_fec_mode())):
if _set_fec_mode(fec_mode, config, obj, op) != True:
nas_if.log_err('Failed to set FEC mode %d to interface %s' % (fec_mode, if_name))
return False
if op == 'create':
_set_hw_profile(config, obj)
config.show()
if op == 'delete':
# remove the interface entry from the config
if_config.if_config_del(if_name)
return True
def _update_fp(fp_obj):
fr_port = nas_if.get_cps_attr(fp_obj, 'front-panel-port')
fp_db = fp.find_front_panel_port(fr_port)
fp_db.set_breakout_mode(nas_if.get_cps_attr(fp_obj, 'breakout-mode'))
fp_db.set_speed(nas_if.get_cps_attr(fp_obj, 'port-speed'))
def apply_cps_config_to_hg(obj, hg_obj):
'''Method to configure a Hybrid Group'''
#Configure Profile Mode
rollback_list = []
prev_profile_mode = hg_obj.get_hybrid_group_profile_mode()
cur_profile_mode = nas_if.get_cps_attr(obj, hg_utils.hg_attr('profile'))
if cur_profile_mode is not None and prev_profile_mode != cur_profile_mode:
hg_obj.set_hybrid_group_profile_mode(cur_profile_mode)
# Configure Default Breakout for profile mode
port_list = hg_obj.get_fp_ports()
if port_list is not None:
for fpp_num in port_list:
port = fp.find_front_panel_port(fpp_num)
# Previous configuration
prev_br_mode = port.get_breakout_mode()
prev_port_speed = port.get_port_speed()
prev_phy_mode = port.get_phy_mode()
prev_port_profile_name = port.get_profile_type()
# Current configuration
hybrid_profile = port.get_hybrid_profile()
cur_port_profile_name = str(
hybrid_profile.get_port_profile(cur_profile_mode))
port.apply_port_profile(
fp.get_port_profile(cur_port_profile_name))
cur_phy_mode = port.get_def_phy_mode()
cur_br_mode = port.get_def_breakout()
cur_port_speed = port.get_default_phy_port_speed()
rollback_list.append((fpp_num, prev_br_mode, prev_port_speed,
prev_phy_mode, prev_port_profile_name))
# Apply configuration
rc = fp_utils.set_fp_port_config(fpp_num, cur_br_mode,
cur_port_speed, cur_phy_mode)
if rc is False or fpp_num not in hg_obj.get_fp_ports():
nas_if.log_err(
'failed to config fp_port %d, start rollback' %
fpp_num)
# Rollback
for (fpp, br_mode, port_speed, phy_mode,
port_profile_name) in rollback_list:
nas_if.log_info('rollback port %d config' % fpp)
port = fp.find_front_panel_port(fpp)
fp_utils.set_fp_port_config(fpp, br_mode, port_speed,
phy_mode)
port.apply_port_profile(
fp.get_port_profile(port_profile_name))
hg_obj.set_hybrid_group_profile_mode(prev_profile_mode)
return False
hwp_speed = pg_utils.get_hwp_speed(cur_br_mode, cur_port_speed,
cur_phy_mode)
port.set_hwp_speed(hwp_speed)
# Configure User Specified Breakout for profile mode
port_list = nas_if.get_cps_attr(obj, hg_utils.hg_attr('port'))
if port_list is not None:
for fpp_idx in port_list:
fpp_num = int(port_list[fpp_idx]['port-id'])
port = fp.find_front_panel_port(fpp_num)
# Current configuration
cur_phy_mode = port_list[fpp_idx]['phy-mode']
cur_br_mode = port_list[fpp_idx]['breakout-mode']
cur_port_speed = port_list[fpp_idx]['port-speed']
# Apply configuration
rc = fp_utils.set_fp_port_config(fpp_num, cur_br_mode,
cur_port_speed, cur_phy_mode)
if rc is False or fpp_num not in hg_obj.get_fp_ports():
nas_if.log_err('failed to config fp_port %d, start rollback' %
fpp_num)
# Rollback
for (fpp, br_mode, port_speed, phy_mode,
port_profile_name) in rollback_list:
nas_if.log_info('rollback port %d config' % fpp)
port = fp.find_front_panel_port(fpp)
fp_utils.set_fp_port_config(fpp, br_mode, port_speed,
phy_mode)
port.apply_port_profile(
fp.get_port_profile(port_profile_name))
hg_obj.set_hybrid_group_profile_mode(prev_profile_mode)
return False
hwp_speed = pg_utils.get_hwp_speed(cur_br_mode, cur_port_speed,
cur_phy_mode)
port.set_hwp_speed(hwp_speed)
return True
def create_hg_state_cps_obj(hg_obj):
'''Helper Method to generate Hybrid Group State'''
if hg_obj is None:
nas_if.log_err("Hybrid Group is None")
return None
obj = cps_object.CPSObject(
module='base-pg/dell-pg/port-groups-state/hybrid-group-state',
qual='observed',
data={
hg_utils.hg_state_attr('id'):
hg_obj.name,
hg_utils.hg_state_attr('default-profile'):
hg_obj.get_hybrid_group_default_profile_mode(),
hg_utils.base_hg_state_attr('front-panel-port'):
hg_obj.get_fp_ports(),
hg_utils.base_hg_state_attr('hwport-list'):
hg_obj.get_hw_ports()
})
# Add description field for each Hybrid Group.
for profile_mode_idx, profile_mode in enumerate(
hg_obj.get_supported_hybrid_group_profile_modes()):
profile_description = str(profile_mode)
for fpp_idx, fpp_num in enumerate(hg_obj.get_fp_ports()):
port = fp.find_front_panel_port(fpp_num)
hybrid_profile = port.get_hybrid_profile()
port_profile_name = str(
hybrid_profile.get_port_profile(profile_mode))
port_profile = fp.get_port_profile(port_profile_name)
desc = (("; Port %d - %s ") % (fpp_num, port_profile.description))
profile_description += desc
obj.add_embed_attr([
hg_utils.hg_state_attr('supported-profiles'),
str(profile_mode_idx), 'profile-name'
], str(profile_mode), 6)
obj.add_embed_attr([
hg_utils.hg_state_attr('supported-profiles'),
str(profile_mode_idx), 'profile-description'
], str(profile_description), 6)
for fpp_idx, fpp_num in enumerate(hg_obj.get_fp_ports()):
port = fp.find_front_panel_port(fpp_num)
prev_port_profile_name = port.get_profile_type()
hybrid_profile = port.get_hybrid_profile()
for profile_mode_idx, profile_mode in enumerate(
hybrid_profile.profile_modes):
cur_port_profile_name = str(
hybrid_profile.get_port_profile(profile_mode))
port.apply_port_profile(fp.get_port_profile(cur_port_profile_name))
obj.add_embed_attr(
[hg_utils.hg_state_attr('port'),
str(fpp_idx), 'port-id'], str(fpp_num), 6)
obj.add_embed_attr([
hg_utils.hg_state_attr('port'),
str(fpp_idx), 'profile',
str(profile_mode_idx), 'name'
], str(profile_mode), 8)
obj.add_embed_attr([
hg_utils.hg_state_attr('port'),
str(fpp_idx), 'profile',
str(profile_mode_idx), 'default-phy-mode'
], str(port.get_def_phy_mode()), 8)
obj.add_embed_attr([
hg_utils.hg_state_attr('port'),
str(fpp_idx), 'profile',
str(profile_mode_idx), 'default-breakout-mode'
], str(port.get_def_breakout()), 8)
obj.add_embed_attr([
hg_utils.hg_state_attr('port'),
str(fpp_idx), 'profile',
str(profile_mode_idx), 'default-port-speed'
], str(port.get_default_phy_port_speed()), 8)
cap_idx = 0
for mode in port.get_breakout_caps():
for hw_speed in port.get_hwport_speed_caps():
phy_npu_speed = fp.get_phy_npu_port_speed(
mode, (hw_speed * len(hg_obj.get_hw_ports())) /
len(hg_obj.get_fp_ports()))
if False is fp.verify_npu_supported_speed(phy_npu_speed):
continue
obj.add_embed_attr([
hg_utils.hg_state_attr('port'),
str(fpp_idx), 'profile',
str(profile_mode_idx), 'br-cap',
str(cap_idx), 'phy-mode'
], str(nas_comm.yang.get_value('ether', 'yang-phy-mode')),
10)
obj.add_embed_attr([
hg_utils.hg_state_attr('port'),
str(fpp_idx), 'profile',
str(profile_mode_idx), 'br-cap',
str(cap_idx), 'breakout-mode'
], str(mode), 10)
obj.add_embed_attr([
hg_utils.hg_state_attr('port'),
str(fpp_idx), 'profile',
str(profile_mode_idx), 'br-cap',
str(cap_idx), 'port-speed'
], str(phy_npu_speed), 10)
obj.add_embed_attr([
hg_utils.hg_state_attr('port'),
str(fpp_idx), 'profile',
str(profile_mode_idx), 'br-cap',
str(cap_idx), 'skip-ports'
], str(
nas_comm.yang.get_tbl('breakout-to-skip-port')[mode]),
10)
cap_idx += 1
port.apply_port_profile(fp.get_port_profile(prev_port_profile_name))
return obj
def get_alloc_mac_addr_params(if_type, cps_obj):
ret_list = {'if_type': if_type}
if if_type == 'front-panel':
port_id = None
try:
port_id = cps_obj.get_attr_data(port_attr_name)
except ValueError:
pass
if port_id == None:
front_panel_port = None
subport_id = None
try:
front_panel_port = cps_obj.get_attr_data(fp_port_attr_name)
subport_id = cps_obj.get_attr_data(subport_attr_name)
except ValueError:
pass
if front_panel_port == None or subport_id == None:
try:
if_name = cps_obj.get_attr_data(ifname_attr_name)
except ValueError:
nas_if.log_err('Failed to read interface name')
return None
front_port = nas_if.get_front_port_from_name(if_name, False)
if front_port == None:
nas_if.log_err(
'Failed to parse front port from interface name %s' %
if_name)
return None
front_panel_port = front_port[0]
subport_id = front_port[1]
cps_obj.add_attr(fp_port_attr_name, front_panel_port)
cps_obj.add_attr(subport_attr_name, subport_id)
port_obj = fp.find_front_panel_port(front_panel_port)
if port_obj == None:
nas_if.log_err('Invalid front panel port id %d' %
front_panel_port)
return None
if subport_id > len(port_obj.hwports):
nas_if.log_err('Invalid subport id %d' % subport_id)
return None
if subport_id > 0:
subport_id -= 1
npu_id = port_obj.npu
hw_port = port_obj.hwports[subport_id]
m = get_phy_port_cache()
port_id = hw_port_to_nas_port(m, npu_id, hw_port)
if port_id == -1:
nas_if.log_err('There is no physical mapped to hw_port %d' %
hw_port)
return None
cps_obj.add_attr(npu_attr_name, npu_id)
cps_obj.add_attr(port_attr_name, port_id)
else:
try:
npu_id = cps_obj.get_attr_data(npu_attr_name)
except ValueError:
nas_if.log_err(
'Input object does not contain npu id attribute')
return None
m = get_phy_port_cache()
ph_key = get_phy_port_cache_keys(npu_id, port_id)
if not ph_key in m:
nas_if.log_err('Physical port object not found')
return None
hw_port = m[ph_key].get_attr_data('hardware-port-id')
npu = fp.get_npu(npu_id)
if hw_port == None or npu == None:
nas_if.log_err(
'No hardware port id or npu object for front panel port')
return None
p = npu.port_from_hwport(hw_port)
lane = p.lane(hw_port)
mac_offset = p.mac_offset + lane
ret_list['fp_mac_offset'] = mac_offset
elif if_type == 'vlan':
try:
vlan_id = cps_obj.get_attr_data(vlan_id_attr_name)
except ValueError:
nas_if.log_err('Input object does not contain VLAN id attribute')
return None
ret_list['vlan_id'] = vlan_id
elif if_type == 'lag':
try:
lag_name = cps_obj.get_attr_data(ifname_attr_name)
except ValueError:
nas_if.log_err('Input object does not contain name attribute')
return None
lag_id = get_lag_id_from_name(lag_name)
ret_list['lag_id'] = lag_id
else:
nas_if.log_err('Unknown interface type %s' % if_type)
return None
return ret_list
def _if_update_config(op, obj):
if_name = None
npu_id = None
port_id = None
negotiation = None
speed = None
duplex = None
try:
if_name = obj.get_attr_data(
nas_comm.yang.get_value('if_name', 'attr_name'))
except:
nas_if.log_info("Interface name not present in the object")
return True
nas_if.log_info('update config for %s: op %s' % (if_name, op))
npu_port_found = True
try:
npu_id = obj.get_attr_data(
nas_comm.yang.get_value('npu_id', 'attr_name'))
port_id = obj.get_attr_data(
nas_comm.yang.get_value('port_id', 'attr_name'))
except:
npu_port_found = False
if op == 'create':
# if config is cached only for physical interface
if_type = if_config.get_intf_type(obj)
if if_type != 'front-panel':
return True
ietf_intf_type = nas_if.get_cps_attr(
obj, nas_comm.yang.get_value('intf_type', 'attr_name'))
config = if_config.IF_CONFIG(if_name, ietf_intf_type)
if if_config.if_config_add(if_name, config) == False:
nas_if.log_err(' interface config already present for ' +
str(if_name))
nas_if.log_info(' interface config added successfully for ' +
str(if_name))
if (nas_if.get_cps_attr(
obj, nas_comm.yang.get_value('negotiation', 'attr_name')) is
None):
obj.add_attr(nas_comm.yang.get_value('negotiation', 'attr_name'),
nas_comm.yang.get_value('auto', 'yang-autoneg'))
config = if_config.if_config_get(if_name)
if config is None:
nas_if.log_info(' interface not present in if config list' +
str(if_name))
return True
if npu_port_found:
#NPU port attribute only found in create or associate/disassociate request
nas_if.log_info(' set npu %s and port %s to if config' %
(str(npu_id), str(port_id)))
config.set_npu_port(npu_id, port_id)
if op == 'set' or op == 'create':
force_update = False
negotiation = nas_if.get_cps_attr(
obj, nas_comm.yang.get_value('negotiation', 'attr_name'))
speed = nas_if.get_cps_attr(
obj, nas_comm.yang.get_value('speed', 'attr_name'))
duplex = nas_if.get_cps_attr(
obj, nas_comm.yang.get_value('duplex', 'attr_name'))
fec = nas_if.get_cps_attr(
obj, nas_comm.yang.get_value('fec_mode', 'attr_name'))
if npu_port_found:
if npu_id != None or port_id != None:
#for create or assiociate request
fp_port = nas_if.get_cps_attr(
obj, nas_comm.yang.get_value('fp_port', 'attr_name'))
subport_id = nas_if.get_cps_attr(
obj, nas_comm.yang.get_value('subport_id', 'attr_name'))
config.set_fp_port(fp_port)
config.set_subport_id(subport_id)
fp_obj = fp.find_front_panel_port(fp_port)
if fp_obj != None:
config.set_cfg_speed(fp_obj.get_port_speed())
config.set_breakout_mode(fp_obj.get_breakout_mode())
obj.add_attr(
nas_comm.yang.get_value('supported_autoneg',
'attr_name'),
fp_obj.get_supported_autoneg())
else:
nas_if.log_err(
'Unable to find front panel object for port %d' %
fp_port)
#read media type from PAS
try:
media_obj = _get_if_media_obj(fp_port)
except:
media_obj = None
media_monitor.process_media_event(npu_id, port_id, media_obj)
if if_lib.check_if_media_supported(
config
) != True or if_lib.check_if_media_support_phy_mode(
config) != True:
config.set_is_media_supported(False)
if negotiation is not None:
config.set_negotiation(negotiation)
if fec is not None and nas_comm.is_fec_supported(
fec, config.get_cfg_speed()) is True:
config.set_fec_mode(fec)
if duplex is not None:
config.set_duplex(duplex)
if speed is not None:
if speed != nas_comm.yang.get_value(
'auto', 'yang-speed'
) and if_lib.verify_intf_supported_speed(
config, speed) is True:
config.set_speed(speed)
return True
obj.add_attr(
nas_comm.yang.get_value('media_type', 'attr_name'),
config.get_media_cable_type())
config.set_is_media_supported(True)
_if_init_config(obj, config)
if op != 'create':
# for the case of interface associate, force attribute update
force_update = True
else:
#for disassociate request
nas_if.log_info(
' reset breakout_mode and media type in if config')
config.set_breakout_mode(None)
config.set_media_obj(None)
if not (_fp_identification_led_handle(obj)):
nas_if.log_err('Setting identification led failed')
return False
if config.get_is_media_supported() == False:
nas_if.log_info('media type not supported')
# Do not do any further processing based on the media connected
if negotiation is not None:
config.set_negotiation(negotiation)
if fec is not None and nas_comm.is_fec_supported(
fec, config.get_cfg_speed()) is True:
config.set_fec_mode(fec)
if duplex is not None:
config.set_duplex(duplex)
if speed is not None:
if speed != nas_comm.yang.get_value(
'auto',
'yang-speed') and if_lib.verify_intf_supported_speed(
config, speed) is True:
config.set_speed(speed)
return True
# update the new speed, duplex and autoneg in the config. If
# autoneg, speed or duplex is auto then fetch default value and replace in the cps object
# do not set auto speed in case of breakout mode.
# In case of ethernet mode, set default speed only in case of breakout mode 1x1
# in case of FC mode, set the default speed of the media.
if speed != None and (force_update or speed != config.get_speed()):
if if_lib.set_if_speed(speed, config, obj) == False:
nas_if.log_err('failed to set speed')
return False
if duplex != None and (force_update or duplex != config.get_duplex()):
if_lib.set_if_duplex(duplex, config, obj)
# in case of negotiation, add autoneg attribute to on or off or default autoneg for eth mode interfaces
intf_phy_mode = nas_comm.yang.get_value(config.get_ietf_intf_type(),
'ietf-type-2-phy-mode')
if intf_phy_mode is not nas_comm.yang.get_value('fc', 'yang-phy-mode'):
if negotiation != None and (
force_update or negotiation != config.get_negotiation()):
if_lib.set_if_autoneg(negotiation, config, obj)
else:
if (nas_if.get_cps_attr(
obj, nas_comm.yang.get_value('negotiation', 'attr_name'))
is not None):
obj.del_attr(nas_comm.yang.get_value('auto_neg', 'attr_name'))
if ((intf_phy_mode == nas_comm.yang.get_value('ether',
'yang-phy-mode'))
and (op == 'create' or
(fec != None and
(force_update or fec != config.get_fec_mode())))):
if if_lib.set_if_fec(fec, config, obj, op) == False:
if op == 'create':
obj.del_attr(
nas_comm.yang.get_value('fec_mode', 'attr_name'))
nas_if.log_info("Failed to set FEC")
else:
nas_if.log_err("Failed to set FEC")
return False
if op == 'create':
if_lib.set_if_hw_profile(config, obj)
config.show()
if op == 'delete':
# remove the interface entry from the config
if_config.if_config_del(if_name)
return True
