def set_media_transceiver(interface_obj):
# get front panel port from ifindex
if_obj = cps_object.CPSObject(obj=interface_obj)
npu = if_obj.get_attr_data('base-if-phy/if/interfaces/interface/npu-id')
port = if_obj.get_attr_data('base-if-phy/if/interfaces/interface/port-id')
nas_if.log_info("set_media_transceiver for "+str(npu)+" , " +str(port))
enable = if_obj.get_attr_data('if/interfaces/interface/enabled')
port_list = nas_if.nas_os_phy_list(
d={'npu-id': npu, 'port-id': port})
phy_obj = cps_object.CPSObject(obj=port_list[0])
fanout = phy_obj.get_attr_data('fanout-mode')
try:
hwport = phy_obj.get_attr_data('hardware-port-id')
fp_details = fp.find_port_by_hwport(npu, hwport)
except:
nas_if.log_err(" Error in setting media Transceiver for ", if_obj.get_attr_data('name'))
return
# set media transceiver using media Id and channel ID
# in case of 40G mode all channels should be enabled/disabled
# else only one channel.
#
nas_if.log_info("fanout " + str(fanout))
if fanout == 2: # then it is in 4x10G fanout mode BASE_PORT_BREAKOUT_MODE_BREAKOUT_4X1
_lane = fp_details.lane
else: # non-fanout mode 1x40g mode
_lane = None # enable/disable all channels. Do not pass Lane #
media.media_transceiver_set(1, fp_details.media_id, _lane, enable)
def __if_present(name):
"""Method to check if the interface is present in linux"""
if len(dn_base_ip_tool.get_if_details(name)) > 0:
nas_if.log_info("Interface exists " + str(name))
return True
nas_if.log_info("Interface doesn't exist " + str(name))
return False
def add_fp_caps_to_fp_obj(fp_port, fp_obj):
br_modes = fp_port.get_breakout_caps()
hw_speeds = fp_port.get_hwport_speed_caps()
hwp_count = len(fp_port.get_hwports())
phy_mode = nas_comm.yang.get_value(
'ether', 'yang-phy-mode'
) # FP port does not support FC capability directly. it is on the port group
cap_index = 0
cap_list = {}
for mode in br_modes:
skip_ports = nas_comm.yang.get_tbl('breakout-to-skip-port')[mode]
for speed in hw_speeds:
phy_speed = fp.get_phy_npu_port_speed(mode, speed * hwp_count)
if fp.verify_npu_supported_speed(phy_speed) == False:
nas_if.log_info(
"create_and_add_fp_caps: fp port %s doesn't support yang speed %s "
% (str(fp_port.id), str(phy_speed)))
# breakout mode and this speed is excluded from cps show
continue
cap_list[str(cap_index)] = {
'phy-mode': phy_mode,
'breakout-mode': mode,
'port-speed': phy_speed,
'skip-ports': skip_ports
}
cap_index += 1
fp_obj.add_attr('br-cap', cap_list)
def _add_default_duplex(media_type, cps_obj):
# fetch default duplex
duplex = media.get_default_media_setting(media_type, 'duplex')
if duplex == None:
duplex = _yang_dup_full
cps_obj.add_attr(duplex_attr_name, duplex)
nas_if.log_info("default Duplex is " + str(duplex))
def if_handle_set_media_type(op, obj):
if_name = None
try:
npu = obj.get_attr_data(npu_attr_name)
port = obj.get_attr_data(port_attr_name)
media_type = obj.get_attr_data(media_type_attr_name)
except:
nas_if.log_err(
'missing npu,port or media type in set media type request')
return
# find npu, port in the _if_config
if_name = find_if_config_by_npu_port(npu, port)
if if_name == None:
nas_if.log_err("No interface present for the npu " + str(npu) +
"and port " + str(port))
return
nas_if.log_info("if name is " + str(if_name))
config = _if_config[if_name]
config.set_media_type(media_type)
obj.add_attr(ifname_attr_name, if_name)
# set the default speed if the speed is configured to auto it is in non-breakout mode
if config.get_breakout_mode() == _yang_breakout_1x1 and config.get_speed(
) == _yang_auto_speed:
_add_default_speed(media_type, obj)
if config.get_negotiation() == _yang_auto_neg:
_add_default_autoneg(media_type, obj)
if config.get_duplex() == _yang_auto_dup:
_add_default_duplex(media_type, obj)
nas_if.log_info("media type setting is successful for " + str(if_name))
config.show()
def _add_default_autoneg(media_type, cps_obj):
# fetch default autoneg
autoneg = media.get_default_media_setting(media_type, 'autoneg')
if autoneg == None:
return
nas_if.log_info("default autoneg is " + str(autoneg))
cps_obj.add_attr(autoneg_attr_name, autoneg)
def get_remote_endpoint_list(cps_obj):
"""Method to retrive a list of remote endpoints from the CPS object"""
rlist = {}
remote_endpoints = __read_attr(cps_obj, REMOTE_ENDPOINT_LIST)
if remote_endpoints is not None:
for name in remote_endpoints:
ip = None
addr_family = None
flooding_enabled = 1
try:
endpoint = remote_endpoints[name]
nas_if.log_info(" remote endpoint %s" % (str(remote_endpoints)))
addr_family = endpoint[REMOTE_ENDPOINT_ADDR_FAMILY]
if addr_family is None:
return False, rlist
ip = None
if addr_family is socket.AF_INET:
ip_ba = ba.hex_to_ba('ipv4', endpoint[REMOTE_ENDPOINT_IP_ADDR])
ip = ba.ba_to_ipv4str('ipv4', ip_ba)
else:
ip_ba = ba.hex_to_ba('ipv6', endpoint[REMOTE_ENDPOINT_IP_ADDR])
ip = ba.ba_to_ipv6str('ipv6', ip_ba)
if REMOTE_ENDPOINT_FLOODING_ENABLED in endpoint:
flooding_enabled = endpoint[REMOTE_ENDPOINT_FLOODING_ENABLED]
except ValueError:
logging.exception('error:')
nas_if.log_err("Failed to read attr of remote endpoint")
pass
if ip is None or addr_family is None or flooding_enabled is None:
return False, rlist
rlist[ip] = RemoteEndpoint(ip, addr_family, flooding_enabled)
return True, rlist
def create_loopback_interface(obj, params):
name = None
mac_str = None
mac = None
try:
name = obj.get_attr_data('if/interfaces/interface/name')
mac_str = obj.get_attr_data(
'dell-if/if/interfaces/interface/phys-address')
except:
pass
if name is None:
nas_if.log_err("Failed to create interface without name")
return False
nas_if.log_info("interface name is" + str(name))
lst = dn_base_ip_tool.get_if_details(name)
if (len(lst)) > 0:
nas_if.log_err("Interface already exists" + str(name))
return False
if mac_str is None:
mac_str = ma.get_offset_mac_addr(ma.get_base_mac_addr(), 0)
rc = dn_base_ip_tool.create_loopback_if(name, mac=mac_str)
if rc:
nas_if.log_info("loopback interface is created" + str(name))
rc = set_loopback_interface(obj)
if_index = ifindex_utils.if_nametoindex(name)
obj.add_attr(nas_comm.yang.get_value('if_index', 'attr_name'),
if_index)
params['change'] = obj.get()
return rc
def set_macvlan_interface(obj):
data = obj.get()['data']
nas_if.log_info("data = " + str(data))
vrf = 'default'
if if_name not in data:
nas_if.log_err("Missing Maclvan interface name")
return False
name = obj.get_attr_data(if_name)
if name is None:
nas_if.log_err("Empty Macvlan interface name")
if vrf_name in data:
vrf = obj.get_attr_data(vrf_name)
if physical_addr in data:
mac_addr = obj.get_attr_data(physical_addr)
if dn_base_ip_tool.set_if_mac(name, mac_addr, vrf) == False:
nas_if.log_err("Failed to set MAC address for " + str(name))
return False
if if_state in data:
state = obj.get_attr_data(if_state)
if dn_base_ip_tool.set_if_state(name, state, vrf) == False:
nas_if.log_err("Failed to set the interface state for " + str(name))
return False
return True
def _set_fec_mode(fec_mode, config, obj, op):
if_cfg_speed = config.get_cfg_speed()
if fec_mode != None:
if not nas_comm.is_fec_supported(fec_mode, if_cfg_speed):
_str_err = ('FEC mode %s is not supported with speed %s'
%(nas_comm.get_value(nas_comm.fec_mode_to_yang,fec_mode),
nas_comm.get_value(nas_comm.yang_to_mbps_speed,if_cfg_speed)))
nas_if.log_err(_str_err)
obj.set_error_string(1,_str_err)
return False
else:
if (op == 'create' and
nas_comm.is_fec_supported(nas_comm.get_value(nas_comm.yang_fec_mode, 'AUTO'), if_cfg_speed)):
# set default FEC mode as auto to newly created interface
fec_mode = nas_comm.get_value(nas_comm.yang_fec_mode, 'AUTO')
else:
return True
nas_if.log_info('set FEC mode %d' % fec_mode)
config.set_fec_mode(fec_mode)
if fec_mode == nas_comm.get_value(nas_comm.yang_fec_mode, 'AUTO'):
media_type = config.get_media_type()
fec_mode = _get_default_fec_mode(media_type,if_cfg_speed)
obj.add_attr(fec_mode_attr_name, fec_mode)
return True
def _gen_npu_lanes(obj, resp):
for npu in fp.get_npu_list():
key_dict = {_lane_attr('npu-id'): npu.id}
if not obj.key_compare(key_dict):
continue
for p in npu.ports:
port = npu.ports[p]
for h in port.hwports:
if not obj.key_compare({_lane_attr('hw-port'): h}):
continue
elem = cps_object.CPSObject(module='base-if-phy/hardware-port',
data={
'npu-id':
npu.id,
'hw-port':
h,
'front-panel-port':
port.id,
'hw-control-port':
port.control_port(),
'subport-id':
port.lane(h),
'fanout-mode':
port.get_breakout_mode()
})
nas_if.log_info(str(elem.get()))
resp.append(elem.get())
def set_media_transceiver(interface_obj):
# get front panel port from ifindex
if_obj = cps_object.CPSObject(obj=interface_obj)
npu = if_obj.get_attr_data('base-if-phy/if/interfaces/interface/npu-id')
port = if_obj.get_attr_data('base-if-phy/if/interfaces/interface/port-id')
enable = if_obj.get_attr_data('if/interfaces/interface/enabled')
nas_if.log_info("set_media_transceiver as " + str(enable) + " for " +
str(npu) + " , " + str(port))
port_list = nas_if.nas_os_phy_list(d={'npu-id': npu, 'port-id': port})
phy_obj = cps_object.CPSObject(obj=port_list[0])
try:
hwport_list = phy_obj.get_attr_data('hardware-port-list')
except:
nas_if.log_err(" Error in setting media Transceiver for %s" %
if_obj.get_attr_data('name'))
return
# set media transceiver using media Id and channel ID
#
for hwport in hwport_list:
fp_details = fp.find_port_by_hwport(npu, hwport)
if fp_details.port_group_id is None:
_lane = fp_details.lane
else:
pg_list = fp.get_port_group_list()
pg_obj = pg_list[fp_details.port_group_id]
if ((pg_obj.get_profile_type()) == "ethernet_ddqsfp28"):
_lane = pg_obj.get_lane(hwport)
else:
_lane = fp_details.lane
media.media_transceiver_set(1, fp_details.media_id, _lane, enable)
def _add_default_speed(media_type, cps_obj):
# fetch default speed
speed = media.get_default_media_setting(media_type, 'speed')
if speed == None:
return
cps_obj.add_attr(speed_attr_name, speed)
nas_if.log_info("default speed is " + str(speed))
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_and_add_fp_caps(fp_port, resp):
br_modes = fp_port.get_breakout_caps()
hw_speeds = fp_port.get_hwport_speed_caps()
hwp_count = len(fp_port.get_hwports())
phy_mode = nas_comm.yang.get_value(
'ether', 'yang-phy-mode'
) # FP port does not support FC capability directly. it is on the port group
for mode in br_modes:
skip_ports = nas_comm.yang.get_tbl('breakout-to-skip-port')[mode]
for speed in hw_speeds:
phy_speed = fp.get_phy_npu_port_speed(mode, speed * hwp_count)
if fp.verify_npu_supported_speed(phy_speed) == False:
nas_if.log_info(
"create_and_add_fp_caps: fp port %s doesn't support yang speed %s "
% (str(fp_port.id), str(phy_speed)))
# breakout mode and this speed is excluded from cps show
continue
cps_obj = cps_object.CPSObject(
module='base-if-phy/front-panel-port/br-cap',
qual='target',
data={
_fp_attr('br-cap/phy-mode'): phy_mode,
_fp_attr('br-cap/breakout-mode'): mode,
_fp_attr('br-cap/port-speed'): phy_speed,
_fp_attr('br-cap/skip-ports'): skip_ports,
_fp_attr('front-panel-port'): fp_port.id
})
resp.append(cps_obj.get())
cps_obj = None
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 create_macvlan_interface(obj):
data = obj.get()['data']
nas_if.log_info("data = " + str(data))
vrf = 'default'
#Check if attributes are present in the object or not
if if_name not in data or parent_interface not in data or physical_addr not in data:
nas_if.log_err("Missing Macvlan interface, or parent interface or mac address attribute")
return False
if vrf_name in data:
vrf = obj.get_attr_data(vrf_name)
#Get the attribute data
name = obj.get_attr_data(if_name)
parent_if = obj.get_attr_data(parent_interface)
mac_addr = obj.get_attr_data(physical_addr)
#Check if the attributes are empty strings or not
if name is None or parent_if is None or mac_addr is None:
nas_if.log_err("Empty Maclvan interface, or parent interface, or mac address")
return False
# Check if interface already exists
lst = dn_base_ip_tool.get_if_details(vrf, name)
if (len(lst)) > 0:
nas_if.log_err("Interface " + str(name) + " already exists")
return False
rc = dn_base_ip_tool.create_macvlan_if(name, parent_if, mac_addr, vrf)
if rc:
nas_if.log_info("Macvlan interface " + str(name) + " is created")
rc = set_macvlan_interface(obj)
return rc
def nas_set_media_type_by_media_id(slot, media_id, media_type):
l = []
port_list = []
o = cps_object.CPSObject(module='base-if-phy/front-panel-port',
data={'media-id': media_id})
cps.get([o.get()], l)
if len(l) == 0:
nas_if.log_err("No such port found... for medial " + str(media_id))
return
#fetching 2 front panel port object from 1 phy media id for QSFP28-DD ports
for fp_obj in l:
obj = cps_object.CPSObject(obj=fp_obj)
if _fp_port_key == obj.get_key():
port_list = port_list + nas_if.physical_ports_for_front_panel_port(
obj)
if len(port_list) == 0:
nas_if.log_err("There are no physical ports for front panel port ")
nas_if.log_err(l[0])
return
for port in port_list:
nas_if.log_info(" port id : " + str(port.get_attr_data('port-id')) +
". media type: " + str(media_type))
port.add_attr('phy-media', media_type)
ch = {'operation': 'set', 'change': port.get()}
cps.transaction([ch])
def get_setting(self, cps_obj):
val = _get_setting(cps_obj, 'fec', 'override')
if val is None:
val = _get_setting(cps_obj, 'fec', 'default')
nas_if.log_info('Default Media FEC: ' +
str(nas_comm.yang.get_key(val, 'yang-fec')))
return val
def __delete_vlan_sub_if(parent_intf, vlan_id):
"""Method to delete VLAN SubInterface in Linux"""
vlan_subintf_name = str(parent_intf) + '.' + str(vlan_id)
if dn_base_ip_tool.delete_if(vlan_subintf_name) is False:
nas_if.log_err("Failed to delete VLAN SubInterface for " + str(vlan_subintf_name))
return False
nas_if.log_info("Successfully deleted VLAN SubInterface " + str(vlan_subintf_name))
return True
def set_media_info(pas_media_obj):
slot = pas_media_obj.get_attr_data('slot')
media_id = pas_media_obj.get_attr_data('port')
media_type = pas_media_obj.get_attr_data('type')
# PAS sends slot # 1 based but for NAS slot number is 0 based
nas_set_media_type_by_media_id((slot - 1), media_id, media_type)
nas_if.log_info("setting media id: " + str(media_id) + " media type: " +
str(media_type))
def __delete_br_if(br_name):
"""Method to delete bridge interface in Linux"""
if __if_present(br_name) is True and \
dn_base_br_tool.del_br(br_name) is False:
nas_if.log_err("Failed to delete Bridge Interface " + str(br_name))
return False
nas_if.log_info("Successfully deleted Bridge Interface " + str(br_name))
return True
def __create_vlan_sub_if(parent_intf, vlan_id):
"""Method to create VLAN SubInterface in Linux"""
vlan_subintf_name = str(parent_intf) + '.' + str(vlan_id)
if dn_base_ip_tool.configure_vlan_tag(parent_intf, vlan_id) is False:
nas_if.log_err("Failed to configure VLAN tag for " + str(vlan_subintf_name))
return False
nas_if.log_info("Successfully created VLAN SubInterface " + str(vlan_subintf_name))
return True
def if_media_type_set(pas_media_obj):
try:
media_id = pas_media_obj.get_attr_data('port')
media_type = pas_media_obj.get_attr_data('type')
except:
nas_if.log_err(
"media Id or media type is not present in the media event")
return
# fetch FP info from media ID
l = nas_if.nas_os_fp_list(d={'media-id': media_id})
if len(l) == 0:
nas_if.log_err("No such port found... for media " + str(media_id))
return
# fetch PHY port list for the FP port
port_list = nas_if.physical_ports_for_front_panel_port(
cps_object.CPSObject(obj=l[0]))
if len(port_list) == 0:
nas_if.log_err("There are no physical ports for front panel port ")
nas_if.log_err(l[0])
return
# create interface set RPC obj for each phy port in the list and send it
for p in port_list:
npu = p.get_attr_data('npu-id')
port = p.get_attr_data('port-id')
fanout = p.get_attr_data('fanout-mode')
hwport = p.get_attr_data('hardware-port-id')
nas_if.log_info("send if rpc for media id set for phy port " +
str(port))
ifobj = cps_object.CPSObject(
module='dell-base-if-cmn/set-interface',
data={
'dell-base-if-cmn/set-interface/input/operation': 3,
'base-if-phy/if/interfaces/interface/npu-id': npu,
'base-if-phy/if/interfaces/interface/port-id': port,
'base-if-phy/if/interfaces/interface/phy-media': media_type,
'if/interfaces/interface/type': "ianaift:ethernetCsmacd"
})
ch = {'operation': 'rpc', 'change': ifobj.get()}
cps.transaction([ch])
if_name = ba.ba_to_str(
ch['change']['data']['if/interfaces/interface/name'],
len(_if_name))
if_details = nas_if.nas_os_if_list(
d={'if/interfaces/interface/name': if_name})
enable = ba.from_ba(
if_details[0]['data']['if/interfaces/interface/enabled'],
"uint64_t")
fp_details = fp.find_port_by_hwport(npu, hwport)
if fanout == 2: # then it is in 4x10G fanout mode BASE_PORT_BREAKOUT_MODE_BREAKOUT_4X1
_lane = fp_details.lane
else: # non-fanout mode 1x40g mode
_lane = None # enable/disable all channels. Do not pass Lane #
media_transceiver_set(1, fp_details.media_id, _lane, enable)
nas_if.log_info("setting media id: " + str(media_id) + " media type: " +
str(media_type))
def get_key(self, key, tbl):
global yang_values
if tbl not in yang_values:
nas_if.log_info('No yang table ' + str(tbl))
return None
tbl = self.inv(yang_values[tbl])
if key in tbl:
return tbl[key]
return None
def get_hg_state_hdlr(methods, params):
'''CPS Get Handler for Hybrid Group State'''
ret = False
try:
nas_if.log_info("CPS Get Handler for Hybrid Group State Invoked")
ret = _get_hg_state_hdlr(methods, params)
except:
logging.exception('Error: CPS Get for Hybrid Group State Failed')
return ret
def set_hg_hdlr(methods, params):
'''CPS Set Handler for Hybrid Group'''
ret = False
try:
nas_if.log_info("CPS Set Handler for Hybrid Group Invoked")
ret = _set_hg_hdlr(methods, params)
except:
logging.exception('Error: CPS Set for Hybrid Group Failed')
return ret
def _set_duplex(duplex, config, obj):
nas_if.log_info("duplex is " + str(duplex))
config.set_duplex(duplex)
if duplex == _yang_auto_dup:
media_type = config.get_media_type()
_add_default_duplex(media_type, obj)
else:
obj.add_attr(duplex_attr_name, duplex)
return
def show(self):
nas_if.log_info("Name " + str(self.name))
if self.speed != None:
nas_if.log_info("speed " + str(self.speed))
if self.autoneg != None:
nas_if.log_info("autoneg " + str(self.autoneg))
if self.duplex != None:
nas_if.log_info("duplex " + str(self.duplex))
nas_if.log_info("supported speed :" + str(self.supported_speed))
def __delete_vtep_if(vtep_name):
"""Method to delete vtep interface in Linux"""
if __if_present(vtep_name) is True and \
dn_base_ip_tool.delete_if(vtep_name):
nas_if.log_info("Successfully deleted VTEP Interface " +
str(vtep_name))
return True
nas_if.log_err("Failed to delete VTEP Interface " + str(vtep_name))
return False
