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