홍길동 / onos

Go to a project
Toggle navigation Toggle navigation pinning
Jonathan Hart
Committed by Gerrit Code Review
eb8c9476 1 parent 41b1f3ab

Created InterfaceService which maintains an inventory of interfaces 

based on configuration data.

Change-Id: I98a360fd1b833885fcb41bf9bb8a6e81dc436fd1
Inline Side-by-side
Showing 10 changed files with 508 additions and 172 deletions
......@@ -15,11 +15,10 @@
*/
package org.onosproject.cli;
import java.util.Comparator;
import org.onosproject.cluster.ControllerNode;
import org.onosproject.core.Application;
import org.onosproject.core.ApplicationId;
import org.onosproject.incubator.net.intf.Interface;
import org.onosproject.net.ConnectPoint;
import org.onosproject.net.Element;
import org.onosproject.net.ElementId;
......@@ -29,6 +28,8 @@ import org.onosproject.net.group.Group;
import org.onosproject.net.host.PortAddresses;
import org.onosproject.net.topology.TopologyCluster;
import java.util.Comparator;
/**
* Various comparators.
*/
......@@ -119,4 +120,7 @@ public final class Comparators {
}
};
public static final Comparator<Interface> INTERFACES_COMPARATOR = (intf1, intf2) ->
CONNECT_POINT_COMPARATOR.compare(intf1.connectPoint(), intf2.connectPoint());
}
......
/*
* Copyright 2015 Open Networking Laboratory
*
* 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.cli.net;
import com.google.common.collect.Lists;
import org.apache.karaf.shell.commands.Command;
import org.onosproject.cli.AbstractShellCommand;
import org.onosproject.cli.Comparators;
import org.onosproject.incubator.net.intf.Interface;
import org.onosproject.incubator.net.intf.InterfaceService;
import java.util.Collections;
import java.util.List;
/**
* Lists all configured interfaces.
*/
@Command(scope = "onos", name = "interfaces",
description = "Lists all configured interfaces.")
public class InterfacesListCommand extends AbstractShellCommand {
private static final String FORMAT =
"port=%s/%s, ips=%s, mac=%s, vlan=%s";
@Override
protected void execute() {
InterfaceService interfaceService = get(InterfaceService.class);
List<Interface> interfaces = Lists.newArrayList(interfaceService.getInterfaces());
Collections.sort(interfaces, Comparators.INTERFACES_COMPARATOR);
for (Interface intf : interfaces) {
print(FORMAT, intf.connectPoint().deviceId(), intf.connectPoint().port(),
intf.ipAddresses(), intf.mac(), intf.vlan());
}
}
}
......@@ -323,6 +323,9 @@
<command>
<action class="org.onosproject.cli.net.AddressBindingsListCommand"/>
</command>
<command>
<action class="org.onosproject.cli.net.InterfacesListCommand"/>
</command>
<command>
<action class="org.onosproject.cli.net.GroupsListCommand"/>
......@@ -365,7 +368,7 @@
<entry key="-a" value-ref="allAppNameCompleter"/>
</optional-completers>
</command>
<command>
<action class="org.onosproject.cli.net.GlobalLabelCommand"/>
</command>
......
......@@ -15,16 +15,16 @@
*/
package org.onosproject.net.host;
import java.util.Set;
import org.onlab.packet.IpAddress;
import org.onlab.packet.MacAddress;
import org.onlab.packet.VlanId;
import org.onosproject.event.ListenerService;
import org.onosproject.net.ConnectPoint;
import org.onosproject.net.DeviceId;
import org.onosproject.net.Host;
import org.onosproject.net.HostId;
import org.onlab.packet.IpAddress;
import org.onlab.packet.MacAddress;
import org.onlab.packet.VlanId;
import java.util.Set;
/**
* Service for interacting with the inventory of end-station hosts.
......@@ -127,7 +127,9 @@ public interface HostService
* Returns the addresses information for all connection points.
*
* @return the set of address bindings for all connection points
* @deprecated in Drake release: use InterfaceService instead
*/
@Deprecated
Set<PortAddresses> getAddressBindings();
/**
......@@ -136,7 +138,9 @@ public interface HostService
*
* @param connectPoint the connection point to retrieve address bindings for
* @return addresses bound to the port
* @deprecated in Drake release: use InterfaceService instead
*/
@Deprecated
Set<PortAddresses> getAddressBindingsForPort(ConnectPoint connectPoint);
}
......
/*
* Copyright 2015 Open Networking Laboratory
*
* 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.incubator.net.config.basics;
import com.fasterxml.jackson.databind.JsonNode;
import com.fasterxml.jackson.databind.node.ArrayNode;
import com.google.common.collect.Sets;
import org.onlab.packet.MacAddress;
import org.onlab.packet.VlanId;
import org.onosproject.incubator.net.config.Config;
import org.onosproject.net.ConnectPoint;
import org.onosproject.net.host.InterfaceIpAddress;
import java.util.Iterator;
import java.util.Set;
/**
* Basic configuration for a port on a device.
*/
public class BasicPortConfig extends Config<ConnectPoint> {
public static final String IPS = "ips";
public static final String MAC = "mac";
public static final String VLAN = "vlan";
/**
* Returns the set of IP addresses assigned to the port.
*
* @return set ip IP addresses
*/
public Set<InterfaceIpAddress> ips() {
Set<InterfaceIpAddress> ips = Sets.newHashSet();
JsonNode ipsNode = node.get(IPS);
ipsNode.forEach(jsonNode -> ips.add(InterfaceIpAddress.valueOf(jsonNode.asText())));
return ips;
}
/**
* Adds an IP address to configuration of the port.
*
* @param ip ip address to add
* @return this
*/
public BasicPortConfig addIp(InterfaceIpAddress ip) {
ArrayNode ipsNode = (ArrayNode) node.get(IPS);
if (ipsNode == null) {
ipsNode = node.putArray(IPS);
}
// Check if the value is already there
if (ipsNode.findValue(ip.toString()) != null) {
ipsNode.add(ip.toString());
}
return this;
}
/**
* Removes an IP address from the configuration of the port.
*
* @param ip ip address to remove
* @return this
*/
public BasicPortConfig removeIp(InterfaceIpAddress ip) {
ArrayNode ipsNode = (ArrayNode) node.get(IPS);
if (ipsNode != null) {
if (ipsNode.size() == 1) {
node.remove(IPS);
} else {
Iterator<JsonNode> it = ipsNode.iterator();
while (it.hasNext()) {
if (it.next().asText().equals(ip.toString())) {
it.remove();
break;
}
}
}
}
return this;
}
/**
* Clear all IP addresses from the configuration.
*
* @return this
*/
public BasicPortConfig clearIps() {
node.remove(IPS);
return this;
}
/**
* Returns the MAC address configured on the port.
*
* @return MAC address
*/
public MacAddress mac() {
JsonNode macNode = node.get(MAC);
if (macNode == null) {
return null;
}
return MacAddress.valueOf(macNode.asText());
}
/**
* Sets the MAC address configured on the port.
*
* @param mac MAC address
* @return this
*/
public BasicPortConfig mac(MacAddress mac) {
String macString = (mac == null) ? null : mac.toString();
return (BasicPortConfig) setOrClear(MAC, macString);
}
/**
* Returns the VLAN configured on the port.
*
* @return VLAN ID
*/
public VlanId vlan() {
JsonNode macNode = node.get(VLAN);
if (macNode == null) {
return null;
}
return VlanId.vlanId(Short.parseShort(macNode.asText()));
}
/**
* Sets the VLAN configured on the port.
*
* @param vlan VLAN ID
* @return this
*/
public BasicPortConfig vlan(VlanId vlan) {
Integer vlanId = (vlan == null) ? null : Integer.valueOf(vlan.toShort());
return (BasicPortConfig) setOrClear(VLAN, vlanId);
}
}
/*
* Copyright 2015 Open Networking Laboratory
*
* 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.incubator.net.config.basics;
import com.fasterxml.jackson.databind.JsonNode;
import com.google.common.collect.Sets;
import org.onlab.packet.MacAddress;
import org.onlab.packet.VlanId;
import org.onosproject.incubator.net.config.Config;
import org.onosproject.incubator.net.intf.Interface;
import org.onosproject.net.ConnectPoint;
import org.onosproject.net.host.InterfaceIpAddress;
import java.util.Set;
/**
* Configuration for interfaces.
*/
public class InterfaceConfig extends Config<ConnectPoint> {
public static final String INTERFACES = "interfaces";
public static final String IPS = "ips";
public static final String MAC = "mac";
public static final String VLAN = "vlan";
/**
* Retrieves all interfaces configured on this port.
*
* @return set of interfaces
*/
public Set<Interface> getInterfaces() {
Set<Interface> interfaces = Sets.newHashSet();
for (JsonNode intfNode : node.path(INTERFACES)) {
interfaces.add(new Interface(subject,
getIps(intfNode),
MacAddress.valueOf(intfNode.path(MAC).asText()),
VlanId.vlanId(Short.parseShort(intfNode.path(VLAN).asText()))));
}
return interfaces;
}
private Set<InterfaceIpAddress> getIps(JsonNode node) {
Set<InterfaceIpAddress> ips = Sets.newHashSet();
JsonNode ipsNode = node.get(IPS);
ipsNode.forEach(jsonNode -> ips.add(InterfaceIpAddress.valueOf(jsonNode.asText())));
return ips;
}
}
/*
* Copyright 2014-2015 Open Networking Laboratory
*
* 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.incubator.net.intf;
import com.google.common.base.MoreObjects;
import com.google.common.collect.Sets;
import org.onlab.packet.MacAddress;
import org.onlab.packet.VlanId;
import org.onosproject.net.ConnectPoint;
import org.onosproject.net.host.InterfaceIpAddress;
import java.util.Objects;
import java.util.Set;
/**
* An Interface maps network configuration information (such as addresses and
* vlans) to a port in the network.
*/
public class Interface {
private final ConnectPoint connectPoint;
private final Set<InterfaceIpAddress> ipAddresses;
private final MacAddress macAddress;
private final VlanId vlan;
/**
* Creates new Interface with the provided configuration.
*
* @param connectPoint the connect point this interface maps to
* @param ipAddresses Set of IP addresses
* @param macAddress MAC address
* @param vlan VLAN ID
*/
public Interface(ConnectPoint connectPoint,
Set<InterfaceIpAddress> ipAddresses,
MacAddress macAddress, VlanId vlan) {
this.connectPoint = connectPoint;
this.ipAddresses = Sets.newHashSet(ipAddresses);
this.macAddress = macAddress;
this.vlan = vlan;
}
/**
* Retrieves the connection point that this interface maps to.
*
* @return the connection point
*/
public ConnectPoint connectPoint() {
return connectPoint;
}
/**
* Retrieves the set of IP addresses that are assigned to the interface.
*
* @return the set of interface IP addresses
*/
public Set<InterfaceIpAddress> ipAddresses() {
return ipAddresses;
}
/**
* Retrieves the MAC address that is assigned to the interface.
*
* @return the MAC address
*/
public MacAddress mac() {
return macAddress;
}
/**
* Retrieves the VLAN ID that is assigned to the interface.
*
* @return the VLAN ID
*/
public VlanId vlan() {
return vlan;
}
@Override
public boolean equals(Object other) {
if (!(other instanceof Interface)) {
return false;
}
Interface otherInterface = (Interface) other;
return Objects.equals(connectPoint, otherInterface.connectPoint) &&
Objects.equals(ipAddresses, otherInterface.ipAddresses) &&
Objects.equals(macAddress, otherInterface.macAddress) &&
Objects.equals(vlan, otherInterface.vlan);
}
@Override
public int hashCode() {
return Objects.hash(connectPoint, ipAddresses, macAddress, vlan);
}
@Override
public String toString() {
return MoreObjects.toStringHelper(getClass())
.add("connectPoint", connectPoint)
.add("ipAddresses", ipAddresses)
.add("macAddress", macAddress)
.add("vlan", vlan)
.toString();
}
}
/*
* Copyright 2015 Open Networking Laboratory
*
* 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.incubator.net.intf;
import org.onlab.packet.IpAddress;
import org.onlab.packet.VlanId;
import org.onosproject.net.ConnectPoint;
import java.util.Set;
/**
* Service for interacting with interfaces.
*/
public interface InterfaceService {
/**
* Returns the set of all interfaces in the system.
*
* @return set of interfaces
*/
Set<Interface> getInterfaces();
/**
* Returns the set of interfaces configured on the given port.
*
* @param port connect point
* @return set of interfaces
*/
Set<Interface> getInterfacesByPort(ConnectPoint port);
/**
* Returns the set of interfaces with the given IP address.
*
* @param ip IP address
* @return set of interfaces
*/
Set<Interface> getInterfacesByIp(IpAddress ip);
/**
* Returns the set of interfaces in the given VLAN.
*
* @param vlan VLAN ID of the interfaces
* @return set of interfaces
*/
Set<Interface> getInterfacesByVlan(VlanId vlan);
/**
* Returns an interface that has an address that is in the same subnet as
* the given IP address.
*
* @param ip IP address to find matching subnet interface for
* @return interface
*/
Interface getMatchingInterface(IpAddress ip);
}
......@@ -28,7 +28,7 @@ import org.onosproject.incubator.net.config.NetworkConfigRegistry;
import org.onosproject.incubator.net.config.basics.BasicDeviceConfig;
import org.onosproject.incubator.net.config.basics.BasicHostConfig;
import org.onosproject.incubator.net.config.basics.BasicLinkConfig;
import org.onosproject.incubator.net.config.basics.BasicPortConfig;
import org.onosproject.incubator.net.config.basics.InterfaceConfig;
import org.onosproject.incubator.net.config.basics.OpticalPortConfig;
import org.onosproject.incubator.net.config.basics.SubjectFactories;
import org.onosproject.incubator.net.domain.IntentDomainConfig;
......@@ -61,12 +61,12 @@ public class BasicNetworkConfigs {
return new BasicDeviceConfig();
}
},
new ConfigFactory<ConnectPoint, BasicPortConfig>(CONNECT_POINT_SUBJECT_FACTORY,
BasicPortConfig.class,
"basic") {
new ConfigFactory<ConnectPoint, InterfaceConfig>(CONNECT_POINT_SUBJECT_FACTORY,
InterfaceConfig.class,
"interfaces") {
@Override
public BasicPortConfig createConfig() {
return new BasicPortConfig();
public InterfaceConfig createConfig() {
return new InterfaceConfig();
}
},
new ConfigFactory<HostId, BasicHostConfig>(HOST_SUBJECT_FACTORY,
......
/*
* Copyright 2015 Open Networking Laboratory
*
* 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.incubator.net.intf.impl;
import com.google.common.collect.ImmutableSet;
import com.google.common.collect.Maps;
import org.apache.felix.scr.annotations.Activate;
import org.apache.felix.scr.annotations.Component;
import org.apache.felix.scr.annotations.Deactivate;
import org.apache.felix.scr.annotations.Reference;
import org.apache.felix.scr.annotations.ReferenceCardinality;
import org.apache.felix.scr.annotations.Service;
import org.onlab.packet.IpAddress;
import org.onlab.packet.VlanId;
import org.onosproject.incubator.net.config.NetworkConfigEvent;
import org.onosproject.incubator.net.config.NetworkConfigListener;
import org.onosproject.incubator.net.config.NetworkConfigService;
import org.onosproject.incubator.net.config.basics.InterfaceConfig;
import org.onosproject.incubator.net.intf.Interface;
import org.onosproject.incubator.net.intf.InterfaceService;
import org.onosproject.net.ConnectPoint;
import org.onosproject.net.Device;
import org.onosproject.net.Port;
import org.onosproject.net.device.DeviceService;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import java.util.Map;
import java.util.Optional;
import java.util.Set;
import static java.util.stream.Collectors.collectingAndThen;
import static java.util.stream.Collectors.toSet;
/**
* Manages the inventory of interfaces in the system.
*/
@Service
@Component(immediate = true)
public class InterfaceManager implements InterfaceService {
private final Logger log = LoggerFactory.getLogger(getClass());
@Reference(cardinality = ReferenceCardinality.MANDATORY_UNARY)
protected NetworkConfigService configService;
@Reference(cardinality = ReferenceCardinality.MANDATORY_UNARY)
protected DeviceService deviceService;
private final InternalConfigListener listener = new InternalConfigListener();
private final Map<ConnectPoint, Set<Interface>> interfaces = Maps.newConcurrentMap();
@Activate
public void activate() {
configService.addListener(listener);
for (Device d : deviceService.getDevices()) {
for (Port p : deviceService.getPorts(d.id())) {
InterfaceConfig config =
configService.getConfig(new ConnectPoint(d.id(), p.number()), InterfaceConfig.class);
if (config != null) {
updateInterfaces(config);
}
}
}
log.info("Started");
}
@Deactivate
public void deactivate() {
configService.removeListener(listener);
log.info("Stopped");
}
@Override
public Set<Interface> getInterfaces() {
return interfaces.values()
.stream()
.flatMap(set -> set.stream())
.collect(collectingAndThen(toSet(), ImmutableSet::copyOf));
}
@Override
public Set<Interface> getInterfacesByPort(ConnectPoint port) {
return ImmutableSet.copyOf(interfaces.get(port));
}
@Override
public Set<Interface> getInterfacesByIp(IpAddress ip) {
return interfaces.values()
.stream()
.flatMap(set -> set.stream())
.filter(intf -> intf.ipAddresses().contains(ip))
.collect(collectingAndThen(toSet(), ImmutableSet::copyOf));
}
@Override
public Interface getMatchingInterface(IpAddress ip) {
Optional<Interface> match = interfaces.values()
.stream()
.flatMap(set -> set.stream())
.filter(intf -> intf.ipAddresses()
.stream()
.anyMatch(intfIp -> intfIp.subnetAddress().contains(ip)))
.findFirst();
if (match.isPresent()) {
return match.get();
}
return null;
}
@Override
public Set<Interface> getInterfacesByVlan(VlanId vlan) {
return interfaces.values()
.stream()
.flatMap(set -> set.stream())
.filter(intf -> intf.vlan().equals(vlan))
.collect(collectingAndThen(toSet(), ImmutableSet::copyOf));
}
private void updateInterfaces(InterfaceConfig intfConfig) {
interfaces.put(intfConfig.subject(), intfConfig.getInterfaces());
}
private void removeInterfaces(ConnectPoint port) {
interfaces.remove(port);
}
/**
* Listener for network config events.
*/
private class InternalConfigListener implements NetworkConfigListener {
@Override
public void event(NetworkConfigEvent event) {
switch (event.type()) {
case CONFIG_ADDED:
case CONFIG_UPDATED:
if (event.configClass() == InterfaceConfig.class) {
InterfaceConfig config =
configService.getConfig((ConnectPoint) event.subject(), InterfaceConfig.class);
updateInterfaces(config);
}
break;
case CONFIG_REMOVED:
if (event.configClass() == InterfaceConfig.class) {
removeInterfaces((ConnectPoint) event.subject());
}
break;
case CONFIG_REGISTERED:
case CONFIG_UNREGISTERED:
default:
break;
}
}
}
}