drivers/arista/src/main/java/org/onosproject/drivers/arista/LinkDiscoveryAristaImpl.java - onos - Gitiles

 /*
  * Copyright 2018-present Open Networking Foundation
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
  * You may obtain a copy of the License at
  *
  *     http://www.apache.org/licenses/LICENSE-2.0
  *
  * Unless required by applicable law or agreed to in writing, software
  * distributed under the License is distributed on an "AS IS" BASIS,
  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
 package org.onosproject.drivers.arista;


 import com.fasterxml.jackson.databind.JsonNode;
 import com.google.common.base.Supplier;
 import com.google.common.collect.Sets;
 import org.onlab.packet.MacAddress;
 import org.onlab.util.Tools;
 import org.onosproject.net.AnnotationKeys;
 import org.onosproject.net.ConnectPoint;
 import org.onosproject.net.DefaultAnnotations;
 import org.onosproject.net.DefaultPort;
 import org.onosproject.net.Device;
 import org.onosproject.net.DeviceId;
 import org.onosproject.net.Link;
 import org.onosproject.net.Port;
 import org.onosproject.net.PortNumber;
 import org.onosproject.net.behaviour.LinkDiscovery;
 import org.onosproject.net.device.DeviceService;
 import org.onosproject.net.driver.AbstractHandlerBehaviour;
 import org.onosproject.net.driver.DriverHandler;
 import org.onosproject.net.link.DefaultLinkDescription;
 import org.onosproject.net.link.LinkDescription;
 import org.slf4j.Logger;

 import java.util.Iterator;
 import java.util.List;
 import java.util.Map;
 import java.util.Objects;
 import java.util.Optional;
 import java.util.Set;
 import java.util.stream.Stream;
 import java.util.stream.StreamSupport;

 import static com.google.common.base.Preconditions.checkNotNull;
 import static org.slf4j.LoggerFactory.getLogger;

 public class LinkDiscoveryAristaImpl extends AbstractHandlerBehaviour implements LinkDiscovery {

     private static final String SHOW_LLDP_NEIGHBOR_DETAIL_CMD = "show lldp neighbors detail";
     private static final String LLDP_NEIGHBORS = "lldpNeighbors";
     private static final String LLDP_NEIGHBOR_INFO = "lldpNeighborInfo";
     private static final String CHASSIS_ID = "chassisId";
     private static final String PORT_ID = "interfaceDescription";
     private static final String CHASSIS_ID_TYPE = "chassisIdType";
     private static final String CHASSIS_ID_TYPE_MAC = "macAddress";

     private final Logger log = getLogger(getClass());

     @Override
     public Set<LinkDescription> getLinks() {
         return createLinksDescs(AristaUtils.retrieveCommandResult(handler(), SHOW_LLDP_NEIGHBOR_DETAIL_CMD));
     }

     private Set<LinkDescription> createLinksDescs(Optional<JsonNode> response) {
         DriverHandler handler = checkNotNull(handler());
         DeviceId localDeviceId = checkNotNull(handler.data().deviceId());
         DeviceService deviceService = handler.get(DeviceService.class);
         Set<LinkDescription> linkDescriptions = Sets.newHashSet();
         List<Port> ports = deviceService.getPorts(localDeviceId);

         if (ports.isEmpty() || Objects.isNull(response)) {
             return linkDescriptions;
         }

         if (!response.isPresent()) {
             return linkDescriptions;
         }

         log.debug("response: {}, {}", response, localDeviceId.toString());

         JsonNode res = response.get();

         if (res == null) {
             log.warn("result is null");
             return linkDescriptions;
         }

         JsonNode lldpNeighbors = res.findValue(LLDP_NEIGHBORS);

         if (lldpNeighbors == null) {
             log.warn("{} is null", LLDP_NEIGHBORS);
             return linkDescriptions;
         }

         Iterator<Map.Entry<String, JsonNode>> lldpNeighborsIter = lldpNeighbors.fields();

         while (lldpNeighborsIter.hasNext()) {
             Map.Entry<String, JsonNode> neighbor = lldpNeighborsIter.next();
             String lldpLocalPort = neighbor.getKey();
             JsonNode neighborValue = neighbor.getValue();

             log.debug("lldpLocalPort: {}", lldpLocalPort);
             log.debug("neighborValue: {}", neighborValue.toString());

             if (lldpLocalPort.isEmpty()) {
                 continue;
             }

             JsonNode neighborInfo = neighborValue.findValue(LLDP_NEIGHBOR_INFO);

             if (neighborInfo == null) {
                 log.warn("{} is null", LLDP_NEIGHBOR_INFO);
                 continue;
             }

             Iterator<JsonNode> neighborInfoIter = neighborInfo.elements();

             while (neighborInfoIter.hasNext()) {
                 JsonNode info = neighborInfoIter.next();
                 String chassisIdType = info.get(CHASSIS_ID_TYPE).asText("");

                 if (chassisIdType == null) {
                     log.warn("{} is null", CHASSIS_ID_TYPE);
                     continue;
                 }

                 if (!chassisIdType.equals(CHASSIS_ID_TYPE_MAC)) {
                     log.warn("{} is not mac: {}", CHASSIS_ID_TYPE_MAC, chassisIdType);
                     continue;
                 }

                 JsonNode remotePortNameNode = info.findValue(PORT_ID);

                 if (remotePortNameNode == null) {
                     continue;
                 }

                 String remoteChassisId = info.get(CHASSIS_ID).asText("");
                 String remotePortName = remotePortNameNode.asText("");

                 log.debug("{}: {}, {}: {}", CHASSIS_ID, remoteChassisId, PORT_ID, remotePortName);

                 Optional<Port> localPort = findLocalPortByName(ports, lldpLocalPort);

                 if (!localPort.isPresent()) {
                     log.warn("local port not found. lldpLocalPort value: {}", lldpLocalPort);
                     continue;
                 }

                 Optional<Device> remoteDevice = findRemoteDeviceByChassisId(deviceService, remoteChassisId);

                 if (!remoteDevice.isPresent()) {
                     log.warn("remote device not found. remoteChassisId value: {}", remoteChassisId);
                     continue;
                 }

                 Optional<Port> remotePort = findDestinationPortByName(
                         remotePortName,
                         deviceService,
                         remoteDevice.get());

                 if (!remotePort.isPresent()) {
                     log.warn("remote port not found. remotePortName value: {}", remotePortName);
                     continue;
                 }

                 if (!localPort.get().isEnabled() || !remotePort.get().isEnabled()) {
                     log.debug("Ports are disabled. Cannot create a link between {}/{} and {}/{}",
                             localDeviceId, localPort.get(), remoteDevice.get().id(), remotePort.get());
                     continue;
                 }

                 linkDescriptions
                         .addAll(buildLinkPair(localDeviceId, localPort.get(),
                                 remoteDevice.get().id(), remotePort.get()));
             }
         }

         log.debug("returning linkDescriptions: {}", linkDescriptions);

         return linkDescriptions;
     }

     private Optional<Port> findLocalPortByName(List<Port> ports, String lldpLocalPort) {
         Optional<Port> localPort = ports.stream()
                 .filter(port -> lldpLocalPort.equalsIgnoreCase(port.annotations().value(AnnotationKeys.PORT_NAME)))
                 .findAny();

         if (!localPort.isPresent()) {
             localPort = ports.stream()
                     .filter(port -> lldpLocalPort.equalsIgnoreCase(port.annotations().value(AnnotationKeys.NAME)))
                     .findAny();

             if (!localPort.isPresent()) {
                 return Optional.empty();
             }
         }

         return localPort;
     }

     private Optional<Device> findRemoteDeviceByChassisId(DeviceService deviceService, String remoteChassisIdString) {
         String forMacTmp = remoteChassisIdString
                 .replace(".", "")
                 .replaceAll("(.{2})", "$1:")
                 .trim()
                 .substring(0, 17);
         MacAddress mac = MacAddress.valueOf(forMacTmp);
         Supplier<Stream<Device>> deviceStream = () ->
                 StreamSupport.stream(deviceService.getAvailableDevices().spliterator(), false);
         Optional<Device> remoteDeviceOptional = deviceStream.get()
                 .filter(device -> device.chassisId() != null
                         && MacAddress.valueOf(device.chassisId().value()).equals(mac))
                 .findAny();

         if (remoteDeviceOptional.isPresent()) {
             log.debug("remoteDevice found by chassis id: {}", forMacTmp);
             return remoteDeviceOptional;
         } else {
             remoteDeviceOptional = deviceStream.get().filter(device ->
                 Tools.stream(deviceService.getPorts(device.id()))
                         .anyMatch(port -> port.annotations().keys().contains(AnnotationKeys.PORT_MAC)
                                 && MacAddress.valueOf(port.annotations().value(AnnotationKeys.PORT_MAC))
                         .equals(mac)))
                     .findAny();
             if (remoteDeviceOptional.isPresent()) {
                 log.debug("remoteDevice found by port mac: {}", forMacTmp);
                 return remoteDeviceOptional;
             } else {
                 return Optional.empty();
             }
         }
     }

     private Optional<Port> findDestinationPortByName(String remotePortName,
                                            DeviceService deviceService,
                                            Device remoteDevice) {
         Optional<Port> remotePort = deviceService.getPorts(remoteDevice.id())
                 .stream().filter(port -> remotePortName.equals(port.annotations().value(AnnotationKeys.PORT_NAME)))
                 .findAny();

         if (remotePort.isPresent()) {
             return remotePort;
         } else {
             int portNumber = Integer.valueOf(remotePortName.replaceAll("\\D+", ""));
             DefaultAnnotations.Builder annotations = DefaultAnnotations.builder()
                     .set(AnnotationKeys.PORT_NAME, remotePortName);

             return Optional.of(new DefaultPort(remoteDevice, PortNumber.portNumber(portNumber, remotePortName),
                     true,
                     annotations.build()));
         }
     }

     private static Set<LinkDescription> buildLinkPair(DeviceId localDevId,
                                                       Port localPort,
                                                       DeviceId remoteDevId,
                                                       Port remotePort) {

         Set<LinkDescription> linkDescriptions = Sets.newHashSet();
         ConnectPoint local = new ConnectPoint(localDevId, localPort.number());
         ConnectPoint remote = new ConnectPoint(remoteDevId, remotePort.number());
         DefaultAnnotations annotations = DefaultAnnotations.builder()
                 .set(AnnotationKeys.LAYER, "ETHERNET")
                 .build();

         linkDescriptions.add(new DefaultLinkDescription(
                 remote, local, Link.Type.DIRECT, true, annotations));

         return linkDescriptions;
     }
 }
	/*
	* Copyright 2018-present Open Networking Foundation
	*
	* Licensed under the Apache License, Version 2.0 (the "License");
	* you may not use this file except in compliance with the License.
	* You may obtain a copy of the License at
	*
	* http://www.apache.org/licenses/LICENSE-2.0
	*
	* Unless required by applicable law or agreed to in writing, software
	* distributed under the License is distributed on an "AS IS" BASIS,
	* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
	* See the License for the specific language governing permissions and
	* limitations under the License.
	*/
	package org.onosproject.drivers.arista;


	import com.fasterxml.jackson.databind.JsonNode;
	import com.google.common.base.Supplier;
	import com.google.common.collect.Sets;
	import org.onlab.packet.MacAddress;
	import org.onlab.util.Tools;
	import org.onosproject.net.AnnotationKeys;
	import org.onosproject.net.ConnectPoint;
	import org.onosproject.net.DefaultAnnotations;
	import org.onosproject.net.DefaultPort;
	import org.onosproject.net.Device;
	import org.onosproject.net.DeviceId;
	import org.onosproject.net.Link;
	import org.onosproject.net.Port;
	import org.onosproject.net.PortNumber;
	import org.onosproject.net.behaviour.LinkDiscovery;
	import org.onosproject.net.device.DeviceService;
	import org.onosproject.net.driver.AbstractHandlerBehaviour;
	import org.onosproject.net.driver.DriverHandler;
	import org.onosproject.net.link.DefaultLinkDescription;
	import org.onosproject.net.link.LinkDescription;
	import org.slf4j.Logger;

	import java.util.Iterator;
	import java.util.List;
	import java.util.Map;
	import java.util.Objects;
	import java.util.Optional;
	import java.util.Set;
	import java.util.stream.Stream;
	import java.util.stream.StreamSupport;

	import static com.google.common.base.Preconditions.checkNotNull;
	import static org.slf4j.LoggerFactory.getLogger;

	public class LinkDiscoveryAristaImpl extends AbstractHandlerBehaviour implements LinkDiscovery {

	private static final String SHOW_LLDP_NEIGHBOR_DETAIL_CMD = "show lldp neighbors detail";
	private static final String LLDP_NEIGHBORS = "lldpNeighbors";
	private static final String LLDP_NEIGHBOR_INFO = "lldpNeighborInfo";
	private static final String CHASSIS_ID = "chassisId";
	private static final String PORT_ID = "interfaceDescription";
	private static final String CHASSIS_ID_TYPE = "chassisIdType";
	private static final String CHASSIS_ID_TYPE_MAC = "macAddress";

	private final Logger log = getLogger(getClass());

	@Override
	public Set<LinkDescription> getLinks() {
	return createLinksDescs(AristaUtils.retrieveCommandResult(handler(), SHOW_LLDP_NEIGHBOR_DETAIL_CMD));
	}

	private Set<LinkDescription> createLinksDescs(Optional<JsonNode> response) {
	DriverHandler handler = checkNotNull(handler());
	DeviceId localDeviceId = checkNotNull(handler.data().deviceId());
	DeviceService deviceService = handler.get(DeviceService.class);
	Set<LinkDescription> linkDescriptions = Sets.newHashSet();
	List<Port> ports = deviceService.getPorts(localDeviceId);

	if (ports.isEmpty() \|\| Objects.isNull(response)) {
	return linkDescriptions;
	}

	if (!response.isPresent()) {
	return linkDescriptions;
	}

	log.debug("response: {}, {}", response, localDeviceId.toString());

	JsonNode res = response.get();

	if (res == null) {
	log.warn("result is null");
	return linkDescriptions;
	}

	JsonNode lldpNeighbors = res.findValue(LLDP_NEIGHBORS);

	if (lldpNeighbors == null) {
	log.warn("{} is null", LLDP_NEIGHBORS);
	return linkDescriptions;
	}

	Iterator<Map.Entry<String, JsonNode>> lldpNeighborsIter = lldpNeighbors.fields();

	while (lldpNeighborsIter.hasNext()) {
	Map.Entry<String, JsonNode> neighbor = lldpNeighborsIter.next();
	String lldpLocalPort = neighbor.getKey();
	JsonNode neighborValue = neighbor.getValue();

	log.debug("lldpLocalPort: {}", lldpLocalPort);
	log.debug("neighborValue: {}", neighborValue.toString());

	if (lldpLocalPort.isEmpty()) {
	continue;
	}

	JsonNode neighborInfo = neighborValue.findValue(LLDP_NEIGHBOR_INFO);

	if (neighborInfo == null) {
	log.warn("{} is null", LLDP_NEIGHBOR_INFO);
	continue;
	}

	Iterator<JsonNode> neighborInfoIter = neighborInfo.elements();

	while (neighborInfoIter.hasNext()) {
	JsonNode info = neighborInfoIter.next();
	String chassisIdType = info.get(CHASSIS_ID_TYPE).asText("");

	if (chassisIdType == null) {
	log.warn("{} is null", CHASSIS_ID_TYPE);
	continue;
	}

	if (!chassisIdType.equals(CHASSIS_ID_TYPE_MAC)) {
	log.warn("{} is not mac: {}", CHASSIS_ID_TYPE_MAC, chassisIdType);
	continue;
	}

	JsonNode remotePortNameNode = info.findValue(PORT_ID);

	if (remotePortNameNode == null) {
	continue;
	}

	String remoteChassisId = info.get(CHASSIS_ID).asText("");
	String remotePortName = remotePortNameNode.asText("");

	log.debug("{}: {}, {}: {}", CHASSIS_ID, remoteChassisId, PORT_ID, remotePortName);

	Optional<Port> localPort = findLocalPortByName(ports, lldpLocalPort);

	if (!localPort.isPresent()) {
	log.warn("local port not found. lldpLocalPort value: {}", lldpLocalPort);
	continue;
	}

	Optional<Device> remoteDevice = findRemoteDeviceByChassisId(deviceService, remoteChassisId);

	if (!remoteDevice.isPresent()) {
	log.warn("remote device not found. remoteChassisId value: {}", remoteChassisId);
	continue;
	}

	Optional<Port> remotePort = findDestinationPortByName(
	remotePortName,
	deviceService,
	remoteDevice.get());

	if (!remotePort.isPresent()) {
	log.warn("remote port not found. remotePortName value: {}", remotePortName);
	continue;
	}

	if (!localPort.get().isEnabled() \|\| !remotePort.get().isEnabled()) {
	log.debug("Ports are disabled. Cannot create a link between {}/{} and {}/{}",
	localDeviceId, localPort.get(), remoteDevice.get().id(), remotePort.get());
	continue;
	}

	linkDescriptions
	.addAll(buildLinkPair(localDeviceId, localPort.get(),
	remoteDevice.get().id(), remotePort.get()));
	}
	}

	log.debug("returning linkDescriptions: {}", linkDescriptions);

	return linkDescriptions;
	}

	private Optional<Port> findLocalPortByName(List<Port> ports, String lldpLocalPort) {
	Optional<Port> localPort = ports.stream()
	.filter(port -> lldpLocalPort.equalsIgnoreCase(port.annotations().value(AnnotationKeys.PORT_NAME)))
	.findAny();

	if (!localPort.isPresent()) {
	localPort = ports.stream()
	.filter(port -> lldpLocalPort.equalsIgnoreCase(port.annotations().value(AnnotationKeys.NAME)))
	.findAny();

	if (!localPort.isPresent()) {
	return Optional.empty();
	}
	}

	return localPort;
	}

	private Optional<Device> findRemoteDeviceByChassisId(DeviceService deviceService, String remoteChassisIdString) {
	String forMacTmp = remoteChassisIdString
	.replace(".", "")
	.replaceAll("(.{2})", "$1:")
	.trim()
	.substring(0, 17);
	MacAddress mac = MacAddress.valueOf(forMacTmp);
	Supplier<Stream<Device>> deviceStream = () ->
	StreamSupport.stream(deviceService.getAvailableDevices().spliterator(), false);
	Optional<Device> remoteDeviceOptional = deviceStream.get()
	.filter(device -> device.chassisId() != null
	&& MacAddress.valueOf(device.chassisId().value()).equals(mac))
	.findAny();

	if (remoteDeviceOptional.isPresent()) {
	log.debug("remoteDevice found by chassis id: {}", forMacTmp);
	return remoteDeviceOptional;
	} else {
	remoteDeviceOptional = deviceStream.get().filter(device ->
	Tools.stream(deviceService.getPorts(device.id()))
	.anyMatch(port -> port.annotations().keys().contains(AnnotationKeys.PORT_MAC)
	&& MacAddress.valueOf(port.annotations().value(AnnotationKeys.PORT_MAC))
	.equals(mac)))
	.findAny();
	if (remoteDeviceOptional.isPresent()) {
	log.debug("remoteDevice found by port mac: {}", forMacTmp);
	return remoteDeviceOptional;
	} else {
	return Optional.empty();
	}
	}
	}

	private Optional<Port> findDestinationPortByName(String remotePortName,
	DeviceService deviceService,
	Device remoteDevice) {
	Optional<Port> remotePort = deviceService.getPorts(remoteDevice.id())
	.stream().filter(port -> remotePortName.equals(port.annotations().value(AnnotationKeys.PORT_NAME)))
	.findAny();

	if (remotePort.isPresent()) {
	return remotePort;
	} else {
	int portNumber = Integer.valueOf(remotePortName.replaceAll("\\D+", ""));
	DefaultAnnotations.Builder annotations = DefaultAnnotations.builder()
	.set(AnnotationKeys.PORT_NAME, remotePortName);

	return Optional.of(new DefaultPort(remoteDevice, PortNumber.portNumber(portNumber, remotePortName),
	true,
	annotations.build()));
	}
	}

	private static Set<LinkDescription> buildLinkPair(DeviceId localDevId,
	Port localPort,
	DeviceId remoteDevId,
	Port remotePort) {

	Set<LinkDescription> linkDescriptions = Sets.newHashSet();
	ConnectPoint local = new ConnectPoint(localDevId, localPort.number());
	ConnectPoint remote = new ConnectPoint(remoteDevId, remotePort.number());
	DefaultAnnotations annotations = DefaultAnnotations.builder()
	.set(AnnotationKeys.LAYER, "ETHERNET")
	.build();

	linkDescriptions.add(new DefaultLinkDescription(
	remote, local, Link.Type.DIRECT, true, annotations));

	return linkDescriptions;
	}
	}