// Adds any missing device ports. private void addMissingPorts(Device device) { try { List<Port> ports = deviceService.getPorts(device.id()); Set<ConnectPoint> existing = ports .stream() .map(p -> new ConnectPoint(device.id(), p.number())) .collect(Collectors.toSet()); Set<ConnectPoint> missing = connectPoints .stream() .filter(cp -> cp.deviceId().equals(device.id())) .filter(cp -> !existing.contains(cp)) .collect(Collectors.toSet()); if (!missing.isEmpty()) { List<PortDescription> newPorts = Stream.concat( ports.stream().map(this::description), missing.stream().map(this::description)) .collect(Collectors.toList()); deviceProviderService.updatePorts(device.id(), newPorts); } } catch (IllegalArgumentException e) { log.warn("Error pushing ports: {}", e.getMessage()); } }
// Parses the given node with list of device ports. private void parsePorts(DeviceId deviceId, JsonNode nodes) { List<PortDescription> ports = new ArrayList<>(); for (JsonNode node : nodes) { ports.add(parsePort(node)); } deviceProviderService.updatePorts(deviceId, ports); }
private void updateOMSPorts(int numChls, ConnectPoint srcCp, ConnectPoint dstCp) { // round down to largest slot that allows numChl channels to fit into C band range ChannelSpacing chl = null; Frequency perChl = TOTAL.floorDivision(numChls); for (int i = 0; i < ChannelSpacing.values().length; i++) { Frequency val = ChannelSpacing.values()[i].frequency(); if (val.isLessThan(perChl)) { chl = ChannelSpacing.values()[i]; break; } } if (chl == null) { chl = ChannelSpacing.CHL_6P25GHZ; } // if true, there was less channels than can be tightly packed. Frequency grid = chl.frequency(); // say Linc's 1st slot starts at CENTER and goes up from there. Frequency min = CENTER.add(grid); Frequency max = CENTER.add(grid.multiply(numChls)); PortDescription srcPortDesc = new OmsPortDescription(srcCp.port(), true, min, max, grid); PortDescription dstPortDesc = new OmsPortDescription(dstCp.port(), true, min, max, grid); descriptions.put(srcCp, srcPortDesc); descriptions.put(dstCp, dstPortDesc); deviceProviderService.portStatusChanged(srcCp.deviceId(), srcPortDesc); deviceProviderService.portStatusChanged(dstCp.deviceId(), dstPortDesc); }
// uses 'bandwidth' annotation to determine the channel spacing. private void updateOchPort(double bw, ConnectPoint srcCp, ConnectPoint dstCp) { Device src = deviceService.getDevice(srcCp.deviceId()); Device dst = deviceService.getDevice(dstCp.deviceId()); // bandwidth in MHz (assuming Hz - linc is not clear if that or Mb). Frequency spacing = Frequency.ofMHz(bw); // channel bandwidth is smaller than smallest standard channel spacing. ChannelSpacing chsp = null; if (spacing.compareTo(ChannelSpacing.CHL_6P25GHZ.frequency()) <= 0) { chsp = ChannelSpacing.CHL_6P25GHZ; } for (int i = 1; i < ChannelSpacing.values().length; i++) { Frequency val = ChannelSpacing.values()[i].frequency(); // pick the next highest or equal channel interval. if (val.isLessThan(spacing)) { chsp = ChannelSpacing.values()[i - 1]; break; } } if (chsp == null) { log.warn("Invalid channel spacing ({}), can't configure port(s)", spacing); return; } OchSignal signal = new OchSignal(GridType.DWDM, chsp, 1, 1); if (src.type() == Device.Type.ROADM) { PortDescription portDesc = new OchPortDescription(srcCp.port(), true, OduSignalType.ODU4, true, signal); descriptions.put(srcCp, portDesc); deviceProviderService.portStatusChanged(srcCp.deviceId(), portDesc); } if (dst.type() == Device.Type.ROADM) { PortDescription portDesc = new OchPortDescription(dstCp.port(), true, OduSignalType.ODU4, true, signal); descriptions.put(dstCp, portDesc); deviceProviderService.portStatusChanged(dstCp.deviceId(), portDesc); } }
// Adds any missing device ports. private void addMissingPorts(Device device) { List<Port> ports = deviceService.getPorts(device.id()); Set<ConnectPoint> existing = ports .stream() .map(p -> new ConnectPoint(device.id(), p.number())) .collect(Collectors.toSet()); Set<ConnectPoint> missing = connectPoints.stream().filter(cp -> !existing.contains(cp)).collect(Collectors.toSet()); if (!missing.isEmpty()) { List<PortDescription> newPorts = Lists.newArrayList(); ports.forEach(p -> newPorts.add(description(p))); missing.forEach(cp -> newPorts.add(description(cp))); deviceProviderService.updatePorts(device.id(), newPorts); } }
// Parses the given node with device data and supplies the device. private void parseDevice(JsonNode node) { URI uri = URI.create(get(node, "uri")); Device.Type type = Device.Type.valueOf(get(node, "type", "SWITCH")); String mfr = get(node, "mfr", UNKNOWN); String hw = get(node, "hw", UNKNOWN); String sw = get(node, "sw", UNKNOWN); String serial = get(node, "serial", UNKNOWN); ChassisId cid = new ChassisId(get(node, "mac", "000000000000")); SparseAnnotations annotations = annotations(node.get("annotations")); DeviceDescription desc = new DefaultDeviceDescription(uri, type, mfr, hw, sw, serial, cid, annotations); DeviceId deviceId = deviceId(uri); deviceProviderService.deviceConnected(deviceId, desc); JsonNode ports = node.get("ports"); if (ports != null) { parsePorts(deviceId, ports); } }
private void deviceAdded(RestSBDevice nodeId) { Preconditions.checkNotNull(nodeId, ISNOTNULL); DeviceId deviceId = nodeId.deviceId(); ChassisId cid = new ChassisId(); String ipAddress = nodeId.ip().toString(); SparseAnnotations annotations = DefaultAnnotations.builder().set(IPADDRESS, ipAddress).build(); DeviceDescription deviceDescription = new DefaultDeviceDescription( deviceId.uri(), Device.Type.SWITCH, UNKNOWN, UNKNOWN, UNKNOWN, UNKNOWN, cid, annotations); providerService.deviceConnected(deviceId, deviceDescription); nodeId.setActive(true); controller.addDevice(nodeId); }
private void connectDevices() { NetconfProviderConfig cfg = cfgService.getConfig(appId, NetconfProviderConfig.class); if (cfg != null) { try { cfg.getDevicesAddresses() .stream() .forEach( addr -> { try { NetconfDeviceInfo netconf = new NetconfDeviceInfo(addr.name(), addr.password(), addr.ip(), addr.port()); controller.connectDevice(netconf); Device device = deviceService.getDevice(netconf.getDeviceId()); if (device.is(PortDiscovery.class)) { PortDiscovery portConfig = device.as(PortDiscovery.class); if (portConfig != null) { providerService.updatePorts(netconf.getDeviceId(), portConfig.getPorts()); } } else { log.warn("No portGetter behaviour for device {}", netconf.getDeviceId()); } } catch (IOException e) { throw new RuntimeException( new NetconfException( "Can't connect to NETCONF " + "device on " + addr.ip() + ":" + addr.port(), e)); } }); } catch (ConfigException e) { log.error("Cannot read config error " + e); } } }
private void connectDevices() { RestProviderConfig cfg = cfgService.getConfig(appId, RestProviderConfig.class); try { if (cfg != null && cfg.getDevicesAddresses() != null) { // Precomputing the devices to be removed Set<RestSBDevice> toBeRemoved = new HashSet<>(controller.getDevices().values()); toBeRemoved.removeAll(cfg.getDevicesAddresses()); // Adding new devices cfg.getDevicesAddresses() .stream() .filter(device -> testDeviceConnection(device)) .forEach( device -> { deviceAdded(device); }); // Removing devices not wanted anymore toBeRemoved.stream().forEach(device -> deviceRemoved(device)); } } catch (ConfigException e) { log.error("Configuration error {}", e); } log.info("REST Devices {}", controller.getDevices()); controller .getDevices() .keySet() .forEach( deviceId -> { DriverHandler h = driverService.createHandler(deviceId); PortDiscovery portConfig = h.behaviour(PortDiscovery.class); if (portConfig != null) { providerService.updatePorts(deviceId, portConfig.getPorts()); } else { log.warn("No portGetter behaviour for device {}", deviceId); } }); }
@Override public void roleChanged(DeviceId device, MastershipRole newRole) { deviceProviderService.receivedRoleReply(device, newRole, newRole); }
// when do I call it ? public void deviceRemoved(RestSBDevice nodeId) { Preconditions.checkNotNull(nodeId, ISNOTNULL); DeviceId deviceId = nodeId.deviceId(); providerService.deviceDisconnected(deviceId); controller.removeDevice(nodeId); }