/** * Returns OpenstackPort object for the Port reference given. * * @param port Port object * @return OpenstackPort reference, or null when not found */ public OpenstackPort openstackPort(Port port) { String uuid = port.annotations().value(PORT_NAME).substring(3); return openstackPortList.stream().filter(p -> p.id().startsWith(uuid)) .findAny().orElse(null); }
@Override public OpenstackPort port(Port port) { String uuid = port.annotations().value(PORT_NAME).substring(3); return getPorts().stream() .filter(p -> p.id().startsWith(uuid)) .findAny().orElse(null); }
private PortNumber getTunnelPort(DeviceId deviceId) { Port port = deviceService.getPorts(deviceId).stream() .filter(p -> p.annotations().value(PORT_NAME).equals( OpenstackSwitchingManager.PORTNAME_PREFIX_TUNNEL)) .findAny().orElse(null); if (port == null) { log.error("No TunnelPort was created."); return null; } return port.number(); }
public static Optional<OduCltPort> asOduCltPort(Port port) { if (port instanceof OduCltPort) { return Optional.of((OduCltPort) port); } try { Annotations an = port.annotations(); CltSignalType signalType = Enum.valueOf(CltSignalType.class, an.value(SIGNAL_TYPE)); // Note: ODU specific annotations is not filtered-out here. // DefaultOduCltPort should filter them, if necessary. return Optional.of(new DefaultOduCltPort(port, signalType)); } catch (NullPointerException | IllegalArgumentException e) { log.warn("{} was not well-formed OduClt port.", port, e); return Optional.empty(); } }
public static Optional<OtuPort> asOtuPort(Port port) { if (port instanceof OtuPort) { return Optional.of((OtuPort) port); } try { Annotations an = port.annotations(); OtuSignalType signalType = Enum.valueOf(OtuSignalType.class, an.value(SIGNAL_TYPE)); // Note: OTU specific annotations is not filtered-out here. // DefaultOtuPort should filter them, if necessary. return Optional.of(new DefaultOtuPort(port, signalType)); } catch (NullPointerException | IllegalArgumentException e) { log.warn("{} was not well-formed Otu port.", port, e); return Optional.empty(); } }
private PortNumber getVxlanPortNumber(DeviceId deviceId) { Iterable<Port> ports = deviceService.getPorts(deviceId); Port vxlanPort = Sets.newHashSet(ports).stream() .filter(p ->!p.number().equals(PortNumber.LOCAL)) .filter(p ->p.annotations().value(AnnotationKeys.PORT_NAME) .startsWith(VXLANPORT_HEAD)) .findFirst().get(); return vxlanPort.number(); } }
/** * Get local tunnel ports. * * @param ports Iterable of Port * @return Collection of PortNumber */ public static Collection<PortNumber> getLocalTunnelPorts(Iterable<Port> ports) { Collection<PortNumber> localTunnelPorts = new ArrayList<>(); Sets.newHashSet(ports).stream() .filter(p -> !p.number().equals(PortNumber.LOCAL)) .forEach(p -> { if (p.annotations().value(AnnotationKeys.PORT_NAME) .startsWith(PORT_HEAD)) { localTunnelPorts.add(p.number()); } }); return localTunnelPorts; }
/** * Checks if there is any port remained with same vni at the device, on which the removed VM was run. * * @param removedPort removedport info * @param deviceId device id on which removed VM was run * @param vni vni which removed VM was belonged * @param openstackPortInfoMap openstackPortInfoMap * @return true if there is, false otherwise */ private boolean checkIfAnyPortRemainedInSameCnode(Port removedPort, DeviceId deviceId, long vni, Map<String, OpenstackPortInfo> openstackPortInfoMap) { for (Map.Entry<String, OpenstackPortInfo> entry : openstackPortInfoMap.entrySet()) { if (!removedPort.annotations().value(PORT_NAME).equals(entry.getKey())) { if (entry.getValue().vni() == vni && entry.getValue().deviceId().equals(deviceId)) { return true; } } } return false; }
private String getPortStatStr(PortStatistics stat, Port port) { final String portName = port.annotations().value(AnnotationKeys.PORT_NAME); return String.format("port: %s(%s), ", stat.portNumber(), portName) + String.format("enabled: %b, ", port.isEnabled()) + String.format("pktRx: %d, ", stat.packetsReceived()) + String.format("pktTx: %d, ", stat.packetsSent()) + String.format("pktRxErr: %d, ", stat.packetsRxErrors()) + String.format("pktTxErr: %d, ", stat.packetsTxErrors()) + String.format("pktRxDrp: %d, ", stat.packetsRxDropped()) + String.format("pktTxDrp: %d", stat.packetsTxDropped()); }
public static Optional<OmsPort> asOmsPort(Port port) { if (port instanceof OmsPort) { return Optional.of((OmsPort) port); } try { Annotations an = port.annotations(); Frequency minFrequency = Frequency.ofHz(Long.parseLong(an.value(OpticalAnnotations.MIN_FREQ_HZ))); Frequency maxFrequency = Frequency.ofHz(Long.parseLong(an.value(OpticalAnnotations.MAX_FREQ_HZ))); Frequency grid = Frequency.ofHz(Long.parseLong(an.value(OpticalAnnotations.GRID_HZ))); return Optional.of(new DefaultOmsPort(port, minFrequency, maxFrequency, grid)); } catch (NumberFormatException e) { log.warn("{} was not well-formed OMS port.", port, e); return Optional.empty(); } }
/** * Populates the flow rules for traffic to VMs in the same Cnode as the sender. * * @param device device to put the rules * @param port port info of the VM */ private void populateFlowRulesForTrafficToSameCnode(Device device, Port port) { Ip4Address vmIp = getFixedIpAddressForPort(port.annotations().value(PORT_NAME)); String portName = port.annotations().value(PORT_NAME); String vni = getVniForPort(portName); if (vmIp != null) { setFlowRuleForVMsInSameCnode(vmIp, device.id(), port, vni); } }
private Port getExPort(DeviceId deviceId) { List<Port> ports = deviceService.getPorts(deviceId); Port exPort = null; for (Port port : ports) { String portName = port.annotations().value(AnnotationKeys.PORT_NAME); Versioned<String> exPortVersioned = exPortMap.get(EX_PORT_KEY); if (portName != null && exPortVersioned != null && portName. equals(exPortVersioned.value())) { exPort = port; break; } } return exPort; }
public boolean isSuppressed(Port port) { Element parent = port.element(); if (parent instanceof Device) { if (isSuppressed((Device) parent)) { return true; } } final Annotations annotations = port.annotations(); if (containsSuppressionAnnotation(annotations)) { return true; } return false; }
/** * Populate the flow rules for tagging tunnelId according to which inport is came from. * * @param device device to put the rules * @param port port info of the VM */ private void populateFlowRulesForTunnelTag(Device device, Port port) { Ip4Address vmIp = getFixedIpAddressForPort(port.annotations().value(PORT_NAME)); String portName = port.annotations().value(PORT_NAME); String vni = getVniForPort(portName); if (vmIp != null) { setFlowRuleForTunnelTag(device.id(), port, vni); } }
private DeviceEvent updatePort(Device device, Port oldPort, Port newPort, Map<PortNumber, Port> ports) { if (oldPort.isEnabled() != newPort.isEnabled() || oldPort.type() != newPort.type() || oldPort.portSpeed() != newPort.portSpeed() || !AnnotationsUtil.isEqual(oldPort.annotations(), newPort.annotations())) { ports.put(oldPort.number(), newPort); return new DeviceEvent(PORT_UPDATED, device, newPort); } return null; }
private void printPort(Port port) { String portName = portName(port.number()); Object portIsEnabled = port.isEnabled() ? "enabled" : "disabled"; String portType = port.type().toString().toLowerCase(); String annotations = annotations(port.annotations()); print(FMT, portName, portIsEnabled, portType, port.portSpeed(), annotations); }
protected void printPorts(DeviceService service, Device device) { List<Port> ports = new ArrayList<>(service.getPorts(device.id())); Collections.sort(ports, Comparators.PORT_COMPARATOR); for (Port port : ports) { if (!isIncluded(port)) { continue; } String portName = port.number().toString(); Object portIsEnabled = port.isEnabled() ? "enabled" : "disabled"; String portType = port.type().toString().toLowerCase(); String annotations = annotations(port.annotations()); print(FMT, portName, portIsEnabled, portType, port.portSpeed(), annotations); } } }
/** * Remove flows rules for the removed VM. * * @param removedPort removedport info * @param openstackPortInfoMap openstackPortInfoMap */ public void removeSwitchingRules(Port removedPort, Map<String, OpenstackPortInfo> openstackPortInfoMap) { OpenstackPortInfo openstackPortInfo = openstackPortInfoMap .get(removedPort.annotations().value(PORT_NAME)); DeviceId deviceId = openstackPortInfo.deviceId(); Ip4Address vmIp = openstackPortInfo.ip(); PortNumber portNumber = removedPort.number(); long vni = openstackPortInfo.vni(); removeFlowRuleForTunnelTag(deviceId, portNumber); removeFlowRuleForVMsInSameCnode(deviceId, vmIp, vni); removeFlowRuleForVMsInDiffrentCnode(removedPort, deviceId, vmIp, vni, openstackPortInfoMap); }
private ConnectPoint staticPort(ConnectPoint connectPoint) { Port port = deviceService.getPort(connectPoint.deviceId(), connectPoint.port()); String staticPort = port.annotations().value(AnnotationKeys.STATIC_PORT); // FIXME: need a better way to match the port if (staticPort != null) { for (Port p : deviceService.getPorts(connectPoint.deviceId())) { if (staticPort.equals(p.number().name())) { return new ConnectPoint(p.element().id(), p.number()); } } } return null; }
private ConnectPoint staticPort(ConnectPoint connectPoint) { Port port = deviceService.getPort(connectPoint.deviceId(), connectPoint.port()); String staticPort = port.annotations().value(AnnotationKeys.STATIC_PORT); // FIXME: need a better way to match the port if (staticPort != null) { for (Port p : deviceService.getPorts(connectPoint.deviceId())) { if (staticPort.equals(p.number().name())) { return new ConnectPoint(p.element().id(), p.number()); } } } return null; }