[ONOS-6248] VPLS refactoring
Change-Id: I8ffb2199ca108ad8dfe271681068636fc4af2a40
diff --git a/apps/vpls/BUCK b/apps/vpls/BUCK
index 471e91c..eb1ddec 100644
--- a/apps/vpls/BUCK
+++ b/apps/vpls/BUCK
@@ -6,7 +6,7 @@
'//cli:onos-cli',
'//utils/rest:onlab-rest',
'//incubator/api:onos-incubator-api',
- '//apps/intentsync:onos-apps-intentsync',
+ '//core/store/serializers:onos-core-serializers'
]
TEST_DEPS = [
diff --git a/apps/vpls/pom.xml b/apps/vpls/pom.xml
index f3dd04f..dbe5ac4 100644
--- a/apps/vpls/pom.xml
+++ b/apps/vpls/pom.xml
@@ -35,7 +35,6 @@
<onos.app.category>Traffic Steering</onos.app.category>
<onos.app.title>VLAN L2 Broadcast Network App</onos.app.title>
<onos.app.url>http://onosproject.org</onos.app.url>
- <onos.app.requires>org.onosproject.intentsynchronizer</onos.app.requires>
</properties>
<dependencies>
@@ -45,21 +44,11 @@
</dependency>
<dependency>
<groupId>org.onosproject</groupId>
- <artifactId>onos-apps-intentsync</artifactId>
- <version>${project.version}</version>
- </dependency>
- <dependency>
- <groupId>org.onosproject</groupId>
<artifactId>onos-api</artifactId>
<scope>test</scope>
<classifier>tests</classifier>
</dependency>
<dependency>
- <groupId>org.onosproject</groupId>
- <artifactId>onos-app-sdnip</artifactId>
- <version>${project.version}</version>
- </dependency>
- <dependency>
<groupId>org.easymock</groupId>
<artifactId>easymock</artifactId>
<scope>test</scope>
@@ -73,6 +62,15 @@
<groupId>org.apache.karaf.shell</groupId>
<artifactId>org.apache.karaf.shell.console</artifactId>
</dependency>
-
+ <dependency>
+ <groupId>org.onosproject</groupId>
+ <artifactId>onos-core-serializers</artifactId>
+ <version>${project.version}</version>
+ </dependency>
+ <dependency>
+ <groupId>org.onosproject</groupId>
+ <artifactId>onos-cli</artifactId>
+ <version>${project.version}</version>
+ </dependency>
</dependencies>
</project>
diff --git a/apps/vpls/src/main/java/org/onosproject/vpls/IntentInstaller.java b/apps/vpls/src/main/java/org/onosproject/vpls/IntentInstaller.java
deleted file mode 100644
index 94b819a..0000000
--- a/apps/vpls/src/main/java/org/onosproject/vpls/IntentInstaller.java
+++ /dev/null
@@ -1,284 +0,0 @@
-/*
- * Copyright 2016-present 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.vpls;
-
-import com.google.common.collect.ImmutableList;
-import com.google.common.collect.ImmutableSet;
-import com.google.common.collect.Lists;
-import org.onlab.packet.MacAddress;
-import org.onosproject.core.ApplicationId;
-import org.onosproject.net.ConnectPoint;
-import org.onosproject.net.EncapsulationType;
-import org.onosproject.net.FilteredConnectPoint;
-import org.onosproject.net.Host;
-import org.onosproject.net.flow.DefaultTrafficSelector;
-import org.onosproject.net.flow.TrafficSelector;
-import org.onosproject.net.intent.ConnectivityIntent;
-import org.onosproject.net.intent.Constraint;
-import org.onosproject.net.intent.Intent;
-import org.onosproject.net.intent.IntentService;
-import org.onosproject.net.intent.IntentState;
-import org.onosproject.net.intent.Key;
-import org.onosproject.net.intent.MultiPointToSinglePointIntent;
-import org.onosproject.net.intent.SinglePointToMultiPointIntent;
-import org.onosproject.net.intent.constraint.EncapsulationConstraint;
-import org.onosproject.net.intent.constraint.PartialFailureConstraint;
-import org.onosproject.intentsync.IntentSynchronizationService;
-import org.slf4j.Logger;
-import org.slf4j.LoggerFactory;
-
-import java.util.ArrayList;
-import java.util.Collection;
-import java.util.List;
-import java.util.Set;
-
-import static org.onosproject.net.EncapsulationType.*;
-
-/**
- * Synchronizes intents between the in-memory intent store and the
- * IntentService.
- */
-public class IntentInstaller {
- private static final String SUBMIT =
- "Submitting intents to the Intent Synchronizer";
- private static final String WITHDRAW =
- "Withdrawing intents to the Intent Synchronizer";
- private static final String SP2MP =
- "Building sp2mp intent from {}";
- private static final String MP2SP =
- "Building mp2sp intent to {}";
-
- private static final Logger log = LoggerFactory.getLogger(
- IntentInstaller.class);
-
- private static final int PRIORITY_OFFSET = 1000;
-
- private static final Set<IntentState> WITHDRAWN_INTENT_STATES =
- ImmutableSet.of(IntentState.WITHDRAWN,
- IntentState.WITHDRAW_REQ,
- IntentState.WITHDRAWING);
-
- static final String PREFIX_BROADCAST = "brc";
- static final String PREFIX_UNICAST = "uni";
- static final String SEPARATOR = "-";
-
- private final ApplicationId appId;
- private final IntentSynchronizationService intentSynchronizer;
- private final IntentService intentService;
-
- public static final ImmutableList<Constraint> PARTIAL_FAILURE_CONSTRAINT =
- ImmutableList.of(new PartialFailureConstraint());
-
- /**
- * Class constructor.
- *
- * @param appId the Application ID
- * @param intentService the intent service
- * @param intentSynchronizer the intent synchronizer service
- */
- public IntentInstaller(ApplicationId appId, IntentService intentService,
- IntentSynchronizationService intentSynchronizer) {
- this.appId = appId;
- this.intentService = intentService;
- this.intentSynchronizer = intentSynchronizer;
- }
-
- /**
- * Requests to install the intents passed as argument to the Intent Service.
- *
- * @param intents intents to be submitted
- */
- protected void submitIntents(Collection<Intent> intents) {
- log.debug(SUBMIT);
- intents.forEach(intentSynchronizer::submit);
- }
-
- /**
- * Requests to withdraw the intents passed as argument to the Intent Service.
- *
- * @param intents intents to be withdraw
- */
- protected void withdrawIntents(Collection<Intent> intents) {
- log.debug(WITHDRAW);
- intents.forEach(intentSynchronizer::withdraw);
- }
-
- /**
- * Returns list of intents belongs to a VPLS.
- *
- * @param name the name of the VPLS
- * @return the list of intents belonging to a VPLS
- */
- protected List<Intent> getIntentsFromVpls(String name) {
- List<Intent> intents = Lists.newArrayList();
-
- intentService.getIntents().forEach(intent -> {
- if (intent.key().toString().startsWith(name)) {
- intents.add(intent);
- }
- });
-
- return intents;
- }
-
- /**
- * Builds a broadcast intent.
- *
- * @param key key to identify the intent
- * @param src the source connect point
- * @param dsts the destination connect points
- * @param encap the encapsulation type
- * @return the generated single-point to multi-point intent
- */
- protected SinglePointToMultiPointIntent buildBrcIntent(Key key,
- FilteredConnectPoint src,
- Set<FilteredConnectPoint> dsts,
- EncapsulationType encap) {
- log.debug("Building broadcast intent {} for source {}", SP2MP, src);
-
- SinglePointToMultiPointIntent.Builder intentBuilder;
-
- TrafficSelector selector = DefaultTrafficSelector.builder()
- .matchEthDst(MacAddress.BROADCAST)
- .build();
-
- intentBuilder = SinglePointToMultiPointIntent.builder()
- .appId(appId)
- .key(key)
- .selector(selector)
- .filteredIngressPoint(src)
- .filteredEgressPoints(dsts)
- .constraints(PARTIAL_FAILURE_CONSTRAINT)
- .priority(PRIORITY_OFFSET);
-
- setEncap(intentBuilder, PARTIAL_FAILURE_CONSTRAINT, encap);
-
- return intentBuilder.build();
- }
-
- /**
- * Builds a unicast intent.
- *
- * @param key key to identify the intent
- * @param srcs the source Connect Points
- * @param dst the destination Connect Point
- * @param host destination Host
- * @param encap the encapsulation type
- * @return the generated multi-point to single-point intent
- */
- protected MultiPointToSinglePointIntent buildUniIntent(Key key,
- Set<FilteredConnectPoint> srcs,
- FilteredConnectPoint dst,
- Host host,
- EncapsulationType encap) {
- log.debug("Building unicast intent {} for destination {}", MP2SP, dst);
-
- MultiPointToSinglePointIntent.Builder intentBuilder;
-
- TrafficSelector selector = DefaultTrafficSelector.builder()
- .matchEthDst(host.mac())
- .build();
-
- intentBuilder = MultiPointToSinglePointIntent.builder()
- .appId(appId)
- .key(key)
- .selector(selector)
- .filteredIngressPoints(srcs)
- .filteredEgressPoint(dst)
- .constraints(PARTIAL_FAILURE_CONSTRAINT)
- .priority(PRIORITY_OFFSET);
-
- setEncap(intentBuilder, PARTIAL_FAILURE_CONSTRAINT, encap);
-
- return intentBuilder.build();
- }
-
- /**
- * Builds an intent key either for single-point to multi-point or
- * multi-point to single-point intents, based on a prefix that defines
- * the type of intent, the single connect point representing the single
- * source or destination for that intent, the name of the VPLS the intent
- * belongs to, and the destination host MAC address the intent reaches.
- *
- * @param prefix the key prefix
- * @param cPoint the connect point identifying the source/destination
- * @param vplsName the name of the VPLS
- * @param hostMac the source/destination MAC address
- * @return the key to identify the intent
- */
- protected Key buildKey(String prefix,
- ConnectPoint cPoint,
- String vplsName,
- MacAddress hostMac) {
- String keyString = vplsName +
- SEPARATOR +
- prefix +
- SEPARATOR +
- cPoint.deviceId() +
- SEPARATOR +
- cPoint.port() +
- SEPARATOR +
- hostMac;
-
- return Key.of(keyString, appId);
- }
-
- /**
- * Returns true if the specified intent exists; false otherwise.
- *
- * @param intentKey the intent key
- * @return true if the intent exists; false otherwise
- */
- protected boolean intentExists(Key intentKey) {
- if (intentService.getIntent(intentKey) == null) {
- return false;
- }
-
- // Intent does not exist if intent withdrawn
- IntentState currentIntentState = intentService.getIntentState(intentKey);
- return !WITHDRAWN_INTENT_STATES.contains(currentIntentState);
-
- }
-
- /**
- * Sets one or more encapsulation constraints on the intent builder given.
- *
- * @param builder the intent builder
- * @param constraints the existing intent constraints
- * @param encap the encapsulation type to be set
- */
- public static void setEncap(ConnectivityIntent.Builder builder,
- List<Constraint> constraints,
- EncapsulationType encap) {
- // Constraints might be an immutable list, so a new modifiable list
- // is created
- List<Constraint> newConstraints = new ArrayList<>(constraints);
-
- // Remove any encapsulation constraint if already in the list
- constraints.stream()
- .filter(c -> c instanceof EncapsulationConstraint)
- .forEach(newConstraints::remove);
-
- // if the new encapsulation is different from NONE, a new encapsulation
- // constraint should be added to the list
- if (!encap.equals(NONE)) {
- newConstraints.add(new EncapsulationConstraint(encap));
- }
-
- // Submit new constraint list as immutable list
- builder.constraints(ImmutableList.copyOf(newConstraints));
- }
-}
diff --git a/apps/vpls/src/main/java/org/onosproject/vpls/Vpls.java b/apps/vpls/src/main/java/org/onosproject/vpls/Vpls.java
deleted file mode 100644
index af47248..0000000
--- a/apps/vpls/src/main/java/org/onosproject/vpls/Vpls.java
+++ /dev/null
@@ -1,432 +0,0 @@
-/*
- * Copyright 2015-present 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.vpls;
-
-import com.google.common.collect.ImmutableSet;
-import com.google.common.collect.Lists;
-import com.google.common.collect.SetMultimap;
-import com.google.common.collect.Sets;
-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.onlab.packet.MacAddress;
-import org.onlab.packet.VlanId;
-import org.onosproject.app.ApplicationService;
-import org.onosproject.core.ApplicationId;
-import org.onosproject.core.CoreService;
-import org.onosproject.incubator.net.intf.Interface;
-import org.onosproject.incubator.net.intf.InterfaceEvent;
-import org.onosproject.incubator.net.intf.InterfaceListener;
-import org.onosproject.incubator.net.intf.InterfaceService;
-import org.onosproject.net.EncapsulationType;
-import org.onosproject.net.FilteredConnectPoint;
-import org.onosproject.net.Host;
-import org.onosproject.net.config.NetworkConfigEvent;
-import org.onosproject.net.config.NetworkConfigListener;
-import org.onosproject.net.config.NetworkConfigService;
-import org.onosproject.net.flow.DefaultTrafficSelector;
-import org.onosproject.net.flow.TrafficSelector;
-import org.onosproject.net.flow.criteria.Criterion;
-import org.onosproject.net.flow.criteria.VlanIdCriterion;
-import org.onosproject.net.host.HostEvent;
-import org.onosproject.net.host.HostListener;
-import org.onosproject.net.host.HostService;
-import org.onosproject.net.intent.Intent;
-import org.onosproject.net.intent.IntentService;
-import org.onosproject.net.intent.Key;
-import org.onosproject.intentsync.IntentSynchronizationService;
-import org.onosproject.vpls.config.VplsConfigService;
-import org.slf4j.Logger;
-
-import java.util.Collection;
-import java.util.HashSet;
-import java.util.List;
-import java.util.Set;
-import java.util.stream.Collectors;
-
-import static org.onosproject.vpls.IntentInstaller.PREFIX_BROADCAST;
-import static org.onosproject.vpls.IntentInstaller.PREFIX_UNICAST;
-import static org.slf4j.LoggerFactory.getLogger;
-
-/**
- * Application to create L2 broadcast overlay networks using VLANs.
- */
-@Component(immediate = true)
-public class Vpls {
- static final String VPLS_APP = "org.onosproject.vpls";
-
- private static final String HOST_FCP_NOT_FOUND =
- "Filtered connected point for host {} not found";
- private static final String HOST_EVENT = "Received HostEvent {}";
- private static final String INTF_CONF_EVENT =
- "Received InterfaceConfigEvent {}";
- private static final String NET_CONF_EVENT =
- "Received NetworkConfigEvent {}";
-
- private final Logger log = getLogger(getClass());
-
- @Reference(cardinality = ReferenceCardinality.MANDATORY_UNARY)
- protected ApplicationService applicationService;
-
- @Reference(cardinality = ReferenceCardinality.MANDATORY_UNARY)
- protected CoreService coreService;
-
- @Reference(cardinality = ReferenceCardinality.MANDATORY_UNARY)
- protected HostService hostService;
-
- @Reference(cardinality = ReferenceCardinality.MANDATORY_UNARY)
- protected IntentService intentService;
-
- @Reference(cardinality = ReferenceCardinality.MANDATORY_UNARY)
- protected InterfaceService interfaceService;
-
- @Reference(cardinality = ReferenceCardinality.MANDATORY_UNARY)
- protected IntentSynchronizationService intentSynchronizer;
-
- @Reference(cardinality = ReferenceCardinality.MANDATORY_UNARY)
- protected NetworkConfigService configService;
-
- @Reference(cardinality = ReferenceCardinality.MANDATORY_UNARY)
- protected VplsConfigService vplsConfigService;
-
- private final HostListener hostListener = new InternalHostListener();
-
- private final InternalInterfaceListener interfaceListener =
- new InternalInterfaceListener();
-
- private final InternalNetworkConfigListener configListener =
- new InternalNetworkConfigListener();
-
- private IntentInstaller intentInstaller;
-
- private ApplicationId appId;
-
- @Activate
- public void activate() {
- appId = coreService.registerApplication(VPLS_APP);
-
- intentInstaller = new IntentInstaller(appId,
- intentService,
- intentSynchronizer);
-
- applicationService.registerDeactivateHook(appId, () -> {
- intentSynchronizer.removeIntentsByAppId(appId);
- });
-
- hostService.addListener(hostListener);
- interfaceService.addListener(interfaceListener);
- configService.addListener(configListener);
-
- setupConnectivity(false);
-
- log.info("Activated");
- }
-
- @Deactivate
- public void deactivate() {
- hostService.removeListener(hostListener);
- interfaceService.removeListener(interfaceListener);
- configService.removeListener(configListener);
- intentSynchronizer.removeIntentsByAppId(appId);
- log.info("Deactivated");
- }
-
- /**
- * Sets up connectivity for all VPLSs.
- *
- * @param isNetworkConfigEvent true if this function is triggered
- * by NetworkConfigEvent; false otherwise
- */
- private void setupConnectivity(boolean isNetworkConfigEvent) {
- SetMultimap<String, Interface> networkInterfaces =
- vplsConfigService.ifacesByVplsName();
-
- Set<String> vplsAffectedByApi =
- new HashSet<>(vplsConfigService.vplsAffectedByApi());
-
- if (isNetworkConfigEvent && vplsAffectedByApi.isEmpty()) {
- vplsAffectedByApi.addAll(vplsConfigService.vplsNamesOld());
- }
-
- networkInterfaces.asMap().forEach((vplsName, interfaces) -> {
- Set<Host> hosts = Sets.newHashSet();
- interfaces.forEach(intf -> {
- // Add hosts that belongs to the specific VPLS
- hostService.getConnectedHosts(intf.connectPoint())
- .stream()
- .filter(host -> host.vlan().equals(intf.vlan()))
- .forEach(hosts::add);
- });
-
- EncapsulationType encap =
- vplsConfigService.encap(vplsName);
-
- setupConnectivity(vplsName, interfaces, hosts, encap,
- vplsAffectedByApi.contains(vplsName));
- vplsAffectedByApi.remove(vplsName);
- });
-
- if (!vplsAffectedByApi.isEmpty()) {
- for (String vplsName : vplsAffectedByApi) {
- withdrawIntents(vplsName, Lists.newArrayList());
- }
- }
- }
-
- /**
- * Sets up connectivity for specific VPLS.
- *
- * @param vplsName the VPLS name
- * @param interfaces the interfaces that belong to the VPLS
- * @param hosts the hosts that belong to the VPLS
- * @param encap the encapsulation type
- * @param affectedByApi true if this function is triggered from the APIs;
- * false otherwise
- */
- private void setupConnectivity(String vplsName,
- Collection<Interface> interfaces,
- Set<Host> hosts,
- EncapsulationType encap,
- boolean affectedByApi) {
-
- List<Intent> intents = Lists.newArrayList();
- List<Key> keys = Lists.newArrayList();
- Set<FilteredConnectPoint> fcPoints = buildFCPoints(interfaces);
-
- intents.addAll(buildBroadcastIntents(
- vplsName, fcPoints, encap, affectedByApi));
- intents.addAll(buildUnicastIntents(
- vplsName, hosts, fcPoints, encap, affectedByApi));
-
- if (affectedByApi) {
- intents.forEach(intent -> keys.add(intent.key()));
- withdrawIntents(vplsName, keys);
- }
-
- intentInstaller.submitIntents(intents);
- }
-
- /**
- * Withdraws intents belonging to a VPLS, given a VPLS name.
- *
- * @param vplsName the VPLS name
- * @param keys the keys of the intents to be installed
- */
- private void withdrawIntents(String vplsName, List<Key> keys) {
- List<Intent> intents = Lists.newArrayList();
-
- intentInstaller.getIntentsFromVpls(vplsName)
- .forEach(intent -> {
- if (!keys.contains(intent.key())) {
- intents.add(intent);
- }
- });
-
- intentInstaller.withdrawIntents(intents);
- }
-
- /**
- * Sets up broadcast intents between any given filtered connect point.
- *
- * @param vplsName the VPLS name
- * @param fcPoints the set of filtered connect points
- * @param encap the encapsulation type
- * @param affectedByApi true if the function triggered from APIs;
- * false otherwise
- * @return the set of broadcast intents
- */
- private Set<Intent> buildBroadcastIntents(String vplsName,
- Set<FilteredConnectPoint> fcPoints,
- EncapsulationType encap,
- boolean affectedByApi) {
- Set<Intent> intents = Sets.newHashSet();
- fcPoints.forEach(point -> {
- Set<FilteredConnectPoint> otherPoints =
- fcPoints.stream()
- .filter(fcp -> !fcp.equals(point))
- .collect(Collectors.toSet());
-
- Key brcKey = intentInstaller.buildKey(PREFIX_BROADCAST,
- point.connectPoint(),
- vplsName,
- MacAddress.BROADCAST);
-
- if ((!intentInstaller.intentExists(brcKey) || affectedByApi)
- && !otherPoints.isEmpty()) {
- intents.add(intentInstaller.buildBrcIntent(brcKey,
- point,
- otherPoints,
- encap));
- }
- });
-
- return ImmutableSet.copyOf(intents);
- }
-
- /**
- * Sets up unicast intents between any given filtered connect point.
- *
- * @param vplsName the VPLS name
- * @param hosts the set of destination hosts
- * @param fcPoints the set of filtered connect points
- * @param encap the encapsulation type
- * @param affectedByApi true if the function triggered from APIs;
- * false otherwise
- * @return the set of unicast intents
- */
- private Set<Intent> buildUnicastIntents(String vplsName,
- Set<Host> hosts,
- Set<FilteredConnectPoint> fcPoints,
- EncapsulationType encap,
- boolean affectedByApi) {
- Set<Intent> intents = Sets.newHashSet();
- hosts.forEach(host -> {
- FilteredConnectPoint hostPoint = getHostPoint(host, fcPoints);
-
- if (hostPoint == null) {
- log.warn(HOST_FCP_NOT_FOUND, host);
- return;
- }
-
- Set<FilteredConnectPoint> otherPoints =
- fcPoints.stream()
- .filter(fcp -> !fcp.equals(hostPoint))
- .collect(Collectors.toSet());
-
- Key uniKey = intentInstaller.buildKey(PREFIX_UNICAST,
- host.location(),
- vplsName,
- host.mac());
-
- if ((!intentInstaller.intentExists(uniKey) || affectedByApi) &&
- !otherPoints.isEmpty()) {
- intents.add(intentInstaller.buildUniIntent(uniKey,
- otherPoints,
- hostPoint,
- host,
- encap));
- }
- });
-
- return ImmutableSet.copyOf(intents);
- }
-
- /**
- * Returns the filtered connect point associated to a given host.
- *
- * @param host the target host
- * @param fcps the filtered connected points
- * @return null if not found; the filtered connect point otherwise
- */
- private FilteredConnectPoint getHostPoint(Host host,
- Set<FilteredConnectPoint> fcps) {
- return fcps.stream()
- .filter(fcp -> fcp.connectPoint().equals(host.location()))
- .filter(fcp -> {
- VlanIdCriterion vlanCriterion =
- (VlanIdCriterion) fcp.trafficSelector().
- getCriterion(Criterion.Type.VLAN_VID);
- return vlanCriterion == null ||
- vlanCriterion.vlanId().equals(host.vlan());
- })
- .findFirst()
- .orElse(null);
- }
-
- /**
- * Computes a set of filtered connect points from a list of given interfaces.
- *
- * @param interfaces the interfaces to compute
- * @return the set of filtered connect points
- */
- private Set<FilteredConnectPoint> buildFCPoints(Collection<Interface> interfaces) {
- // Build all filtered connected points in the VPLS
- return interfaces
- .stream()
- .map(intf -> {
- TrafficSelector.Builder selectorBuilder =
- DefaultTrafficSelector.builder();
- if (!intf.vlan().equals(VlanId.NONE)) {
- selectorBuilder.matchVlanId(intf.vlan());
- }
- return new FilteredConnectPoint(intf.connectPoint(),
- selectorBuilder.build());
- })
- .collect(Collectors.toSet());
- }
-
- /**
- * Listener for host events.
- */
- private class InternalHostListener implements HostListener {
- @Override
- public void event(HostEvent event) {
- log.debug(HOST_EVENT, event);
- switch (event.type()) {
- case HOST_ADDED:
- case HOST_UPDATED:
- case HOST_REMOVED:
- setupConnectivity(false);
- break;
-
- default:
- break;
- }
- }
- }
-
- /**
- * Listener for interface configuration events.
- */
- private class InternalInterfaceListener implements InterfaceListener {
- @Override
- public void event(InterfaceEvent event) {
- log.debug(INTF_CONF_EVENT, event);
- switch (event.type()) {
- case INTERFACE_ADDED:
- case INTERFACE_UPDATED:
- case INTERFACE_REMOVED:
- setupConnectivity(false);
- break;
- default:
- break;
- }
- }
- }
-
- /**
- * Listener for VPLS configuration events.
- */
- private class InternalNetworkConfigListener implements NetworkConfigListener {
- @Override
- public void event(NetworkConfigEvent event) {
- if (event.configClass() == VplsConfigService.CONFIG_CLASS) {
- log.debug(NET_CONF_EVENT, event.configClass());
- switch (event.type()) {
- case CONFIG_ADDED:
- case CONFIG_UPDATED:
- case CONFIG_REMOVED:
- setupConnectivity(true);
- break;
- default:
- break;
- }
- }
- }
- }
-}
diff --git a/apps/vpls/src/main/java/org/onosproject/vpls/VplsManager.java b/apps/vpls/src/main/java/org/onosproject/vpls/VplsManager.java
new file mode 100644
index 0000000..58ea4a2
--- /dev/null
+++ b/apps/vpls/src/main/java/org/onosproject/vpls/VplsManager.java
@@ -0,0 +1,265 @@
+/*
+ * Copyright 2015-present 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.vpls;
+
+import com.google.common.collect.ImmutableSet;
+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.onosproject.incubator.net.intf.Interface;
+import org.onosproject.incubator.net.intf.InterfaceService;
+import org.onosproject.net.EncapsulationType;
+import org.onosproject.net.Host;
+import org.onosproject.net.host.HostEvent;
+import org.onosproject.net.host.HostListener;
+import org.onosproject.net.host.HostService;
+import org.onosproject.store.StoreDelegate;
+import org.onosproject.vpls.api.VplsData;
+import org.onosproject.vpls.api.VplsOperationService;
+import org.onosproject.vpls.api.VplsOperation;
+import org.onosproject.vpls.api.Vpls;
+import org.onosproject.vpls.api.VplsStore;
+import org.onosproject.vpls.store.VplsStoreEvent;
+import org.slf4j.Logger;
+
+import java.util.Collection;
+import java.util.Set;
+
+import static java.util.Objects.*;
+import static org.slf4j.LoggerFactory.getLogger;
+
+/**
+ * Application to create L2 broadcast overlay networks using VLANs.
+ */
+@Component(immediate = true)
+@Service
+public class VplsManager implements Vpls {
+ public static final String VPLS_APP = "org.onosproject.vpls";
+ private static final String UNSUPPORTED_STORE_EVENT_TYPE =
+ "Unsupported store event type {}.";
+ private final Logger log = getLogger(getClass());
+
+ @Reference(cardinality = ReferenceCardinality.MANDATORY_UNARY)
+ protected HostService hostService;
+
+ @Reference(cardinality = ReferenceCardinality.MANDATORY_UNARY)
+ protected InterfaceService interfaceService;
+
+ @Reference(cardinality = ReferenceCardinality.MANDATORY_UNARY)
+ protected VplsStore vplsStore;
+
+ @Reference(cardinality = ReferenceCardinality.MANDATORY_UNARY)
+ protected VplsOperationService operationService;
+
+ private StoreDelegate<VplsStoreEvent> vplsStoreDelegate;
+ private HostListener vplsHostListener;
+
+ @Activate
+ public void activate() {
+ vplsStoreDelegate = new VplsStoreDelegate();
+ vplsHostListener = new VplsHostListener();
+
+ vplsStore.setDelegate(vplsStoreDelegate);
+ hostService.addListener(vplsHostListener);
+ }
+
+ @Deactivate
+ public void deactivate() {
+ vplsStore.unsetDelegate(vplsStoreDelegate);
+ hostService.removeListener(vplsHostListener);
+ }
+
+ @Override
+ public VplsData createVpls(String vplsName, EncapsulationType encapsulationType) {
+ requireNonNull(vplsName);
+ requireNonNull(encapsulationType);
+
+ if (vplsStore.getVpls(vplsName) != null) {
+ return null;
+ }
+
+ VplsData vplsData = VplsData.of(vplsName, encapsulationType);
+ vplsStore.addVpls(vplsData);
+
+ return vplsData;
+ }
+
+ @Override
+ public VplsData removeVpls(VplsData vplsData) {
+ requireNonNull(vplsData);
+ vplsData.state(VplsData.VplsState.REMOVING);
+ vplsStore.removeVpls(vplsData);
+ return vplsData;
+ }
+
+ @Override
+ public void addInterfaces(VplsData vplsData, Collection<Interface> interfaces) {
+ requireNonNull(vplsData);
+ requireNonNull(interfaces);
+ vplsData.addInterfaces(interfaces);
+ updateVplsStatus(vplsData, VplsData.VplsState.UPDATING);
+ }
+
+ @Override
+ public void addInterface(VplsData vplsData, Interface iface) {
+ requireNonNull(vplsData);
+ requireNonNull(iface);
+ vplsData.addInterface(iface);
+ updateVplsStatus(vplsData, VplsData.VplsState.UPDATING);
+ }
+
+ @Override
+ public void setEncapsulationType(VplsData vplsData, EncapsulationType encapsulationType) {
+ requireNonNull(vplsData);
+ requireNonNull(encapsulationType);
+ if (vplsData.encapsulationType().equals(encapsulationType)) {
+ // Encap type not changed.
+ return;
+ }
+ vplsData.encapsulationType(encapsulationType);
+ updateVplsStatus(vplsData, VplsData.VplsState.UPDATING);
+ }
+
+ @Override
+ public VplsData getVpls(String vplsName) {
+ requireNonNull(vplsName);
+ return vplsStore.getVpls(vplsName);
+ }
+
+ @Override
+ public Collection<Interface> removeInterfaces(VplsData vplsData, Collection<Interface> interfaces) {
+ requireNonNull(vplsData);
+ requireNonNull(interfaces);
+ vplsData.removeInterfaces(interfaces);
+ updateVplsStatus(vplsData, VplsData.VplsState.UPDATING);
+ return interfaces;
+ }
+
+ @Override
+ public Interface removeInterface(VplsData vplsData, Interface iface) {
+ requireNonNull(vplsData);
+ requireNonNull(iface);
+ vplsData.removeInterface(iface);
+ updateVplsStatus(vplsData, VplsData.VplsState.UPDATING);
+ return iface;
+ }
+
+ @Override
+ public void removeAllVpls() {
+ Set<VplsData> allVplses = ImmutableSet.copyOf(vplsStore.getAllVpls());
+ allVplses.forEach(this::removeVpls);
+ }
+
+ @Override
+ public Collection<VplsData> getAllVpls() {
+ return ImmutableSet.copyOf(vplsStore.getAllVpls());
+ }
+
+ /**
+ * Updates VPLS status to the store.
+ *
+ * @param vplsData the VPLS
+ * @param vplsState the new state to the VPLS
+ */
+ private void updateVplsStatus(VplsData vplsData, VplsData.VplsState vplsState) {
+ vplsData.state(vplsState);
+ vplsStore.updateVpls(vplsData);
+ }
+
+ /**
+ * A listener for host events.
+ * Updates a VPLS if host added or removed.
+ */
+ class VplsHostListener implements HostListener {
+ @Override
+ public void event(HostEvent event) {
+ Host host = event.subject();
+ Interface iface = getHostInterface(host);
+ if (iface == null) {
+ return;
+ }
+ VplsData vplsData = vplsStore.getAllVpls().stream()
+ .filter(v -> v.interfaces().contains(iface))
+ .findFirst()
+ .orElse(null);
+ if (vplsData == null) {
+ // the host does not related to any vpls
+ return;
+ }
+ updateVplsStatus(vplsData, VplsData.VplsState.UPDATING);
+ }
+
+ /**
+ * Gets the network interface of the host.
+ *
+ * @param host the host
+ * @return the network interface of the host; null if no network
+ * interface found
+ */
+ private Interface getHostInterface(Host host) {
+ Set<Interface> interfaces = interfaceService.getInterfaces();
+ return interfaces.stream()
+ .filter(iface -> iface.connectPoint().equals(host.location()) &&
+ iface.vlan().equals(host.vlan()))
+ .findFirst()
+ .orElse(null);
+ }
+ }
+
+ /**
+ * Store delegate for VPLS store.
+ * Handles VPLS store event and generate VPLS operation according to event
+ * type.
+ */
+ class VplsStoreDelegate implements StoreDelegate<VplsStoreEvent> {
+
+ @Override
+ public void notify(VplsStoreEvent event) {
+ VplsOperation vplsOperation;
+ VplsOperation.Operation op;
+ VplsData vplsData = event.subject();
+ switch (event.type()) {
+ case ADD:
+ op = VplsOperation.Operation.ADD;
+ break;
+ case REMOVE:
+ op = VplsOperation.Operation.REMOVE;
+ break;
+ case UPDATE:
+ if (vplsData.state() == VplsData.VplsState.FAILED ||
+ vplsData.state() == VplsData.VplsState.ADDED ||
+ vplsData.state() == VplsData.VplsState.REMOVED) {
+ // Update the state only. Nothing to do if it is updated
+ // to ADDED, REMOVED or FAILED
+ op = null;
+ } else {
+ op = VplsOperation.Operation.UPDATE;
+ }
+ break;
+ default:
+ log.warn(UNSUPPORTED_STORE_EVENT_TYPE, event.type());
+ return;
+ }
+ if (op != null) {
+ vplsOperation = VplsOperation.of(vplsData, op);
+ operationService.submit(vplsOperation);
+ }
+ }
+ }
+}
diff --git a/apps/vpls/src/main/java/org/onosproject/vpls/VplsNeighbourHandler.java b/apps/vpls/src/main/java/org/onosproject/vpls/VplsNeighbourHandler.java
index de4365f..8a3ac7d 100644
--- a/apps/vpls/src/main/java/org/onosproject/vpls/VplsNeighbourHandler.java
+++ b/apps/vpls/src/main/java/org/onosproject/vpls/VplsNeighbourHandler.java
@@ -15,12 +15,13 @@
*/
package org.onosproject.vpls;
-import com.google.common.collect.SetMultimap;
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.onlab.packet.MacAddress;
+import org.onlab.packet.VlanId;
import org.onosproject.core.ApplicationId;
import org.onosproject.core.CoreService;
import org.onosproject.incubator.net.intf.Interface;
@@ -30,16 +31,20 @@
import org.onosproject.incubator.net.neighbour.NeighbourMessageContext;
import org.onosproject.incubator.net.neighbour.NeighbourMessageHandler;
import org.onosproject.incubator.net.neighbour.NeighbourResolutionService;
+import org.onosproject.net.ConnectPoint;
import org.onosproject.net.Host;
import org.onosproject.net.config.NetworkConfigEvent;
import org.onosproject.net.config.NetworkConfigListener;
import org.onosproject.net.config.NetworkConfigService;
-import org.onosproject.net.device.DeviceService;
import org.onosproject.net.host.HostService;
-import org.onosproject.vpls.config.VplsConfigService;
+import org.onosproject.vpls.api.VplsData;
+import org.onosproject.vpls.api.VplsStore;
import org.slf4j.Logger;
+import java.util.Collection;
+import java.util.Objects;
import java.util.Set;
+import java.util.stream.Collectors;
import static org.slf4j.LoggerFactory.getLogger;
@@ -58,16 +63,13 @@
protected CoreService coreService;
@Reference(cardinality = ReferenceCardinality.MANDATORY_UNARY)
- protected DeviceService deviceService;
-
- @Reference(cardinality = ReferenceCardinality.MANDATORY_UNARY)
protected InterfaceService interfaceService;
@Reference(cardinality = ReferenceCardinality.MANDATORY_UNARY)
protected NeighbourResolutionService neighbourService;
@Reference(cardinality = ReferenceCardinality.MANDATORY_UNARY)
- protected VplsConfigService vplsConfigService;
+ protected VplsStore vplsStore;
@Reference(cardinality = ReferenceCardinality.MANDATORY_UNARY)
protected NetworkConfigService configService;
@@ -88,7 +90,7 @@
@Activate
protected void activate() {
- appId = coreService.registerApplication(Vpls.VPLS_APP);
+ appId = coreService.registerApplication(VplsManager.VPLS_APP);
interfaceService.addListener(interfaceListener);
configService.addListener(configListener);
configNeighbourHandler();
@@ -101,18 +103,16 @@
neighbourService.unregisterNeighbourHandlers(appId);
}
- private void configNeighbourHandler() {
+ /**
+ * Registers neighbour handler to all available interfaces.
+ */
+ protected void configNeighbourHandler() {
neighbourService.unregisterNeighbourHandlers(appId);
- Set<Interface> interfaces = vplsConfigService.allIfaces();
-
- interfaceService.getInterfaces()
- .stream()
- .filter(interfaces::contains)
- .forEach(intf -> {
- neighbourService.registerNeighbourHandler(intf,
- neighbourHandler,
- appId);
- });
+ interfaceService
+ .getInterfaces()
+ .forEach(intf -> neighbourService.registerNeighbourHandler(intf,
+ neighbourHandler,
+ appId));
}
/**
@@ -123,16 +123,13 @@
@Override
public void handleMessage(NeighbourMessageContext context,
HostService hostService) {
-
switch (context.type()) {
case REQUEST:
handleRequest(context);
break;
-
case REPLY:
handleReply(context, hostService);
break;
-
default:
log.warn(UNKNOWN_CONTEXT, context.type());
break;
@@ -146,16 +143,15 @@
* @param context the message context
*/
protected void handleRequest(NeighbourMessageContext context) {
- SetMultimap<String, Interface> interfaces =
- vplsConfigService.ifacesByVplsName(context.vlan(),
- context.inPort());
- if (interfaces != null) {
- interfaces.values().stream()
+ // Find target VPLS first, then broadcast to all interface of this VPLS
+ VplsData vplsData = findVpls(context);
+ if (vplsData != null) {
+ vplsData.interfaces().stream()
.filter(intf -> !context.inPort().equals(intf.connectPoint()))
.forEach(context::forward);
-
} else {
- log.debug(CAN_NOT_FIND_VPLS, context.inPort(), context.vlan());
+ log.warn(CAN_NOT_FIND_VPLS, context.inPort(), context.vlan());
+ context.drop();
}
}
@@ -167,21 +163,66 @@
*/
protected void handleReply(NeighbourMessageContext context,
HostService hostService) {
- Set<Host> hosts = hostService.getHostsByMac(context.dstMac());
- SetMultimap<String, Interface> interfaces =
- vplsConfigService.ifacesByVplsName(context.vlan(),
- context.inPort());
- if (interfaces != null) {
- hosts.forEach(host -> interfaces.values().stream()
- .filter(intf -> intf.connectPoint().equals(host.location()))
- .filter(intf -> intf.vlan().equals(host.vlan()))
- .forEach(context::forward));
+ // Find target VPLS, then reply to the host
+ VplsData vplsData = findVpls(context);
+ if (vplsData != null) {
+ MacAddress dstMac = context.dstMac();
+ Set<Host> hosts = hostService.getHostsByMac(dstMac);
+ hosts = hosts.stream()
+ .filter(host -> vplsData.interfaces().contains(getHostInterface(host)))
+ .collect(Collectors.toSet());
+
+ // reply to all host in same VPLS
+ hosts.stream()
+ .map(this::getHostInterface)
+ .filter(Objects::nonNull)
+ .forEach(context::forward);
} else {
- log.debug(CAN_NOT_FIND_VPLS, context.inPort(), context.vlan());
+ // this might be happened when we remove an interface from VPLS
+ // just ignore this message
+ log.warn(CAN_NOT_FIND_VPLS, context.inPort(), context.vlan());
+ context.drop();
}
}
/**
+ * Finds the VPLS with given neighbour message context.
+ *
+ * @param context the neighbour message context
+ * @return the VPLS for specific neighbour message context
+ */
+ private VplsData findVpls(NeighbourMessageContext context) {
+ Collection<VplsData> vplses = vplsStore.getAllVpls();
+ for (VplsData vplsData : vplses) {
+ Set<Interface> interfaces = vplsData.interfaces();
+ ConnectPoint port = context.inPort();
+ VlanId vlanId = context.vlan();
+ boolean match = interfaces.stream()
+ .anyMatch(iface -> iface.connectPoint().equals(port) &&
+ iface.vlan().equals(vlanId));
+ if (match) {
+ return vplsData;
+ }
+ }
+ return null;
+ }
+
+ /**
+ * Finds the network interface related to the host.
+ *
+ * @param host the host
+ * @return the interface related to the host
+ */
+ private Interface getHostInterface(Host host) {
+ Set<Interface> interfaces = interfaceService.getInterfaces();
+ return interfaces.stream()
+ .filter(iface -> iface.connectPoint().equals(host.location()) &&
+ iface.vlan().equals(host.vlan()))
+ .findFirst()
+ .orElse(null);
+ }
+
+ /**
* Listener for interface configuration events.
*/
private class VplsInterfaceListener implements InterfaceListener {
diff --git a/apps/vpls/src/main/java/org/onosproject/vpls/VplsOperationManager.java b/apps/vpls/src/main/java/org/onosproject/vpls/VplsOperationManager.java
new file mode 100644
index 0000000..4c0262d
--- /dev/null
+++ b/apps/vpls/src/main/java/org/onosproject/vpls/VplsOperationManager.java
@@ -0,0 +1,645 @@
+/*
+ * Copyright 2017-present 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.vpls;
+
+import com.google.common.collect.Maps;
+import com.google.common.collect.Queues;
+import com.google.common.collect.Sets;
+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.util.Tools;
+import org.onosproject.cluster.ClusterService;
+import org.onosproject.cluster.LeadershipEvent;
+import org.onosproject.cluster.LeadershipEventListener;
+import org.onosproject.cluster.LeadershipService;
+import org.onosproject.cluster.NodeId;
+import org.onosproject.core.ApplicationId;
+import org.onosproject.core.CoreService;
+import org.onosproject.incubator.net.intf.Interface;
+import org.onosproject.net.Host;
+import org.onosproject.net.host.HostService;
+import org.onosproject.net.intent.Intent;
+import org.onosproject.net.intent.IntentEvent;
+import org.onosproject.net.intent.IntentException;
+import org.onosproject.net.intent.IntentListener;
+import org.onosproject.net.intent.IntentService;
+import org.onosproject.net.intent.IntentUtils;
+import org.onosproject.net.intent.Key;
+import org.onosproject.net.intent.MultiPointToSinglePointIntent;
+import org.onosproject.net.intent.SinglePointToMultiPointIntent;
+import org.onosproject.vpls.api.VplsData;
+import org.onosproject.vpls.api.VplsOperationException;
+import org.onosproject.vpls.api.VplsOperationService;
+import org.onosproject.vpls.api.VplsOperation;
+import org.onosproject.vpls.api.VplsStore;
+import org.onosproject.vpls.intent.VplsIntentUtility;
+import org.slf4j.Logger;
+
+import java.util.Collection;
+import java.util.Deque;
+import java.util.Map;
+import java.util.Set;
+import java.util.concurrent.CompletableFuture;
+import java.util.concurrent.ExecutionException;
+import java.util.concurrent.ExecutorService;
+import java.util.concurrent.Executors;
+import java.util.concurrent.ScheduledExecutorService;
+import java.util.concurrent.TimeUnit;
+import java.util.concurrent.TimeoutException;
+import java.util.function.Consumer;
+import java.util.stream.Collectors;
+import java.util.stream.Stream;
+
+import static org.onlab.util.BoundedThreadPool.newFixedThreadPool;
+import static org.onlab.util.Tools.groupedThreads;
+import static org.slf4j.LoggerFactory.getLogger;
+
+/**
+ * An implementation of VplsOperationService.
+ * Handles the execution order of the VPLS operations generated by the
+ * application.
+ */
+@Component(immediate = true)
+@Service
+public class VplsOperationManager implements VplsOperationService {
+ private static final int NUM_THREADS = 4;
+
+ @Reference(cardinality = ReferenceCardinality.MANDATORY_UNARY)
+ protected CoreService coreService;
+
+ @Reference(cardinality = ReferenceCardinality.MANDATORY_UNARY)
+ protected IntentService intentService;
+
+ @Reference(cardinality = ReferenceCardinality.MANDATORY_UNARY)
+ protected LeadershipService leadershipService;
+
+ @Reference(cardinality = ReferenceCardinality.MANDATORY_UNARY)
+ protected ClusterService clusterService;
+
+ @Reference(cardinality = ReferenceCardinality.MANDATORY_UNARY)
+ protected HostService hostService;
+
+ @Reference(cardinality = ReferenceCardinality.MANDATORY_UNARY)
+ protected VplsStore vplsStore;
+
+ private final Logger log = getLogger(getClass());
+ protected Map<String, Deque<VplsOperation>> pendingVplsOperations;
+ protected final Map<String, VplsOperation> runningOperations = Maps.newHashMap();
+ protected ScheduledExecutorService schedulerExecutor;
+ protected ExecutorService workerExecutor;
+ protected ApplicationId appId;
+ protected boolean isLeader;
+ protected NodeId localNodeId;
+ protected LeadershipEventListener leadershipEventListener;
+
+ @Activate
+ public void activate() {
+ appId = coreService.registerApplication(VplsManager.VPLS_APP);
+ localNodeId = clusterService.getLocalNode().id();
+
+ leadershipEventListener = new InternalLeadershipListener();
+ leadershipService.addListener(leadershipEventListener);
+ leadershipService.runForLeadership(appId.name());
+ pendingVplsOperations = Maps.newConcurrentMap();
+
+ // Thread pool for VplsOperationExecutor
+ workerExecutor = newFixedThreadPool(NUM_THREADS,
+ groupedThreads("onos/apps/vpls",
+ "worker-%d",
+ log));
+ // A single thread pool for VplsOperationScheduler
+ schedulerExecutor = Executors.newScheduledThreadPool(1,
+ groupedThreads("onos/apps/vpls",
+ "scheduler-%d",
+ log));
+ // Start the scheduler
+ schedulerExecutor.scheduleAtFixedRate(new VplsOperationScheduler(),
+ 0,
+ 500,
+ TimeUnit.MILLISECONDS);
+
+ }
+
+ @Deactivate
+ public void deactivate() {
+ pendingVplsOperations.clear();
+ runningOperations.clear();
+ leadershipService.removeListener(leadershipEventListener);
+ schedulerExecutor.shutdown();
+ workerExecutor.shutdown();
+
+ // remove all intents from VPLS application when deactivated
+ Tools.stream(intentService.getIntents())
+ .filter(intent -> intent.appId().equals(appId))
+ .forEach(intentService::withdraw);
+ }
+
+ @Override
+ public void submit(VplsOperation vplsOperation) {
+ if (isLeader) {
+ // Only leader can execute operation
+ addVplsOperation(vplsOperation);
+ }
+ }
+
+ /**
+ * Adds a VPLS operation to the queue of pending operations.
+ *
+ * @param vplsOperation the VPLS operation to add
+ */
+ private void addVplsOperation(VplsOperation vplsOperation) {
+ VplsData vplsData = vplsOperation.vpls();
+ pendingVplsOperations.compute(vplsData.name(), (name, opQueue) -> {
+ opQueue = opQueue == null ? Queues.newArrayDeque() : opQueue;
+
+ // If the operation already exist in queue, ignore it.
+ if (opQueue.contains(vplsOperation)) {
+ return opQueue;
+ }
+ opQueue.add(vplsOperation);
+ return opQueue;
+ });
+ }
+
+ /**
+ * Optimizes the VPLS operation queue and return a single VPLS operation to
+ * execute.
+ *
+ * @param operations the queue to be optimized
+ * @return optimized VPLS operation from the queue
+ */
+ protected static VplsOperation getOptimizedVplsOperation(Deque<VplsOperation> operations) {
+ if (operations.isEmpty()) {
+ return null;
+ }
+ // no need to optimize if the queue contains only one operation
+ if (operations.size() == 1) {
+ return operations.getFirst();
+ }
+
+ final VplsOperation firstOperation = operations.peekFirst();
+ final VplsOperation lastOperation = operations.peekLast();
+ final VplsOperation.Operation firstOp = firstOperation.op();
+ final VplsOperation.Operation lastOp = lastOperation.op();
+
+ if (firstOp.equals(VplsOperation.Operation.REMOVE)) {
+ if (lastOp.equals(VplsOperation.Operation.REMOVE)) {
+ // case 1: both first and last operation are REMOVE; do remove
+ return firstOperation;
+ } else if (lastOp.equals(VplsOperation.Operation.ADD)) {
+ // case 2: if first is REMOVE, and last is ADD; do update
+ return VplsOperation.of(lastOperation.vpls(),
+ VplsOperation.Operation.UPDATE);
+ } else {
+ // case 3: first is REMOVE, last is UPDATE; do update
+ return lastOperation;
+ }
+ } else if (firstOp.equals(VplsOperation.Operation.ADD)) {
+ if (lastOp.equals(VplsOperation.Operation.REMOVE)) {
+ // case 4: first is ADD, last is REMOVE; nothing to do
+ return null;
+ } else if (lastOp.equals(VplsOperation.Operation.ADD)) {
+ // case 5: both first and last are ADD, do add
+ return VplsOperation.of(lastOperation.vpls(),
+ VplsOperation.Operation.ADD);
+ } else {
+ // case 6: first is ADD and last is update, do add
+ return VplsOperation.of(lastOperation.vpls(),
+ VplsOperation.Operation.ADD);
+ }
+ } else {
+ if (lastOp.equals(VplsOperation.Operation.REMOVE)) {
+ // case 7: last is remove, do remove
+ return lastOperation;
+ } else if (lastOp.equals(VplsOperation.Operation.ADD)) {
+ // case 8: do update only
+ return VplsOperation.of(lastOperation.vpls(),
+ VplsOperation.Operation.UPDATE);
+ } else {
+ // case 9: from UPDATE to UPDATE
+ // only need last UPDATE operation
+ return VplsOperation.of(lastOperation.vpls(),
+ VplsOperation.Operation.UPDATE);
+ }
+ }
+ }
+
+ /**
+ * Scheduler for VPLS operation.
+ * Processes a batch of VPLS operations in a period.
+ */
+ class VplsOperationScheduler implements Runnable {
+ private static final String UNKNOWN_STATE =
+ "Unknown state {} for success consumer";
+ private static final String OP_EXEC_ERR =
+ "Error when executing VPLS operation {}, error: {}";
+
+ /**
+ * Process a batch of VPLS operations.
+ */
+ @Override
+ public void run() {
+ Set<String> vplsNames = pendingVplsOperations.keySet();
+ vplsNames.forEach(vplsName -> {
+ VplsOperation operation;
+ synchronized (runningOperations) {
+ // Only one operation for a VPLS at the same time
+ if (runningOperations.containsKey(vplsName)) {
+ return;
+ }
+ Deque<VplsOperation> operations = pendingVplsOperations.remove(vplsName);
+ operation = getOptimizedVplsOperation(operations);
+ if (operation == null) {
+ // Nothing to do, this only happened when we add a VPLS
+ // and remove it before batch operations been processed.
+ return;
+ }
+ runningOperations.put(vplsName, operation);
+ }
+
+ VplsOperationExecutor operationExecutor =
+ new VplsOperationExecutor(operation);
+ operationExecutor.setConsumers(
+ (vplsOperation) -> {
+ // Success consumer
+ VplsData vplsData = vplsOperation.vpls();
+ log.debug("VPLS operation success: {}", vplsOperation);
+ switch (vplsData.state()) {
+ case ADDING:
+ case UPDATING:
+ vplsData.state(VplsData.VplsState.ADDED);
+ vplsStore.updateVpls(vplsData);
+ break;
+ case REMOVING:
+ // The VPLS information does not exists in
+ // store. No need to update the store.
+ break;
+ default:
+ log.warn(UNKNOWN_STATE, vplsData.state());
+ vplsData.state(VplsData.VplsState.FAILED);
+ vplsStore.updateVpls(vplsData);
+ break;
+ }
+ runningOperations.remove(vplsName);
+ },
+ (vplsOperationException) -> {
+ // Error consumer
+ VplsOperation vplsOperation =
+ vplsOperationException.vplsOperation();
+ log.debug("VPLS operation failed: {}", vplsOperation);
+ VplsData vplsData = vplsOperation.vpls();
+ vplsData.state(VplsData.VplsState.FAILED);
+ vplsStore.updateVpls(vplsData);
+ log.error(OP_EXEC_ERR,
+ vplsOperation.toString(),
+ vplsOperationException.getMessage());
+ runningOperations.remove(vplsName);
+ });
+ log.debug("Applying operation: {}", operation);
+ workerExecutor.execute(operationExecutor);
+ });
+ }
+ }
+
+ /**
+ * Direction for Intent installation.
+ */
+ private enum Direction {
+ ADD,
+ REMOVE
+ }
+
+ /**
+ * VPLS operation executor.
+ * Installs, updates or removes Intents according to the given VPLS operation.
+ */
+ class VplsOperationExecutor implements Runnable {
+ private static final String UNKNOWN_OP = "Unknown operation.";
+ private static final String UNKNOWN_INTENT_DIR = "Unknown Intent install direction.";
+ private static final int OPERATION_TIMEOUT = 10;
+ private VplsOperation vplsOperation;
+ private Consumer<VplsOperation> successConsumer;
+ private Consumer<VplsOperationException> errorConsumer;
+ private VplsOperationException error;
+
+ public VplsOperationExecutor(VplsOperation vplsOperation) {
+ this.vplsOperation = vplsOperation;
+ this.error = null;
+ }
+
+ /**
+ * Sets success consumer and error consumer for this executor.
+ *
+ * @param successConsumer the success consumer
+ * @param errorConsumer the error consumer
+ */
+ public void setConsumers(Consumer<VplsOperation> successConsumer,
+ Consumer<VplsOperationException> errorConsumer) {
+ this.successConsumer = successConsumer;
+ this.errorConsumer = errorConsumer;
+
+ }
+
+ @Override
+ public void run() {
+ switch (vplsOperation.op()) {
+ case ADD:
+ installVplsIntents();
+ break;
+ case REMOVE:
+ removeVplsIntents();
+ break;
+ case UPDATE:
+ updateVplsIntents();
+ break;
+ default:
+ this.error = new VplsOperationException(vplsOperation,
+ UNKNOWN_OP);
+ break;
+ }
+
+ if (this.error != null) {
+ errorConsumer.accept(this.error);
+ } else {
+ successConsumer.accept(vplsOperation);
+ }
+ }
+
+ /**
+ * Updates Intents of the VPLS.
+ */
+ private void updateVplsIntents() {
+ // check which part we need to update
+ // if we update host only, we don't need to reinstall
+ // every Intents
+ Set<Intent> intentsToInstall = Sets.newHashSet();
+ Set<Intent> intentsToUninstall = Sets.newHashSet();
+ VplsData vplsData = vplsOperation.vpls();
+ Set<Intent> currentIntents = getCurrentIntents();
+
+ // Compares broadcast Intents
+ Set<Intent> currentBrcIntents = currentIntents.stream()
+ .filter(intent -> intent instanceof SinglePointToMultiPointIntent)
+ .collect(Collectors.toSet());
+ Set<Intent> targetBrcIntents = VplsIntentUtility.buildBrcIntents(vplsData, appId);
+ if (!intentSetEquals(currentBrcIntents, targetBrcIntents)) {
+ // If broadcast Intents changes, it means some network
+ // interfaces or encapsulation constraint changed; Need to
+ // reinstall all intents
+ removeVplsIntents();
+ installVplsIntents();
+ return;
+ }
+
+ // Compares unicast Intents
+ Set<Intent> currentUniIntents = currentIntents.stream()
+ .filter(intent -> intent instanceof MultiPointToSinglePointIntent)
+ .collect(Collectors.toSet());
+ Set<Intent> targetUniIntents = VplsIntentUtility.buildUniIntents(vplsData,
+ hostsFromVpls(),
+ appId);
+
+ // New unicast Intents to install
+ targetUniIntents.forEach(intent -> {
+ if (!currentUniIntents.contains(intent)) {
+ intentsToInstall.add(intent);
+ }
+ });
+
+ // Old unicast Intents to remove
+ currentUniIntents.forEach(intent -> {
+ if (!targetUniIntents.contains(intent)) {
+ intentsToUninstall.add(intent);
+ }
+ });
+ applyIntentsSync(intentsToUninstall, Direction.REMOVE);
+ applyIntentsSync(intentsToInstall, Direction.ADD);
+ }
+
+ private Set<Host> hostsFromVpls() {
+ VplsData vplsData = vplsOperation.vpls();
+ Set<Interface> interfaces = vplsData.interfaces();
+ return interfaces.stream()
+ .map(this::hostsFromInterface)
+ .flatMap(Collection::stream)
+ .collect(Collectors.toSet());
+ }
+
+ private Set<Host> hostsFromInterface(Interface iface) {
+ return hostService.getConnectedHosts(iface.connectPoint())
+ .stream()
+ .filter(host -> host.vlan().equals(iface.vlan()))
+ .collect(Collectors.toSet());
+ }
+
+ /**
+ * Applies Intents synchronously with a specific direction.
+ *
+ * @param intents the Intents
+ * @param direction the direction
+ */
+ private void applyIntentsSync(Set<Intent> intents, Direction direction) {
+ Set<Key> pendingIntentKeys = intents.stream()
+ .map(Intent::key).collect(Collectors.toSet());
+ IntentCompleter completer;
+
+ switch (direction) {
+ case ADD:
+ completer = new IntentCompleter(pendingIntentKeys,
+ IntentEvent.Type.INSTALLED);
+ intentService.addListener(completer);
+ intents.forEach(intentService::submit);
+ break;
+ case REMOVE:
+ completer = new IntentCompleter(pendingIntentKeys,
+ IntentEvent.Type.WITHDRAWN);
+ intentService.addListener(completer);
+ intents.forEach(intentService::withdraw);
+ break;
+ default:
+ this.error = new VplsOperationException(this.vplsOperation,
+ UNKNOWN_INTENT_DIR);
+ return;
+ }
+
+ try {
+ // Wait until Intent operation completed
+ completer.complete();
+ } catch (VplsOperationException e) {
+ this.error = e;
+ } finally {
+ intentService.removeListener(completer);
+ }
+ }
+
+ /**
+ * Checks if two sets of Intents are equal.
+ *
+ * @param intentSet1 the first set of Intents
+ * @param intentSet2 the second set of Intents
+ * @return true if both set of Intents are equal; otherwise false
+ */
+ private boolean intentSetEquals(Set<Intent> intentSet1, Set<Intent> intentSet2) {
+ if (intentSet1.size() != intentSet2.size()) {
+ return false;
+ }
+ for (Intent intent1 : intentSet1) {
+ if (intentSet2.stream()
+ .noneMatch(intent2 -> IntentUtils.intentsAreEqual(intent1, intent2))) {
+ return false;
+ }
+ }
+ return true;
+ }
+
+ /**
+ * Retrieves installed Intents from IntentService which related to
+ * specific VPLS.
+ *
+ * @return the Intents which related to the VPLS
+ */
+ private Set<Intent> getCurrentIntents() {
+ VplsData vplsData = vplsOperation.vpls();
+ String vplsName = vplsData.name();
+ return Tools.stream(intentService.getIntents())
+ .filter(intent -> intent.key().toString().startsWith(vplsName))
+ .collect(Collectors.toSet());
+ }
+
+ /**
+ * Generates unicast Intents and broadcast Intents for the VPLS.
+ *
+ * @return Intents for the VPLS
+ */
+ private Set<Intent> generateVplsIntents() {
+ VplsData vplsData = vplsOperation.vpls();
+ Set<Intent> brcIntents = VplsIntentUtility.buildBrcIntents(vplsData, appId);
+ Set<Intent> uniIntent = VplsIntentUtility.buildUniIntents(vplsData, hostsFromVpls(), appId);
+
+ return Stream.concat(brcIntents.stream(), uniIntent.stream())
+ .collect(Collectors.toSet());
+ }
+
+ /**
+ * Removes all Intents from the VPLS.
+ */
+ private void removeVplsIntents() {
+ Set<Intent> intentsToWithdraw = getCurrentIntents();
+ applyIntentsSync(intentsToWithdraw, Direction.REMOVE);
+ }
+
+ /**
+ * Installs Intents of the VPLS.
+ */
+ private void installVplsIntents() {
+ Set<Intent> intentsToInstall = generateVplsIntents();
+ applyIntentsSync(intentsToInstall, Direction.ADD);
+ }
+
+ /**
+ * Helper class which monitors if all Intent operations are completed.
+ */
+ class IntentCompleter implements IntentListener {
+ private static final String INTENT_COMPILE_ERR = "Got {} from intent completer";
+ private CompletableFuture<Void> completableFuture;
+ private Set<Key> pendingIntentKeys;
+ private IntentEvent.Type expectedEventType;
+
+ /**
+ * Initialize completer with given Intent keys and expect Intent
+ * event type.
+ *
+ * @param pendingIntentKeys the Intent keys to wait
+ * @param expectedEventType expect Intent event type
+ */
+ public IntentCompleter(Set<Key> pendingIntentKeys, IntentEvent.Type expectedEventType) {
+ this.completableFuture = new CompletableFuture<>();
+ this.pendingIntentKeys = Sets.newConcurrentHashSet(pendingIntentKeys);
+ this.expectedEventType = expectedEventType;
+ }
+
+ @Override
+ public void event(IntentEvent event) {
+ Intent intent = event.subject();
+ // Intent failed, throw an exception to completable future
+ if (event.type() == IntentEvent.Type.CORRUPT ||
+ event.type() == IntentEvent.Type.FAILED) {
+ completableFuture.completeExceptionally(new IntentException(intent.toString()));
+ return;
+ }
+ // If event type matched to expected type, remove from pending
+ if (event.type() == expectedEventType) {
+ Key key = intent.key();
+ pendingIntentKeys.remove(key);
+ }
+ if (pendingIntentKeys.isEmpty()) {
+ completableFuture.complete(null);
+ }
+ }
+
+ /**
+ * Waits until all pending Intents completed ot timeout.
+ */
+ public void complete() {
+ // If no pending Intent keys, complete directly
+ if (pendingIntentKeys.isEmpty()) {
+ return;
+ }
+ try {
+ completableFuture.get(OPERATION_TIMEOUT, TimeUnit.SECONDS);
+ } catch (TimeoutException | InterruptedException |
+ ExecutionException | IntentException e) {
+ // TODO: handle errors more carefully
+ log.warn(INTENT_COMPILE_ERR, e.toString());
+ throw new VplsOperationException(vplsOperation, e.toString());
+ }
+ }
+ }
+ }
+
+ /**
+ * A listener for leadership events.
+ * Only the leader can process VPLS operation in the ONOS cluster.
+ */
+ private class InternalLeadershipListener implements LeadershipEventListener {
+ private static final String LEADER_CHANGE = "Change leader to {}";
+
+ @Override
+ public void event(LeadershipEvent event) {
+ switch (event.type()) {
+ case LEADER_CHANGED:
+ case LEADER_AND_CANDIDATES_CHANGED:
+ isLeader = localNodeId.equals(event.subject().leaderNodeId());
+ if (isLeader) {
+ log.debug(LEADER_CHANGE, localNodeId);
+ }
+ break;
+ default:
+ break;
+ }
+ }
+
+ @Override
+ public boolean isRelevant(LeadershipEvent event) {
+ return event.subject().topic().equals(appId.name());
+ }
+ }
+}
diff --git a/apps/vpls/src/main/java/org/onosproject/vpls/api/Vpls.java b/apps/vpls/src/main/java/org/onosproject/vpls/api/Vpls.java
new file mode 100644
index 0000000..5dec2b2
--- /dev/null
+++ b/apps/vpls/src/main/java/org/onosproject/vpls/api/Vpls.java
@@ -0,0 +1,104 @@
+/*
+ * Copyright 2017-present 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.vpls.api;
+
+import org.onosproject.incubator.net.intf.Interface;
+import org.onosproject.net.EncapsulationType;
+
+import java.util.Collection;
+
+public interface Vpls {
+
+ /**
+ * Creates a new VPLS.
+ *
+ * @param vplsName the name of the VPLS
+ * @param encapsulationType the encapsulation type
+ * @return a VPLS instance if the operation is successful; null otherwise
+ */
+ VplsData createVpls(String vplsName, EncapsulationType encapsulationType);
+
+ /**
+ * Removes a VPLS.
+ *
+ * @param vplsData the VPLS to be removed
+ * @return the VPLS removed if the operation is successful; null otherwise
+ */
+ VplsData removeVpls(VplsData vplsData);
+
+ /**
+ * Adds network interfaces to a VPLS.
+ *
+ * @param vplsData the VPLS to which the interfaces have to be added to
+ * @param interfaces the interfaces to add
+ */
+ void addInterfaces(VplsData vplsData, Collection<Interface> interfaces);
+
+ /**
+ * Adds a network interface to a VPLS.
+ *
+ * @param vplsData the VPLS to which the interface has to be added to
+ * @param iface the interface to add
+ */
+ void addInterface(VplsData vplsData, Interface iface);
+
+ /**
+ * Sets an encapsulation type for a VPLS.
+ *
+ * @param vplsData the VPLS for which the encapsulation has to be set
+ * @param encapsulationType the encapsulation type
+ */
+ void setEncapsulationType(VplsData vplsData, EncapsulationType encapsulationType);
+
+ /**
+ * Retrieves a VPLS.
+ *
+ * @param vplsName the name of the VPLS
+ * @return the VPLS instance if the VPLS exists; null otherwise
+ */
+ VplsData getVpls(String vplsName);
+
+ /**
+ * Gets all VPLSs.
+ *
+ * @return a collection of VPLSs
+ */
+ Collection<VplsData> getAllVpls();
+
+ /**
+ * Removes the interfaces specified from a VPLS.
+ *
+ * @param vplsData the VPLS from which the interfaces are to be removed
+ * @param interfaces the interfaces to remove
+ * @return the interfaces removed
+ */
+ Collection<Interface> removeInterfaces(VplsData vplsData, Collection<Interface> interfaces);
+
+ /**
+ * Removes the interface specified from a VPLS.
+ *
+ * @param vplsData the VPLS from which the interface is to be removed
+ * @param iface the interface to remove
+ * @return the interface removed
+ */
+ Interface removeInterface(VplsData vplsData, Interface iface);
+
+ /**
+ * Removes all VPLSs and cleans up the VPLS configuration.
+ */
+ void removeAllVpls();
+}
diff --git a/apps/vpls/src/main/java/org/onosproject/vpls/api/VplsData.java b/apps/vpls/src/main/java/org/onosproject/vpls/api/VplsData.java
new file mode 100644
index 0000000..bba9d78
--- /dev/null
+++ b/apps/vpls/src/main/java/org/onosproject/vpls/api/VplsData.java
@@ -0,0 +1,183 @@
+/*
+ * Copyright 2017-present 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.vpls.api;
+
+import com.google.common.base.MoreObjects;
+import com.google.common.collect.ImmutableSet;
+import com.google.common.collect.Sets;
+import org.onosproject.incubator.net.intf.Interface;
+import org.onosproject.net.EncapsulationType;
+
+import java.util.Collection;
+import java.util.Objects;
+import java.util.Set;
+
+import static java.util.Objects.*;
+
+/**
+ * Class stores a VPLS information.
+ */
+public final class VplsData {
+ /**
+ * States of a VPLS.
+ */
+ public enum VplsState {
+ UPDATING,
+ ADDING,
+ REMOVING,
+ ADDED,
+ REMOVED,
+ FAILED
+ }
+
+ private String name;
+ private Set<Interface> interfaces;
+ private EncapsulationType encapsulationType;
+ private VplsState state;
+
+ /**
+ * Constructs a VPLS data by given name and encapsulation type.
+ *
+ * @param name the given name
+ * @param encapType the encapsulation type
+ */
+ private VplsData(String name, EncapsulationType encapType) {
+ this.name = name;
+ this.encapsulationType = encapType;
+ this.interfaces = Sets.newHashSet();
+ this.state = VplsState.ADDING;
+ }
+
+ /**
+ * Creates a VPLS data by given name.
+ * The encapsulation type of the VPLS will be NONE.
+ *
+ * @param name the given name
+ * @return the VPLS data
+ */
+ public static VplsData of(String name) {
+ requireNonNull(name);
+ return new VplsData(name, EncapsulationType.NONE);
+ }
+
+ /**
+ * Creates a VPLS data by given name and encapsulation type.
+ *
+ * @param name the given name
+ * @param encapType the encapsulation type
+ * @return the VPLS data
+ */
+ public static VplsData of(String name, EncapsulationType encapType) {
+ requireNonNull(name);
+ if (encapType == null) {
+ return new VplsData(name, EncapsulationType.NONE);
+ } else {
+ return new VplsData(name, encapType);
+ }
+ }
+
+ /**
+ * Creates a copy of VPLS data.
+ *
+ * @param vplsData the VPLS data
+ * @return the copy of the VPLS data
+ */
+ public static VplsData of(VplsData vplsData) {
+ requireNonNull(vplsData);
+ VplsData vplsDataCopy = new VplsData(vplsData.name(), vplsData.encapsulationType());
+ vplsDataCopy.addInterfaces(vplsData.interfaces());
+ return vplsData;
+ }
+
+ /**
+ * Gets name of the VPLS.
+ *
+ * @return the name of the VPLS
+ */
+ public String name() {
+ return name;
+ }
+
+ public Set<Interface> interfaces() {
+ return ImmutableSet.copyOf(interfaces);
+ }
+
+ public EncapsulationType encapsulationType() {
+ return encapsulationType;
+ }
+
+ public void addInterfaces(Collection<Interface> interfaces) {
+ requireNonNull(interfaces);
+ this.interfaces.addAll(interfaces);
+ }
+
+ public void addInterface(Interface iface) {
+ requireNonNull(iface);
+ this.interfaces.add(iface);
+ }
+
+ public void removeInterfaces(Collection<Interface> interfaces) {
+ requireNonNull(interfaces);
+ this.interfaces.removeAll(interfaces);
+ }
+
+ public void removeInterface(Interface iface) {
+ requireNonNull(iface);
+ this.interfaces.remove(iface);
+ }
+
+ public void encapsulationType(EncapsulationType encapType) {
+ this.encapsulationType = encapType;
+ }
+
+ public VplsState state() {
+ return state;
+ }
+
+ public void state(VplsState state) {
+ this.state = state;
+ }
+
+ @Override
+ public String toString() {
+ return MoreObjects.toStringHelper(getClass())
+ .add("name", name)
+ .add("interfaces", interfaces)
+ .add("encap type", encapsulationType)
+ .add("state", state)
+ .toString();
+ }
+
+ @Override
+ public boolean equals(Object obj) {
+ if (obj == this) {
+ return true;
+ }
+ if (!(obj instanceof VplsData)) {
+ return false;
+ }
+ VplsData other = (VplsData) obj;
+ return Objects.equals(other.name, this.name) &&
+ Objects.equals(other.interfaces, this.interfaces) &&
+ Objects.equals(other.encapsulationType, this.encapsulationType);
+ }
+
+ @Override
+ public int hashCode() {
+ return hash(name, interfaces, encapsulationType);
+ }
+}
diff --git a/apps/vpls/src/main/java/org/onosproject/vpls/api/VplsOperation.java b/apps/vpls/src/main/java/org/onosproject/vpls/api/VplsOperation.java
new file mode 100644
index 0000000..abc5025
--- /dev/null
+++ b/apps/vpls/src/main/java/org/onosproject/vpls/api/VplsOperation.java
@@ -0,0 +1,110 @@
+/*
+ * Copyright 2017-present 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.vpls.api;
+
+import com.google.common.base.MoreObjects;
+
+import java.util.Objects;
+
+import static java.util.Objects.*;
+
+/**
+ * Operation for VPLS.
+ */
+public class VplsOperation {
+
+ /**
+ * The operation type.
+ */
+ public enum Operation {
+ REMOVE,
+ ADD,
+ UPDATE
+ }
+
+ private VplsData vplsData;
+ private Operation op;
+
+ /**
+ * Defines a VPLS operation by binding a given VPLS and operation type.
+ *
+ * @param vplsData the VPLS
+ * @param op the operation
+ */
+ protected VplsOperation(VplsData vplsData, Operation op) {
+ requireNonNull(vplsData);
+ requireNonNull(op);
+ // Make a copy of the VPLS data to ensure other thread won't change it.
+ this.vplsData = VplsData.of(vplsData);
+ this.op = op;
+ }
+
+ /**
+ * Defines a VPLS operation by binding a given VPLS and operation type.
+ *
+ * @param vplsData the VPLS
+ * @param op the operation
+ * @return the VPLS operation
+ */
+ public static VplsOperation of(VplsData vplsData, Operation op) {
+ return new VplsOperation(vplsData, op);
+ }
+
+ /**
+ * Retrieves the VPLS from the operation.
+ *
+ * @return the VPLS
+ */
+ public VplsData vpls() {
+ return vplsData;
+ }
+
+ /**
+ * Retrieves the operation type from the operation.
+ *
+ * @return the operation type
+ */
+ public Operation op() {
+ return op;
+ }
+
+ @Override
+ public String toString() {
+ return MoreObjects.toStringHelper(getClass())
+ .add("vplsData", vplsData.toString())
+ .add("op", op.toString())
+ .toString();
+ }
+
+ @Override
+ public boolean equals(Object obj) {
+ if (obj == this) {
+ return true;
+ }
+ if (!(obj instanceof VplsOperation)) {
+ return false;
+ }
+ VplsOperation other = (VplsOperation) obj;
+ return Objects.equals(other.vplsData, this.vplsData) &&
+ Objects.equals(other.op, this.op);
+ }
+
+ @Override
+ public int hashCode() {
+ return hash(vplsData, op);
+ }
+}
diff --git a/apps/vpls/src/main/java/org/onosproject/vpls/api/VplsOperationException.java b/apps/vpls/src/main/java/org/onosproject/vpls/api/VplsOperationException.java
new file mode 100644
index 0000000..95dfdfa
--- /dev/null
+++ b/apps/vpls/src/main/java/org/onosproject/vpls/api/VplsOperationException.java
@@ -0,0 +1,45 @@
+/*
+ * Copyright 2017-present 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.vpls.api;
+
+/**
+ * Exception for VPLS operation.
+ */
+public class VplsOperationException extends RuntimeException {
+ private static final long serialVersionUID = 4514685940685335886L;
+ private VplsOperation vplsOperation;
+
+ /**
+ * Constructs a VPLS operation exception with given VPLS operation and
+ * message.
+ *
+ * @param operation the VPLS operation
+ * @param msg the description of the exception
+ */
+ public VplsOperationException(VplsOperation operation, String msg) {
+ super(msg);
+ this.vplsOperation = operation;
+ }
+
+ /**
+ * Gets VPLS operation for this exception.
+ * @return the VPLS operation
+ */
+ public VplsOperation vplsOperation() {
+ return vplsOperation;
+ }
+}
diff --git a/apps/vpls/src/main/java/org/onosproject/vpls/config/impl/package-info.java b/apps/vpls/src/main/java/org/onosproject/vpls/api/VplsOperationService.java
similarity index 62%
copy from apps/vpls/src/main/java/org/onosproject/vpls/config/impl/package-info.java
copy to apps/vpls/src/main/java/org/onosproject/vpls/api/VplsOperationService.java
index b5d6ec9..3044f7e 100644
--- a/apps/vpls/src/main/java/org/onosproject/vpls/config/impl/package-info.java
+++ b/apps/vpls/src/main/java/org/onosproject/vpls/api/VplsOperationService.java
@@ -1,5 +1,5 @@
/*
- * Copyright 2016-present Open Networking Laboratory
+ * Copyright 2017-present 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.
@@ -14,7 +14,17 @@
* limitations under the License.
*/
+package org.onosproject.vpls.api;
+
/**
- * Configuration service implementation for VPLS.
+ * Service for application submitting VPLS operation.
*/
-package org.onosproject.vpls.config.impl;
+public interface VplsOperationService {
+
+ /**
+ * Submits a VPLS operation.
+ *
+ * @param vplsOperation the VPLS operation to submit
+ */
+ void submit(VplsOperation vplsOperation);
+}
diff --git a/apps/vpls/src/main/java/org/onosproject/vpls/api/VplsStore.java b/apps/vpls/src/main/java/org/onosproject/vpls/api/VplsStore.java
new file mode 100644
index 0000000..caf7550
--- /dev/null
+++ b/apps/vpls/src/main/java/org/onosproject/vpls/api/VplsStore.java
@@ -0,0 +1,63 @@
+/*
+ * Copyright 2017-present 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.vpls.api;
+
+import org.onosproject.store.Store;
+import org.onosproject.store.StoreDelegate;
+import org.onosproject.vpls.store.VplsStoreEvent;
+
+import java.util.Collection;
+
+/**
+ * Definition of the operations regarding the management of the VPLS elements.
+ */
+public interface VplsStore extends Store<VplsStoreEvent, StoreDelegate<VplsStoreEvent>> {
+ /**
+ * Adds a VPLS to the configuration.
+ *
+ * @param vplsData the VPLS to add
+ */
+ void addVpls(VplsData vplsData);
+
+ /**
+ * Removes a VPLS from the configuration.
+ *
+ * @param vplsData the VPLS to remove
+ */
+ void removeVpls(VplsData vplsData);
+
+ /**
+ * Updates a VPLS.
+ *
+ * @param vplsData the VPLS to update
+ */
+ void updateVpls(VplsData vplsData);
+
+ /**
+ * Gets a VPLS by name.
+ *
+ * @param vplsName the VPLS name
+ * @return the VPLS instance if it exists; null otherwise
+ */
+ VplsData getVpls(String vplsName);
+
+ /**
+ * Gets all the VPLSs.
+ *
+ * @return all the VPLSs
+ */
+ Collection<VplsData> getAllVpls();
+}
diff --git a/apps/vpls/src/main/java/org/onosproject/vpls/config/impl/package-info.java b/apps/vpls/src/main/java/org/onosproject/vpls/api/package-info.java
similarity index 79%
rename from apps/vpls/src/main/java/org/onosproject/vpls/config/impl/package-info.java
rename to apps/vpls/src/main/java/org/onosproject/vpls/api/package-info.java
index b5d6ec9..91d3937 100644
--- a/apps/vpls/src/main/java/org/onosproject/vpls/config/impl/package-info.java
+++ b/apps/vpls/src/main/java/org/onosproject/vpls/api/package-info.java
@@ -1,5 +1,5 @@
/*
- * Copyright 2016-present Open Networking Laboratory
+ * Copyright 2017-present 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.
@@ -15,6 +15,6 @@
*/
/**
- * Configuration service implementation for VPLS.
+ * APIs for VPLS.
*/
-package org.onosproject.vpls.config.impl;
+package org.onosproject.vpls.api;
\ No newline at end of file
diff --git a/apps/vpls/src/main/java/org/onosproject/vpls/cli/VplsCommand.java b/apps/vpls/src/main/java/org/onosproject/vpls/cli/VplsCommand.java
index d4bfa8d..4718453 100644
--- a/apps/vpls/src/main/java/org/onosproject/vpls/cli/VplsCommand.java
+++ b/apps/vpls/src/main/java/org/onosproject/vpls/cli/VplsCommand.java
@@ -15,24 +15,24 @@
*/
package org.onosproject.vpls.cli;
-import com.google.common.collect.Lists;
-import com.google.common.collect.SetMultimap;
-import com.google.common.collect.Sets;
import org.apache.karaf.shell.commands.Argument;
import org.apache.karaf.shell.commands.Command;
import org.onosproject.cli.AbstractShellCommand;
import org.onosproject.incubator.net.intf.Interface;
+import org.onosproject.incubator.net.intf.InterfaceService;
import org.onosproject.net.EncapsulationType;
-import org.onosproject.vpls.config.VplsConfigService;
+import org.onosproject.vpls.api.VplsData;
+import org.onosproject.vpls.api.Vpls;
+import java.util.Collection;
import java.util.Collections;
import java.util.List;
-import java.util.Map;
-import java.util.Optional;
import java.util.Set;
+import java.util.stream.Collectors;
import static com.google.common.base.Strings.isNullOrEmpty;
+
/**
* CLI to interact with the VPLS application.
*/
@@ -85,7 +85,8 @@
" not found" + RESET;
private static final String VPLS_DISPLAY = "VPLS name: " + BOLD +
- "%s" + RESET + "\nAssociated interfaces: %s\nEncapsulation: %s";
+ "%s" + RESET + "\nAssociated interfaces: %s\nEncapsulation: %s\n" +
+ "State: %s";
private static final String VPLS_NOT_FOUND =
COLOR_ERROR + "VPLS " + BOLD + "%s" + RESET + COLOR_ERROR +
@@ -93,15 +94,13 @@
private static final String IFACE_NOT_ASSOCIATED =
COLOR_ERROR + "Interface " + BOLD + "%s" + RESET + COLOR_ERROR +
- " cannot be removed from VPLS " + BOLD + "%s" + RESET +
- COLOR_ERROR + ". The interface is associated to another" +
- "VPLS (" + BOLD + "%s" + RESET + COLOR_ERROR + ")" + RESET;
+ " cannot be removed from VPLS " + BOLD + "%s" + RESET + ".";
- private static VplsConfigService vplsConfigService =
- get(VplsConfigService.class);
+ protected static Vpls vpls;
+ protected static InterfaceService interfaceService;
@Argument(index = 0, name = "command", description = "Command name (add-if|" +
- "clean|create|delete|list|rem-if|set-encap|show)",
+ "create|delete|list|rem-if|set-encap|show)",
required = true, multiValued = false)
String command = null;
@@ -116,15 +115,19 @@
@Override
protected void execute() {
+ if (vpls == null) {
+ vpls = get(Vpls.class);
+ }
+ if (interfaceService == null) {
+ interfaceService = get(InterfaceService.class);
+ }
+
VplsCommandEnum enumCommand = VplsCommandEnum.enumFromString(command);
if (enumCommand != null) {
switch (enumCommand) {
case ADD_IFACE:
addIface(vplsName, optArg);
break;
- case CLEAN:
- clean();
- break;
case CREATE:
create(vplsName);
break;
@@ -143,6 +146,9 @@
case SHOW:
show(vplsName);
break;
+ case CLEAN:
+ cleanVpls();
+ break;
default:
print(VPLS_COMMAND_NOT_FOUND, command);
}
@@ -157,7 +163,7 @@
* @param vplsName the name of the VLPS
* @param ifaceName the name of the interface to add
*/
- private void addIface(String vplsName, String ifaceName) {
+ protected void addIface(String vplsName, String ifaceName) {
if (vplsName == null) {
print(INSERT_VPLS_NAME);
return;
@@ -166,28 +172,24 @@
print(INSERT_INTERFACE);
return;
}
- if (!vplsExists(vplsName)) {
+
+ Interface iface = getInterface(ifaceName);
+ VplsData vplsData = vpls.getVpls(vplsName);
+
+ if (vplsData == null) {
print(VPLS_NOT_FOUND, vplsName);
return;
}
- if (!ifaceExists(ifaceName)) {
+ if (iface == null) {
print(IFACE_NOT_FOUND, ifaceName);
return;
}
- if (isIfaceAssociated(ifaceName)) {
+ if (isIfaceAssociated(iface)) {
print(IFACE_ALREADY_ASSOCIATED,
- ifaceName, vplsNameFromIfaceName(ifaceName));
+ ifaceName, getVplsByInterface(iface).name());
return;
}
-
- vplsConfigService.addIface(vplsName, ifaceName);
- }
-
- /**
- * Cleans the VPLS configuration.
- */
- private void clean() {
- vplsConfigService.cleanVplsConfig();
+ vpls.addInterface(vplsData, iface);
}
/**
@@ -195,16 +197,17 @@
*
* @param vplsName the name of the VLPS
*/
- private void create(String vplsName) {
+ protected void create(String vplsName) {
if (vplsName == null || vplsName.isEmpty()) {
print(INSERT_VPLS_NAME);
return;
}
- if (vplsExists(vplsName)) {
+ VplsData vplsData = vpls.getVpls(vplsName);
+ if (vplsData != null) {
print(VPLS_ALREADY_EXISTS, vplsName);
return;
}
- vplsConfigService.addVpls(vplsName, Sets.newHashSet(), null);
+ vpls.createVpls(vplsName, EncapsulationType.NONE);
}
/**
@@ -212,23 +215,26 @@
*
* @param vplsName the name of the VLPS
*/
- private void delete(String vplsName) {
+ protected void delete(String vplsName) {
if (vplsName == null) {
print(INSERT_VPLS_NAME);
return;
}
- if (!vplsExists(vplsName)) {
+ VplsData vplsData = vpls.getVpls(vplsName);
+ if (vplsData == null) {
print(VPLS_NOT_FOUND, vplsName);
return;
}
- vplsConfigService.removeVpls(vplsName);
+ vpls.removeVpls(vplsData);
}
/**
* Lists the configured VPLSs.
*/
- private void list() {
- List<String> vplsNames = Lists.newArrayList(vplsConfigService.vplsNames());
+ protected void list() {
+ List<String> vplsNames = vpls.getAllVpls().stream()
+ .map(VplsData::name)
+ .collect(Collectors.toList());
Collections.sort(vplsNames);
vplsNames.forEach(vpls -> {
@@ -242,7 +248,7 @@
* @param vplsName the name of the VLPS
* @param ifaceName the name of the interface to remove
*/
- private void removeIface(String vplsName, String ifaceName) {
+ protected void removeIface(String vplsName, String ifaceName) {
if (vplsName == null) {
print(INSERT_VPLS_NAME);
return;
@@ -251,20 +257,21 @@
print(INSERT_INTERFACE);
return;
}
- if (!vplsExists(vplsName)) {
+ VplsData vplsData = vpls.getVpls(vplsName);
+ Interface iface = getInterface(ifaceName);
+ if (vplsData == null) {
print(VPLS_NOT_FOUND, vplsName);
return;
}
- if (!ifaceExists(ifaceName)) {
+ if (iface == null) {
print(IFACE_NOT_FOUND, ifaceName);
return;
}
- String vplsNameFromIfaceName = vplsNameFromIfaceName(ifaceName);
- if (!vplsNameFromIfaceName.equals(vplsName)) {
- print(IFACE_NOT_ASSOCIATED, ifaceName, vplsName, vplsNameFromIfaceName);
+ if (!vplsData.interfaces().contains(iface)) {
+ print(IFACE_NOT_ASSOCIATED, ifaceName, vplsName);
return;
}
- vplsConfigService.removeIface(ifaceName);
+ vpls.removeInterface(vplsData, iface);
}
/**
@@ -273,7 +280,7 @@
* @param vplsName the name of the VPLS
* @param encap the encapsulation type
*/
- private void setEncap(String vplsName, String encap) {
+ protected void setEncap(String vplsName, String encap) {
if (vplsName == null) {
print(INSERT_VPLS_NAME);
return;
@@ -282,7 +289,8 @@
print(INSERT_ENCAP_TYPE);
return;
}
- if (!vplsExists(vplsName)) {
+ VplsData vplsData = vpls.getVpls(vplsName);
+ if (vplsData == null) {
print(VPLS_NOT_FOUND, vplsName);
return;
}
@@ -292,7 +300,7 @@
print(ENCAP_NOT_FOUND, encap);
return;
}
- vplsConfigService.setEncap(vplsName, encap);
+ vpls.setEncapsulationType(vplsData, encapType);
}
/**
@@ -300,113 +308,88 @@
*
* @param vplsName the name of the VPLS
*/
- private void show(String vplsName) {
- List<String> vplsNames = Lists.newArrayList(vplsConfigService.vplsNames());
- Collections.sort(vplsNames);
-
- Map<String, EncapsulationType> encapByVplsName =
- vplsConfigService.encapByVplsName();
-
+ protected void show(String vplsName) {
if (!isNullOrEmpty(vplsName)) {
// A VPLS name is provided. Check first if the VPLS exists
- if (vplsExists(vplsName)) {
+ VplsData vplsData = vpls.getVpls(vplsName);
+ if (vplsData != null) {
+ Set<String> ifaceNames = vplsData.interfaces().stream()
+ .map(Interface::name)
+ .collect(Collectors.toSet());
print(VPLS_DISPLAY,
vplsName,
- ifacesFromVplsName(vplsName).toString(),
- encapByVplsName.get(vplsName).toString());
+ ifaceNames,
+ vplsData.encapsulationType().toString(),
+ vplsData.state());
} else {
print(VPLS_NOT_FOUND, vplsName);
}
} else {
+ Collection<VplsData> vplses = vpls.getAllVpls();
// No VPLS names are provided. Display all VPLSs configured
print(SEPARATOR);
- vplsNames.forEach(v -> {
+ vplses.forEach(vplsData -> {
+ Set<String> ifaceNames = vplsData.interfaces().stream()
+ .map(Interface::name)
+ .collect(Collectors.toSet());
print(VPLS_DISPLAY,
- v,
- ifacesFromVplsName(v).toString(),
- encapByVplsName.get(v).toString());
+ vplsData.name(),
+ ifaceNames,
+ vplsData.encapsulationType().toString(),
+ vplsData.state());
print(SEPARATOR);
});
}
}
/**
- * States if a VPLS exists or not.
- *
- * @param vplsName the name of the VPLS
- * @return true if the VPLS exists; false otherwise
+ * Remove all VPLS.
*/
- private static boolean vplsExists(String vplsName) {
- return vplsConfigService.vplsNames().contains(vplsName);
+ protected void cleanVpls() {
+ vpls.removeAllVpls();
}
- /**
- * States if an interface is defined or not in the system.
- *
- * @param ifaceName the name of the interface
- * @return true if the interface is defined; false otherwise
- */
- private static boolean ifaceExists(String ifaceName) {
- return vplsConfigService.allIfaces()
- .stream()
- .anyMatch(iface -> iface.name().equals(ifaceName));
- }
/**
* States if an interface is already associated to a VPLS.
*
- * @param ifaceName the name of the interface
+ * @param iface the interface
* @return true if the interface is already associated to a VPLS; false
* otherwise
*/
- private static boolean isIfaceAssociated(String ifaceName) {
- return vplsConfigService.ifaces()
+ private static boolean isIfaceAssociated(Interface iface) {
+ return vpls.getAllVpls()
.stream()
- .anyMatch(iface -> iface.name().equals(ifaceName));
+ .map(VplsData::interfaces)
+ .flatMap(Collection::stream)
+ .anyMatch(iface::equals);
}
/**
- * Returns the name of a VPLS, given the name of an interface associated to
- * it.
+ * Gets a network interface by given interface name.
*
- * @param ifaceName the name of the interface
- * @return the name of the VPLS that has the interface configured; null if
- * the interface does not exist or is not associated to any VPLS
+ * @param interfaceName the interface name
+ * @return the network interface
*/
- private static String vplsNameFromIfaceName(String ifaceName) {
- String vplsName = null;
-
- Optional<String> optVplsName = vplsConfigService.ifacesByVplsName()
- .entries()
- .stream()
- .filter((entry -> entry.getValue().name().equals(ifaceName)))
- .map(Map.Entry::getKey)
- .findFirst();
-
- if (optVplsName.isPresent()) {
- vplsName = optVplsName.get();
- }
-
- return vplsName;
+ private Interface getInterface(String interfaceName) {
+ // FIXME: only returns first interface it found
+ // multiple interface with same name not support
+ return interfaceService.getInterfaces().stream()
+ .filter(iface -> iface.name().equals(interfaceName))
+ .findFirst()
+ .orElse(null);
}
/**
- * Returns a list of interfaces associated to a VPLS, given a VPLS name.
+ * Gets a VPLS related to the network interface.
*
- * @param vplsName the name of the VPLS
- * @return the set of interfaces associated to the given VPLS; null if the
- * VPLS is not found
+ * @param iface the network interface
+ * @return the VPLS related to the network interface
*/
- private static Set<String> ifacesFromVplsName(String vplsName) {
- if (!vplsExists(vplsName)) {
- return null;
- }
- SetMultimap<String, Interface> ifacesByVplsName =
- vplsConfigService.ifacesByVplsName();
- Set<String> ifaceNames = Sets.newHashSet();
-
- ifacesByVplsName.get(vplsName).forEach(iface -> ifaceNames.add(iface.name()));
-
- return ifaceNames;
+ private VplsData getVplsByInterface(Interface iface) {
+ return vpls.getAllVpls().stream()
+ .filter(vplsData -> vplsData.interfaces().contains(iface))
+ .findFirst()
+ .orElse(null);
}
}
diff --git a/apps/vpls/src/main/java/org/onosproject/vpls/cli/VplsCommandEnum.java b/apps/vpls/src/main/java/org/onosproject/vpls/cli/VplsCommandEnum.java
index dfdaadf..c1ccb2b 100644
--- a/apps/vpls/src/main/java/org/onosproject/vpls/cli/VplsCommandEnum.java
+++ b/apps/vpls/src/main/java/org/onosproject/vpls/cli/VplsCommandEnum.java
@@ -25,13 +25,13 @@
*/
public enum VplsCommandEnum {
ADD_IFACE("add-if"),
- CLEAN("clean"),
CREATE("create"),
DELETE("delete"),
LIST("list"),
REMOVE_IFACE("rem-if"),
SET_ENCAP("set-encap"),
- SHOW("show");
+ SHOW("show"),
+ CLEAN("clean");
private final String command;
@@ -40,7 +40,7 @@
*
* @param command the text representing the command
*/
- private VplsCommandEnum(final String command) {
+ VplsCommandEnum(final String command) {
this.command = command;
}
@@ -56,7 +56,7 @@
*/
public static List<String> toStringList() {
return Arrays.stream(values())
- .map(c -> c.toString())
+ .map(VplsCommandEnum::toString)
.collect(Collectors.toCollection(ArrayList::new));
}
@@ -71,7 +71,7 @@
public static VplsCommandEnum enumFromString(String command) {
if (command != null && !command.isEmpty()) {
for (VplsCommandEnum c : values()) {
- if (command.toString().equalsIgnoreCase(c.toString())) {
+ if (command.equalsIgnoreCase(c.toString())) {
return c;
}
}
diff --git a/apps/vpls/src/main/java/org/onosproject/vpls/cli/completer/VplsCommandCompleter.java b/apps/vpls/src/main/java/org/onosproject/vpls/cli/completer/VplsCommandCompleter.java
index cfe08b7..2b198a9 100644
--- a/apps/vpls/src/main/java/org/onosproject/vpls/cli/completer/VplsCommandCompleter.java
+++ b/apps/vpls/src/main/java/org/onosproject/vpls/cli/completer/VplsCommandCompleter.java
@@ -16,6 +16,7 @@
package org.onosproject.vpls.cli.completer;
import com.google.common.collect.Lists;
+import org.apache.karaf.shell.console.completer.ArgumentCompleter;
import org.onosproject.cli.AbstractChoicesCompleter;
import org.onosproject.vpls.cli.VplsCommandEnum;
@@ -29,17 +30,19 @@
@Override
public List<String> choices() {
- List<String> argumentList =
- Lists.newArrayList(getArgumentList().getArguments());
+ ArgumentCompleter.ArgumentList argumentList = getArgumentList();
+ if (argumentList == null) {
+ return Collections.emptyList();
+ }
+ List<String> argList = Lists.newArrayList(argumentList.getArguments());
String argOne = null;
- if (argumentList.size() > 1) {
- argOne = argumentList.get(1);
+ if (argList.size() > 1) {
+ argOne = argList.get(1);
}
VplsCommandEnum vplsCommandEnum = VplsCommandEnum.enumFromString(argOne);
if (vplsCommandEnum != null) {
switch (vplsCommandEnum) {
case CREATE:
- case CLEAN:
case LIST:
return Collections.emptyList();
default:
diff --git a/apps/vpls/src/main/java/org/onosproject/vpls/cli/completer/VplsNameCompleter.java b/apps/vpls/src/main/java/org/onosproject/vpls/cli/completer/VplsNameCompleter.java
index ab2479b..6900880 100644
--- a/apps/vpls/src/main/java/org/onosproject/vpls/cli/completer/VplsNameCompleter.java
+++ b/apps/vpls/src/main/java/org/onosproject/vpls/cli/completer/VplsNameCompleter.java
@@ -15,11 +15,13 @@
*/
package org.onosproject.vpls.cli.completer;
-import com.google.common.collect.Lists;
import org.onosproject.cli.AbstractChoicesCompleter;
-import org.onosproject.vpls.config.VplsConfigService;
+import org.onosproject.vpls.api.Vpls;
+import org.onosproject.vpls.api.VplsData;
+import java.util.Collection;
import java.util.List;
+import java.util.stream.Collectors;
import static org.onosproject.cli.AbstractShellCommand.get;
@@ -28,9 +30,14 @@
*/
public class VplsNameCompleter extends AbstractChoicesCompleter {
+ protected static Vpls vpls;
+
@Override
public List<String> choices() {
- VplsConfigService vplsConfigService = get(VplsConfigService.class);
- return Lists.newArrayList(vplsConfigService.vplsNames());
+ if (vpls == null) {
+ vpls = get(Vpls.class);
+ }
+ Collection<VplsData> vplses = vpls.getAllVpls();
+ return vplses.stream().map(VplsData::name).collect(Collectors.toList());
}
}
diff --git a/apps/vpls/src/main/java/org/onosproject/vpls/cli/completer/VplsOptArgCompleter.java b/apps/vpls/src/main/java/org/onosproject/vpls/cli/completer/VplsOptArgCompleter.java
index 5b60352..7058cdc 100644
--- a/apps/vpls/src/main/java/org/onosproject/vpls/cli/completer/VplsOptArgCompleter.java
+++ b/apps/vpls/src/main/java/org/onosproject/vpls/cli/completer/VplsOptArgCompleter.java
@@ -16,15 +16,17 @@
package org.onosproject.vpls.cli.completer;
import com.google.common.collect.Lists;
-import com.google.common.collect.Sets;
import org.apache.karaf.shell.console.completer.ArgumentCompleter;
import org.onosproject.cli.AbstractChoicesCompleter;
import org.onosproject.incubator.net.intf.Interface;
+import org.onosproject.incubator.net.intf.InterfaceService;
import org.onosproject.net.EncapsulationType;
+import org.onosproject.vpls.api.Vpls;
+import org.onosproject.vpls.api.VplsData;
import org.onosproject.vpls.cli.VplsCommandEnum;
-import org.onosproject.vpls.config.VplsConfigService;
import java.util.Arrays;
+import java.util.Collection;
import java.util.Collections;
import java.util.List;
import java.util.Set;
@@ -36,22 +38,29 @@
* VPLS optional argument completer.
*/
public class VplsOptArgCompleter extends AbstractChoicesCompleter {
+ protected static Vpls vpls;
+ protected static InterfaceService interfaceService;
@Override
public List<String> choices() {
- VplsConfigService vplsConfigService = get(VplsConfigService.class);
- List<String> argumentList =
- Lists.newArrayList(getArgumentList().getArguments());
- String argOne = argumentList.get(1);
+ if (vpls == null) {
+ vpls = get(Vpls.class);
+ }
+ ArgumentCompleter.ArgumentList argumentList = getArgumentList();
+ if (argumentList == null) {
+ return Collections.emptyList();
+ }
+ List<String> argList = Lists.newArrayList(argumentList.getArguments());
+ String argOne = argList.get(1);
VplsCommandEnum vplsCommandEnum = VplsCommandEnum.enumFromString(argOne);
if (vplsCommandEnum != null) {
switch (vplsCommandEnum) {
case ADD_IFACE:
- return availableIfaces(vplsConfigService);
+ return availableIfaces();
case SET_ENCAP:
return encap();
case REMOVE_IFACE:
- return vplsIfaces(vplsConfigService);
+ return vplsIfaces();
default:
return Collections.emptyList();
}
@@ -64,21 +73,27 @@
*
* @return the list of interfaces not yet assigned to any VPLS
*/
- private List<String> availableIfaces(VplsConfigService vplsConfigService) {
- List<String> ifacesAvailable = Lists.newArrayList();
- Set<Interface> allIfaces = Sets.newHashSet(vplsConfigService.allIfaces());
- Set<Interface> usedIfaces = Sets.newHashSet(vplsConfigService.ifaces());
+ private List<String> availableIfaces() {
+ if (interfaceService == null) {
+ interfaceService = get(InterfaceService.class);
+ }
- allIfaces.removeAll(usedIfaces);
- allIfaces.forEach(iface -> ifacesAvailable.add(iface.name()));
+ Set<Interface> allIfaces = interfaceService.getInterfaces();
+ Set<Interface> usedIfaces = vpls.getAllVpls().stream()
+ .map(VplsData::interfaces)
+ .flatMap(Collection::stream)
+ .collect(Collectors.toSet());
- return ifacesAvailable;
+ return allIfaces.stream()
+ .filter(iface -> !usedIfaces.contains(iface))
+ .map(Interface::name)
+ .collect(Collectors.toList());
}
/**
* Returns the list of supported encapsulation types.
*
- * @return the list of supported encapsualtion types
+ * @return the list of supported encapsulation types
*/
private List<String> encap() {
return Arrays.stream(EncapsulationType.values())
@@ -91,15 +106,12 @@
*
* @return the list of interfaces associated to a VPLS
*/
- private List<String> vplsIfaces(VplsConfigService vplsConfigService) {
+ private List<String> vplsIfaces() {
ArgumentCompleter.ArgumentList list = getArgumentList();
String vplsName = list.getArguments()[2];
-
- List<String> vplsIfaces = Lists.newArrayList();
-
- Set<Interface> connectPoints = vplsConfigService.ifaces(vplsName);
- connectPoints.forEach(iface -> vplsIfaces.add(iface.name()));
-
- return vplsIfaces;
+ VplsData vplsData = vpls.getVpls(vplsName);
+ return vplsData.interfaces().stream()
+ .map(Interface::name)
+ .collect(Collectors.toList());
}
}
diff --git a/apps/vpls/src/main/java/org/onosproject/vpls/config/VplsAppConfig.java b/apps/vpls/src/main/java/org/onosproject/vpls/config/VplsAppConfig.java
index 66f7882..775d56b 100644
--- a/apps/vpls/src/main/java/org/onosproject/vpls/config/VplsAppConfig.java
+++ b/apps/vpls/src/main/java/org/onosproject/vpls/config/VplsAppConfig.java
@@ -35,6 +35,9 @@
private static final String INTERFACE = "interfaces";
private static final String ENCAPSULATION = "encapsulation";
+ // Record update time when VPLS distribute store update it
+ private static final String UPDATE_TIME = "lastUpdateTime";
+
/**
* Returns a set of configured VPLSs.
*
@@ -42,9 +45,7 @@
*/
public Set<VplsConfig> vplss() {
Set<VplsConfig> vplss = Sets.newHashSet();
-
JsonNode vplsNode = object.get(VPLS);
-
if (vplsNode == null) {
return vplss;
}
@@ -67,7 +68,6 @@
ifaces,
EncapsulationType.enumFromString(encap)));
});
-
return vplss;
}
@@ -215,4 +215,37 @@
private ArrayNode initVplsConfiguration() {
return object.putArray(VPLS);
}
+
+ /**
+ * Sets the last time of update for the VPLS information in the store.
+ *
+ * @param timestamp the update time
+ */
+ public void updateTime(long timestamp) {
+ object.put(UPDATE_TIME, timestamp);
+ }
+
+ /**
+ * Retrieves the last time of update for the VPLS information in the store.
+ *
+ * @return update time, -1 if there is no update time in the config
+ */
+ public long updateTime() {
+ if (object.get(UPDATE_TIME) != null) {
+ return object.get(UPDATE_TIME).asLong();
+ } else {
+ // No update time
+ return -1L;
+ }
+ }
+
+ /**
+ * Clears all VPLS configurations.
+ */
+ public void clearVplsConfig() {
+ if (object.get(VPLS) != null) {
+ object.remove(VPLS);
+ }
+ initVplsConfiguration();
+ }
}
diff --git a/apps/vpls/src/main/java/org/onosproject/vpls/config/VplsConfigManager.java b/apps/vpls/src/main/java/org/onosproject/vpls/config/VplsConfigManager.java
new file mode 100644
index 0000000..71b14ad
--- /dev/null
+++ b/apps/vpls/src/main/java/org/onosproject/vpls/config/VplsConfigManager.java
@@ -0,0 +1,260 @@
+/*
+ * Copyright 2017-present 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.vpls.config;
+
+import com.google.common.collect.Sets;
+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.onosproject.cluster.LeadershipService;
+import org.onosproject.cluster.NodeId;
+import org.onosproject.core.ApplicationId;
+import org.onosproject.core.CoreService;
+import org.onosproject.incubator.net.intf.Interface;
+import org.onosproject.incubator.net.intf.InterfaceService;
+import org.onosproject.net.config.ConfigFactory;
+import org.onosproject.net.config.NetworkConfigEvent;
+import org.onosproject.net.config.NetworkConfigListener;
+import org.onosproject.net.config.NetworkConfigRegistry;
+import org.onosproject.net.config.NetworkConfigService;
+import org.onosproject.net.config.basics.SubjectFactories;
+import org.onosproject.vpls.VplsManager;
+import org.onosproject.vpls.api.VplsData;
+import org.onosproject.vpls.api.Vpls;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+import java.util.Collection;
+import java.util.Objects;
+import java.util.Set;
+import java.util.concurrent.Executors;
+import java.util.concurrent.ScheduledExecutorService;
+import java.util.concurrent.TimeUnit;
+import java.util.stream.Collectors;
+
+import static org.onlab.util.Tools.groupedThreads;
+
+/**
+ * Component for the management of the VPLS configuration.
+ */
+@Component(immediate = true)
+public class VplsConfigManager {
+ private static final Class<VplsAppConfig> CONFIG_CLASS = VplsAppConfig.class;
+ private static final String NET_CONF_EVENT = "Received NetworkConfigEvent {}";
+ private static final String CONFIG_NULL = "VPLS configuration not defined";
+ private static final int INITIAL_RELOAD_CONFIG_DELAY = 0;
+ private static final int INITIAL_RELOAD_CONFIG_PERIOD = 1000;
+ private static final int NUM_THREADS = 1;
+ private static final String VPLS = "vpls";
+ private final Logger log = LoggerFactory.getLogger(getClass());
+
+ private final NetworkConfigListener configListener =
+ new InternalNetworkConfigListener();
+
+ @Reference(cardinality = ReferenceCardinality.MANDATORY_UNARY)
+ protected NetworkConfigService configService;
+
+ @Reference(cardinality = ReferenceCardinality.MANDATORY_UNARY)
+ protected CoreService coreService;
+
+ @Reference(cardinality = ReferenceCardinality.MANDATORY_UNARY)
+ protected InterfaceService interfaceService;
+
+ @Reference(cardinality = ReferenceCardinality.MANDATORY_UNARY)
+ protected NetworkConfigRegistry registry;
+
+ @Reference(cardinality = ReferenceCardinality.MANDATORY_UNARY)
+ protected Vpls vpls;
+
+ @Reference(cardinality = ReferenceCardinality.MANDATORY_UNARY)
+ protected LeadershipService leadershipService;
+
+ private ScheduledExecutorService reloadExecutor =
+ Executors.newScheduledThreadPool(NUM_THREADS,
+ groupedThreads("onos/apps/vpls",
+ "config-reloader-%d",
+ log)
+ );
+
+ private ConfigFactory<ApplicationId, VplsAppConfig> vplsConfigFactory =
+ new ConfigFactory<ApplicationId, VplsAppConfig>(
+ SubjectFactories.APP_SUBJECT_FACTORY, VplsAppConfig.class, VPLS) {
+ @Override
+ public VplsAppConfig createConfig() {
+ return new VplsAppConfig();
+ }
+ };
+
+ protected ApplicationId appId;
+
+ @Activate
+ void activate() {
+ appId = coreService.registerApplication(VplsManager.VPLS_APP);
+ configService.addListener(configListener);
+
+ // Load config when VPLS service started and there is a leader for VPLS;
+ // otherwise, try again after a period.
+ reloadExecutor.scheduleAtFixedRate(() -> {
+ NodeId vplsLeaderNode = leadershipService.getLeader(appId.name());
+ if (vpls == null || vplsLeaderNode == null) {
+ return;
+ }
+ reloadConfiguration();
+ reloadExecutor.shutdown();
+ }, INITIAL_RELOAD_CONFIG_DELAY, INITIAL_RELOAD_CONFIG_PERIOD, TimeUnit.MILLISECONDS);
+ registry.registerConfigFactory(vplsConfigFactory);
+ }
+
+ @Deactivate
+ void deactivate() {
+ configService.removeListener(configListener);
+ registry.unregisterConfigFactory(vplsConfigFactory);
+ }
+
+ /**
+ * Retrieves the VPLS configuration from network configuration.
+ * Checks difference between new configuration and old configuration.
+ */
+ private synchronized void reloadConfiguration() {
+ VplsAppConfig vplsAppConfig = configService.getConfig(appId, VplsAppConfig.class);
+
+ if (vplsAppConfig == null) {
+ log.warn(CONFIG_NULL);
+
+ // If the config is null, removes all VPLS.
+ vpls.removeAllVpls();
+ return;
+ }
+
+ // If there exists a update time in the configuration; it means the
+ // configuration was pushed by VPLS store; ignore this configuration.
+ long updateTime = vplsAppConfig.updateTime();
+ if (updateTime != -1L) {
+ return;
+ }
+
+ Collection<VplsData> oldVplses = vpls.getAllVpls();
+ Collection<VplsData> newVplses;
+
+ // Generates collection of new VPLSs
+ newVplses = vplsAppConfig.vplss().stream()
+ .map(vplsConfig -> {
+ Set<Interface> interfaces = vplsConfig.ifaces().stream()
+ .map(this::getInterfaceByName)
+ .filter(Objects::nonNull)
+ .collect(Collectors.toSet());
+ VplsData vplsData = VplsData.of(vplsConfig.name(), vplsConfig.encap());
+ vplsData.addInterfaces(interfaces);
+ return vplsData;
+ }).collect(Collectors.toSet());
+
+ if (newVplses.containsAll(oldVplses) && oldVplses.containsAll(newVplses)) {
+ // no update, ignore
+ return;
+ }
+
+ // To add or update
+ newVplses.forEach(newVplsData -> {
+ boolean vplsExists = false;
+ for (VplsData oldVplsData : oldVplses) {
+ if (oldVplsData.name().equals(newVplsData.name())) {
+ vplsExists = true;
+
+ // VPLS exists; but need to be updated.
+ if (!oldVplsData.equals(newVplsData)) {
+ // Update VPLS
+ Set<Interface> newInterfaces = newVplsData.interfaces();
+ Set<Interface> oldInterfaces = oldVplsData.interfaces();
+
+ Set<Interface> ifaceToAdd = newInterfaces.stream()
+ .filter(iface -> !oldInterfaces.contains(iface))
+ .collect(Collectors.toSet());
+
+ Set<Interface> ifaceToRem = oldInterfaces.stream()
+ .filter(iface -> !newInterfaces.contains(iface))
+ .collect(Collectors.toSet());
+
+ vpls.addInterfaces(oldVplsData, ifaceToAdd);
+ vpls.removeInterfaces(oldVplsData, ifaceToRem);
+ vpls.setEncapsulationType(oldVplsData, newVplsData.encapsulationType());
+ }
+ }
+ }
+ // VPLS not exist; add new VPLS
+ if (!vplsExists) {
+ vpls.createVpls(newVplsData.name(), newVplsData.encapsulationType());
+ vpls.addInterfaces(newVplsData, newVplsData.interfaces());
+ }
+ });
+
+ // VPLS not exists in old VPLS configuration; remove it.
+ Set<VplsData> vplsToRemove = Sets.newHashSet();
+ oldVplses.forEach(oldVpls -> {
+ Set<String> newVplsNames = newVplses.stream()
+ .map(VplsData::name)
+ .collect(Collectors.toSet());
+
+ if (!newVplsNames.contains(oldVpls.name())) {
+ // To avoid ConcurrentModificationException; do remove after this
+ // iteration.
+ vplsToRemove.add(oldVpls);
+ }
+ });
+ vplsToRemove.forEach(vpls::removeVpls);
+ }
+
+ /**
+ * Gets network interface by a given name.
+ *
+ * @param interfaceName the interface name
+ * @return the network interface if there exist with the given name; null
+ * otherwise
+ */
+ private Interface getInterfaceByName(String interfaceName) {
+ return interfaceService.getInterfaces().stream()
+ .filter(iface -> iface.name().equals(interfaceName))
+ .findFirst()
+ .orElse(null);
+ }
+
+ /**
+ * Listener for VPLS configuration events.
+ * Reloads VPLS configuration when configuration added or updated.
+ * Removes all VPLS when configuration removed or unregistered.
+ */
+ private class InternalNetworkConfigListener implements NetworkConfigListener {
+ @Override
+ public void event(NetworkConfigEvent event) {
+ if (event.configClass() == CONFIG_CLASS) {
+ log.debug(NET_CONF_EVENT, event.configClass());
+ switch (event.type()) {
+ case CONFIG_ADDED:
+ case CONFIG_UPDATED:
+ reloadConfiguration();
+ break;
+ case CONFIG_REMOVED:
+ case CONFIG_UNREGISTERED:
+ vpls.removeAllVpls();
+ default:
+ break;
+ }
+ }
+ }
+ }
+}
diff --git a/apps/vpls/src/main/java/org/onosproject/vpls/config/VplsConfigService.java b/apps/vpls/src/main/java/org/onosproject/vpls/config/VplsConfigService.java
deleted file mode 100644
index 2d2a576..0000000
--- a/apps/vpls/src/main/java/org/onosproject/vpls/config/VplsConfigService.java
+++ /dev/null
@@ -1,155 +0,0 @@
-/*
- * Copyright 2016-present 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.vpls.config;
-
-import com.google.common.collect.SetMultimap;
-import org.onlab.packet.VlanId;
-import org.onosproject.incubator.net.intf.Interface;
-import org.onosproject.net.ConnectPoint;
-import org.onosproject.net.EncapsulationType;
-
-import java.util.Map;
-import java.util.Set;
-
-/**
- * Provides information about the VPLS configuration.
- */
-public interface VplsConfigService {
- Class<VplsAppConfig> CONFIG_CLASS = VplsAppConfig.class;
-
- /**
- * Adds a VPLS to the configuration.
- *
- * @param vplsName the name of the VPLS
- * @param ifaces the interfaces associated with the VPLS
- * @param encap the encapsulation type
- */
- void addVpls(String vplsName, Set<String> ifaces, String encap);
-
- /**
- * Removes a VPLS from the configuration.
- *
- * @param vplsName the name of the VPLS to be removed
- */
- void removeVpls(String vplsName);
-
- /**
- * Adds a network interface to a VPLS.
- *
- * @param vplsName the name of the VPLS
- * @param iface the network interface to be added to the VPLS
- */
- void addIface(String vplsName, String iface);
-
- /**
- * Sets an encapsulation parameter for a VPLS.
- *
- * @param vplsName the name of the VPLS
- * @param encap the encapsulation used (i.e. MPLS or VLAN) or
- */
- void setEncap(String vplsName, String encap);
-
- /**
- * Returns the encapsulation type in use for a given VPLS.
- *
- * @param vplsName the name of the VPLS
- * @return the encapsulation type in use, if any
- */
- EncapsulationType encap(String vplsName);
-
- /**
- * Removes a network interface from a VPLS.
- *
- * @param iface the network interface to be removed from the VPLS
- */
- void removeIface(String iface);
-
- /**
- * Cleans up the VPLS configuration. Removes all VPLSs.
- */
- void cleanVplsConfig();
-
- /**
- * Retrieves the VPLS names modified from CLI.
- *
- * @return the VPLS names modified from CLI
- */
- Set<String> vplsAffectedByApi();
- // TODO Remove this function after the intent framework race condition has been fixed
-
- /**
- * Retrieves the interfaces without IP configured, so compatible with VPLS,
- * from the interface service.
- *
- * @return the set of interfaces configured, compatible with VPLS
- */
- Set<Interface> allIfaces();
-
- /**
- * Retrieves the interfaces associated to a VPLS.
- *
- * @return the set of interfaces associated to a VPLS
- */
- Set<Interface> ifaces();
-
- /**
- * Retrieves the interfaces associated to the VPLS specified.
- *
- * @param vplsName the name of the VPLS
- * @return the set of interfaces associated to the VPLS specified
- */
- Set<Interface> ifaces(String vplsName);
-
- /**
- * Retrieves all VPLS names.
- *
- * @return a set of VPLS names
- */
- Set<String> vplsNames();
-
- /**
- * Retrieves all VPLS names from the old config.
- *
- * @return a set of VPLS names
- */
- Set<String> vplsNamesOld();
- // TODO Removes this function after the race condition gets fixed in IF
-
- /**
- * Returns the VPLS names and associated interfaces from the configuration.
- *
- * @return a map of VPLS names and associated interfaces
- */
- SetMultimap<String, Interface> ifacesByVplsName();
-
- /**
- * Returns the list of interfaces grouped by VPLS name, given a VLAN Id and
- * a connect point.
- *
- * @param vlan the VLAN Id
- * @param connectPoint the connect point
- * @return a map of VPLS names and associated interfaces; null otherwise
- */
- SetMultimap<String, Interface> ifacesByVplsName(VlanId vlan,
- ConnectPoint connectPoint);
-
- /**
- * Returns the VPLS names and associated encapsulation type.
- *
- * @return a map of VPLS names and associated encapsulation type
- */
- Map<String, EncapsulationType> encapByVplsName();
-}
diff --git a/apps/vpls/src/main/java/org/onosproject/vpls/config/impl/VplsConfigImpl.java b/apps/vpls/src/main/java/org/onosproject/vpls/config/impl/VplsConfigImpl.java
deleted file mode 100644
index 36da63c..0000000
--- a/apps/vpls/src/main/java/org/onosproject/vpls/config/impl/VplsConfigImpl.java
+++ /dev/null
@@ -1,388 +0,0 @@
-/*
- * Copyright 2016-present 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.vpls.config.impl;
-
-import com.google.common.collect.HashMultimap;
-import com.google.common.collect.ImmutableMap;
-import com.google.common.collect.ImmutableSet;
-import com.google.common.collect.ImmutableSetMultimap;
-import com.google.common.collect.Maps;
-import com.google.common.collect.SetMultimap;
-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.VlanId;
-import org.onosproject.core.ApplicationId;
-import org.onosproject.core.CoreService;
-import org.onosproject.incubator.net.intf.Interface;
-import org.onosproject.incubator.net.intf.InterfaceService;
-import org.onosproject.net.ConnectPoint;
-import org.onosproject.net.EncapsulationType;
-import org.onosproject.net.config.ConfigFactory;
-import org.onosproject.net.config.NetworkConfigEvent;
-import org.onosproject.net.config.NetworkConfigListener;
-import org.onosproject.net.config.NetworkConfigRegistry;
-import org.onosproject.net.config.NetworkConfigService;
-import org.onosproject.net.config.basics.SubjectFactories;
-import org.onosproject.vpls.config.VplsAppConfig;
-import org.onosproject.vpls.config.VplsConfig;
-import org.onosproject.vpls.config.VplsConfigService;
-import org.slf4j.Logger;
-import org.slf4j.LoggerFactory;
-
-import java.util.HashMap;
-import java.util.HashSet;
-import java.util.Map;
-import java.util.Set;
-
-/**
- * Implementation of VPLSConfigurationService which reads VPLS configuration
- * from the network configuration service.
- */
-@Component(immediate = true)
-@Service
-public class VplsConfigImpl implements VplsConfigService {
- private static final String VPLS_APP = "org.onosproject.vpls";
- private static final String VPLS = "vpls";
- private static final String EMPTY = "";
- private static final String CONFIG_NULL = "VPLS configuration not defined";
- private static final String APP_ID_NULL = "VPLS application ID is null";
- private static final String CONFIG_CHANGED = "VPLS configuration changed: {}";
- private static final String CHECK_CONFIG =
- "Checking the interface configuration";
- private static final String NET_CONF_EVENT =
- "Received NetworkConfigEvent {}";
-
- private final Logger log = LoggerFactory.getLogger(getClass());
-
- @Reference(cardinality = ReferenceCardinality.MANDATORY_UNARY)
- protected NetworkConfigRegistry registry;
-
- @Reference(cardinality = ReferenceCardinality.MANDATORY_UNARY)
- protected CoreService coreService;
-
- @Reference(cardinality = ReferenceCardinality.MANDATORY_UNARY)
- protected InterfaceService interfaceService;
-
- @Reference(cardinality = ReferenceCardinality.MANDATORY_UNARY)
- protected NetworkConfigService configService;
-
- private final Set<String> vplsAffectedByApi = new HashSet<>();
-
- private VplsAppConfig vplsAppConfig = null;
-
- private SetMultimap<String, String> ifacesOfVpls = HashMultimap.create();
- private SetMultimap<String, String> oldIfacesOfVpls = HashMultimap.create();
- private SetMultimap<String, Interface> vplsIfaces = HashMultimap.create();
-
- private Map<String, EncapsulationType> vplsEncaps = Maps.newHashMap();
-
- private final InternalNetworkConfigListener configListener =
- new InternalNetworkConfigListener();
-
- private ConfigFactory<ApplicationId, VplsAppConfig> vplsConfigFactory =
- new ConfigFactory<ApplicationId, VplsAppConfig>(
- SubjectFactories.APP_SUBJECT_FACTORY, VplsAppConfig.class, VPLS) {
- @Override
- public VplsAppConfig createConfig() {
- return new VplsAppConfig();
- }
- };
-
- private ApplicationId vplsAppId;
-
- @Activate
- protected void active() {
- configService.addListener(configListener);
- registry.registerConfigFactory(vplsConfigFactory);
- loadConfiguration();
- log.info("Started");
- }
-
- @Deactivate
- protected void deactive() {
- registry.unregisterConfigFactory(vplsConfigFactory);
- configService.removeListener(configListener);
- log.info("Stopped");
- }
-
- @Override
- public void addVpls(String vplsName, Set<String> ifaces, String encap) {
- EncapsulationType encapType = EncapsulationType.enumFromString(encap);
-
- if (ifacesOfVpls.containsKey(vplsName)) {
- if (ifaces.isEmpty()) {
- return;
- }
- ifaces.forEach(iface -> vplsAppConfig.addIface(vplsName, iface));
- vplsAppConfig.setEncap(vplsName, encapType);
- } else {
- vplsAppConfig.addVpls(new VplsConfig(vplsName, ifaces, encapType));
- }
-
- vplsAffectedByApi.add(vplsName);
- applyConfig(vplsAppConfig);
- }
-
- @Override
- public void removeVpls(String vplsName) {
- if (ifacesOfVpls.containsKey(vplsName)) {
- vplsAppConfig.removeVpls(vplsName);
- vplsAffectedByApi.add(vplsName);
- applyConfig(vplsAppConfig);
- }
- }
-
- @Override
- public void addIface(String vplsName, String iface) {
- if (ifacesOfVpls.containsKey(vplsName)) {
- vplsAppConfig.addIface(vplsName, iface);
- vplsAffectedByApi.add(vplsName);
- applyConfig(vplsAppConfig);
- }
- }
-
- @Override
- public void setEncap(String vplsName, String encap) {
- EncapsulationType encapType = EncapsulationType.enumFromString(encap);
-
- if (ifacesOfVpls.containsKey(vplsName)) {
- vplsAppConfig.setEncap(vplsName, encapType);
- vplsAffectedByApi.add(vplsName);
- applyConfig(vplsAppConfig);
- }
- }
-
- @Override
- public void removeIface(String iface) {
- if (ifacesOfVpls.containsValue(iface)) {
- VplsConfig vpls = vplsAppConfig.vplsFromIface(iface);
- vplsAppConfig.removeIface(vpls, iface);
- vplsAffectedByApi.add(vpls.name());
- applyConfig(vplsAppConfig);
- }
- }
-
- @Override
- public void cleanVplsConfig() {
- ifacesOfVpls.entries().forEach(e -> {
- vplsAppConfig.removeVpls(e.getKey());
- vplsAffectedByApi.add(e.getKey());
- });
- applyConfig(vplsAppConfig);
- }
-
- @Override
- public EncapsulationType encap(String vplsName) {
- EncapsulationType encap = null;
- if (vplsEncaps.containsKey(vplsName)) {
- encap = vplsEncaps.get(vplsName);
- }
-
- return encap;
- }
-
- @Override
- public Set<String> vplsAffectedByApi() {
- Set<String> vplsNames = ImmutableSet.copyOf(vplsAffectedByApi);
- vplsAffectedByApi.clear();
- return vplsNames;
- }
-
- @Override
- public Set<Interface> allIfaces() {
- Set<Interface> interfaces = new HashSet<>();
- interfaceService.getInterfaces().stream()
- .filter(iface -> iface.ipAddressesList() == null ||
- iface.ipAddressesList().isEmpty())
- .forEach(interfaces::add);
- return interfaces;
- }
-
- @Override
- public Set<Interface> ifaces() {
- Set<Interface> interfaces = new HashSet<>();
- vplsIfaces.values().forEach(interfaces::add);
- return interfaces;
- }
-
- @Override
- public Set<Interface> ifaces(String vplsName) {
- Set<Interface> vplsInterfaces = new HashSet<>();
- vplsIfaces.get(vplsName).forEach(vplsInterfaces::add);
- return vplsInterfaces;
- }
-
- @Override
- public Set<String> vplsNames() {
- return ifacesOfVpls.keySet();
- }
-
- @Override
- public Set<String> vplsNamesOld() {
- return oldIfacesOfVpls.keySet();
- }
-
- @Override
- public SetMultimap<String, Interface> ifacesByVplsName() {
- return ImmutableSetMultimap.copyOf(vplsIfaces);
- }
-
- @Override
- public SetMultimap<String, Interface> ifacesByVplsName(VlanId vlan,
- ConnectPoint connectPoint) {
- String vplsName =
- vplsIfaces.entries().stream()
- .filter(e -> e.getValue().connectPoint().equals(connectPoint))
- .filter(e -> e.getValue().vlan().equals(vlan))
- .map(Map.Entry::getKey)
- .findFirst()
- .orElse(null);
- SetMultimap<String, Interface> result = HashMultimap.create();
- if (vplsName != null && vplsIfaces.containsKey(vplsName)) {
- vplsIfaces.get(vplsName)
- .forEach(intf -> result.put(vplsName, intf));
- return result;
- }
- return null;
- }
-
- @Override
- public Map<String, EncapsulationType> encapByVplsName() {
- return ImmutableMap.copyOf(vplsEncaps);
- }
-
- /**
- * Retrieves the VPLS configuration from network configuration.
- */
- private void loadConfiguration() {
- loadAppId();
-
- vplsAppConfig = configService.getConfig(vplsAppId, VplsAppConfig.class);
-
- if (vplsAppConfig == null) {
- log.warn(CONFIG_NULL);
- vplsAppConfig = configService.addConfig(vplsAppId, VplsAppConfig.class);
- }
-
- oldIfacesOfVpls = ifacesOfVpls;
- ifacesOfVpls = getConfigInterfaces();
- vplsIfaces = getConfigCPointsFromIfaces();
- vplsEncaps = getConfigEncap();
-
- log.debug(CONFIG_CHANGED, ifacesOfVpls);
- }
-
- /**
- * Retrieves the application identifier from core service.
- */
- private void loadAppId() {
- vplsAppId = coreService.getAppId(VPLS_APP);
- if (vplsAppId == null) {
- log.warn(APP_ID_NULL);
- }
- }
-
- /**
- * Applies a given configuration to the VPLS application.
- */
- private void applyConfig(VplsAppConfig vplsAppConfig) {
- loadAppId();
- configService.applyConfig(vplsAppId, VplsAppConfig.class, vplsAppConfig.node());
- }
-
- /**
- * Retrieves the VPLS names and related encapsulation types from the
- * configuration.
- *
- * @return a map of VPLS names and associated encapsulation types
- */
- private Map<String, EncapsulationType> getConfigEncap() {
- Map<String, EncapsulationType> configEncap = new HashMap<>();
-
- vplsAppConfig.vplss().forEach(vpls -> {
- configEncap.put(vpls.name(), vpls.encap());
- });
-
- return configEncap;
- }
-
- /**
- * Retrieves the VPLS names and related interfaces names from the configuration.
- *
- * @return a map of VPLS names and related interface names
- */
- private SetMultimap<String, String> getConfigInterfaces() {
- SetMultimap<String, String> confIntfByVpls =
- HashMultimap.create();
-
- vplsAppConfig.vplss().forEach(vpls -> {
- if (vpls.ifaces().isEmpty()) {
- confIntfByVpls.put(vpls.name(), EMPTY);
- } else {
- vpls.ifaces().forEach(iface -> confIntfByVpls.put(vpls.name(), iface));
- }
- });
-
- return confIntfByVpls;
- }
-
- /**
- * Retrieves the VPLS names and related interfaces from the configuration.
- *
- * @return a map of VPLS names and related interfaces
- */
- private SetMultimap<String, Interface> getConfigCPointsFromIfaces() {
- log.debug(CHECK_CONFIG);
-
- SetMultimap<String, Interface> confCPointsByIntf =
- HashMultimap.create();
-
- ifacesOfVpls.entries().forEach(vpls -> {
- interfaceService.getInterfaces()
- .stream()
- .filter(intf -> intf.ipAddressesList().isEmpty())
- .filter(intf -> intf.name().equals(vpls.getValue()))
- .forEach(intf -> confCPointsByIntf.put(vpls.getKey(), intf));
- });
-
- return confCPointsByIntf;
- }
-
- /**
- * Listener for VPLS configuration events.
- */
- private class InternalNetworkConfigListener implements NetworkConfigListener {
- @Override
- public void event(NetworkConfigEvent event) {
- if (event.configClass() == VplsConfigService.CONFIG_CLASS) {
- log.debug(NET_CONF_EVENT, event.configClass());
- switch (event.type()) {
- case CONFIG_ADDED:
- case CONFIG_UPDATED:
- case CONFIG_REMOVED:
- loadConfiguration();
- break;
- default:
- break;
- }
- }
- }
- }
-}
\ No newline at end of file
diff --git a/apps/vpls/src/main/java/org/onosproject/vpls/intent/VplsIntentUtility.java b/apps/vpls/src/main/java/org/onosproject/vpls/intent/VplsIntentUtility.java
new file mode 100644
index 0000000..a81a72f
--- /dev/null
+++ b/apps/vpls/src/main/java/org/onosproject/vpls/intent/VplsIntentUtility.java
@@ -0,0 +1,339 @@
+/*
+ * Copyright 2017-present 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.vpls.intent;
+
+import com.google.common.collect.ImmutableList;
+import com.google.common.collect.ImmutableSet;
+import com.google.common.collect.Sets;
+import org.onlab.packet.MacAddress;
+import org.onlab.packet.VlanId;
+import org.onosproject.core.ApplicationId;
+import org.onosproject.incubator.net.intf.Interface;
+import org.onosproject.net.ConnectPoint;
+import org.onosproject.net.EncapsulationType;
+import org.onosproject.net.FilteredConnectPoint;
+import org.onosproject.net.Host;
+import org.onosproject.net.ResourceGroup;
+import org.onosproject.net.flow.DefaultTrafficSelector;
+import org.onosproject.net.flow.TrafficSelector;
+import org.onosproject.net.intent.ConnectivityIntent;
+import org.onosproject.net.intent.Constraint;
+import org.onosproject.net.intent.Intent;
+import org.onosproject.net.intent.Key;
+import org.onosproject.net.intent.MultiPointToSinglePointIntent;
+import org.onosproject.net.intent.SinglePointToMultiPointIntent;
+import org.onosproject.net.intent.constraint.EncapsulationConstraint;
+import org.onosproject.net.intent.constraint.PartialFailureConstraint;
+import org.onosproject.vpls.api.VplsData;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+import java.util.ArrayList;
+import java.util.List;
+import java.util.Objects;
+import java.util.Set;
+import java.util.stream.Collectors;
+
+import static java.util.Objects.*;
+import static org.onosproject.net.EncapsulationType.*;
+
+/**
+ * Intent utilities for VPLS.
+ */
+public final class VplsIntentUtility {
+ private static final String SP2MP =
+ "Building sp2mp intent from {}";
+ private static final String MP2SP =
+ "Building mp2sp intent to {}";
+
+ private static final Logger log = LoggerFactory.getLogger(
+ VplsIntentUtility.class);
+
+ private static final int PRIORITY_OFFSET = 1000;
+ private static final int PRIORITY_UNI = 200;
+ private static final int PRIORITY_BRC = 100;
+
+ public static final String PREFIX_BROADCAST = "brc";
+ public static final String PREFIX_UNICAST = "uni";
+ private static final String SEPARATOR = "-";
+
+ public static final ImmutableList<Constraint> PARTIAL_FAILURE_CONSTRAINT =
+ ImmutableList.of(new PartialFailureConstraint());
+
+ private VplsIntentUtility() {
+ // Utility classes should not have a public or default constructor.
+ }
+
+ /**
+ * Builds broadcast Intents for a VPLS.
+ *
+ * @param vplsData the VPLS
+ * @param appId the application id for Intents
+ * @return broadcast Intents for the VPLS
+ */
+ public static Set<Intent> buildBrcIntents(VplsData vplsData, ApplicationId appId) {
+ Set<Interface> interfaces = vplsData.interfaces();
+
+ // At least two or more network interfaces to build broadcast Intents
+ if (interfaces.size() < 2) {
+ return ImmutableSet.of();
+ }
+ Set<Intent> brcIntents = Sets.newHashSet();
+ ResourceGroup resourceGroup = ResourceGroup.of(vplsData.name());
+
+ // Generates broadcast Intents from any network interface to other
+ // network interface from the VPLS.
+ interfaces.forEach(src -> {
+ FilteredConnectPoint srcFcp = VplsIntentUtility.buildFilteredConnectedPoint(src);
+ Set<FilteredConnectPoint> dstFcps =
+ interfaces.stream()
+ .filter(iface -> !iface.equals(src))
+ .map(VplsIntentUtility::buildFilteredConnectedPoint)
+ .collect(Collectors.toSet());
+ Key key = VplsIntentUtility.buildKey(PREFIX_BROADCAST,
+ srcFcp.connectPoint(),
+ vplsData.name(),
+ MacAddress.BROADCAST,
+ appId);
+ Intent brcIntent = buildBrcIntent(key,
+ appId,
+ srcFcp,
+ dstFcps,
+ vplsData.encapsulationType(),
+ resourceGroup);
+
+ brcIntents.add(brcIntent);
+ });
+ return brcIntents;
+ }
+
+ /**
+ * Builds a broadcast intent.
+ *
+ * @param key key to identify the intent
+ * @param appId application ID for this Intent
+ * @param src the source connect point
+ * @param dsts the destination connect points
+ * @param encap the encapsulation type
+ * @param resourceGroup resource group for this Intent
+ * @return the generated single-point to multi-point intent
+ */
+ protected static SinglePointToMultiPointIntent buildBrcIntent(Key key,
+ ApplicationId appId,
+ FilteredConnectPoint src,
+ Set<FilteredConnectPoint> dsts,
+ EncapsulationType encap,
+ ResourceGroup resourceGroup) {
+ log.debug("Building broadcast intent {} for source {}", SP2MP, src);
+
+ SinglePointToMultiPointIntent.Builder intentBuilder;
+
+ TrafficSelector selector = DefaultTrafficSelector.builder()
+ .matchEthDst(MacAddress.BROADCAST)
+ .build();
+
+ intentBuilder = SinglePointToMultiPointIntent.builder()
+ .appId(appId)
+ .key(key)
+ .selector(selector)
+ .filteredIngressPoint(src)
+ .filteredEgressPoints(dsts)
+ .constraints(PARTIAL_FAILURE_CONSTRAINT)
+ .priority(PRIORITY_OFFSET + PRIORITY_BRC)
+ .resourceGroup(resourceGroup);
+
+ setEncap(intentBuilder, PARTIAL_FAILURE_CONSTRAINT, encap);
+
+ return intentBuilder.build();
+ }
+
+ /**
+ * Builds unicast Intents for a VPLS.
+ *
+ * @param vplsData the VPLS
+ * @param hosts the hosts of the VPLS
+ * @param appId application ID for Intents
+ * @return unicast Intents for the VPLS
+ */
+ public static Set<Intent> buildUniIntents(VplsData vplsData, Set<Host> hosts, ApplicationId appId) {
+ Set<Interface> interfaces = vplsData.interfaces();
+ if (interfaces.size() < 2) {
+ return ImmutableSet.of();
+ }
+ Set<Intent> uniIntents = Sets.newHashSet();
+ ResourceGroup resourceGroup = ResourceGroup.of(vplsData.name());
+ hosts.forEach(host -> {
+ FilteredConnectPoint hostFcp = buildFilteredConnectedPoint(host);
+ Set<FilteredConnectPoint> srcFcps =
+ interfaces.stream()
+ .map(VplsIntentUtility::buildFilteredConnectedPoint)
+ .filter(fcp -> !fcp.equals(hostFcp))
+ .collect(Collectors.toSet());
+ Key key = buildKey(PREFIX_UNICAST,
+ hostFcp.connectPoint(),
+ vplsData.name(),
+ host.mac(),
+ appId);
+ Intent uniIntent = buildUniIntent(key,
+ appId,
+ srcFcps,
+ hostFcp,
+ host,
+ vplsData.encapsulationType(),
+ resourceGroup);
+ uniIntents.add(uniIntent);
+ });
+
+ return uniIntents;
+ }
+
+ /**
+ * Builds a unicast intent.
+ *
+ * @param key key to identify the intent
+ * @param appId application ID for this Intent
+ * @param srcs the source Connect Points
+ * @param dst the destination Connect Point
+ * @param host destination Host
+ * @param encap the encapsulation type
+ * @param resourceGroup resource group for this Intent
+ * @return the generated multi-point to single-point intent
+ */
+ protected static MultiPointToSinglePointIntent buildUniIntent(Key key,
+ ApplicationId appId,
+ Set<FilteredConnectPoint> srcs,
+ FilteredConnectPoint dst,
+ Host host,
+ EncapsulationType encap,
+ ResourceGroup resourceGroup) {
+ log.debug("Building unicast intent {} for destination {}", MP2SP, dst);
+
+ MultiPointToSinglePointIntent.Builder intentBuilder;
+
+ TrafficSelector selector = DefaultTrafficSelector.builder()
+ .matchEthDst(host.mac())
+ .build();
+
+ intentBuilder = MultiPointToSinglePointIntent.builder()
+ .appId(appId)
+ .key(key)
+ .selector(selector)
+ .filteredIngressPoints(srcs)
+ .filteredEgressPoint(dst)
+ .constraints(PARTIAL_FAILURE_CONSTRAINT)
+ .priority(PRIORITY_OFFSET + PRIORITY_UNI)
+ .resourceGroup(resourceGroup);
+
+ setEncap(intentBuilder, PARTIAL_FAILURE_CONSTRAINT, encap);
+
+ return intentBuilder.build();
+ }
+
+ /**
+ * Builds an intent key either for single-point to multi-point or
+ * multi-point to single-point intents, based on a prefix that defines
+ * the type of intent, the single connect point representing the single
+ * source or destination for that intent, the name of the VPLS the intent
+ * belongs to, and the destination host MAC address the intent reaches.
+ *
+ * @param prefix the key prefix
+ * @param cPoint the connect point identifying the source/destination
+ * @param vplsName the name of the VPLS
+ * @param hostMac the source/destination MAC address
+ * @param appId application ID for the key
+ * @return the key to identify the intent
+ */
+ protected static Key buildKey(String prefix,
+ ConnectPoint cPoint,
+ String vplsName,
+ MacAddress hostMac,
+ ApplicationId appId) {
+ String keyString = vplsName +
+ SEPARATOR +
+ prefix +
+ SEPARATOR +
+ cPoint.deviceId() +
+ SEPARATOR +
+ cPoint.port() +
+ SEPARATOR +
+ hostMac;
+
+ return Key.of(keyString, appId);
+ }
+
+
+ /**
+ * Sets one or more encapsulation constraints on the intent builder given.
+ *
+ * @param builder the intent builder
+ * @param constraints the existing intent constraints
+ * @param encap the encapsulation type to be set
+ */
+ public static void setEncap(ConnectivityIntent.Builder builder,
+ List<Constraint> constraints,
+ EncapsulationType encap) {
+ // Constraints might be an immutable list, so a new modifiable list
+ // is created
+ List<Constraint> newConstraints = new ArrayList<>(constraints);
+
+ // Remove any encapsulation constraint if already in the list
+ constraints.stream()
+ .filter(c -> c instanceof EncapsulationConstraint)
+ .forEach(newConstraints::remove);
+
+ // if the new encapsulation is different from NONE, a new encapsulation
+ // constraint should be added to the list
+ if (!encap.equals(NONE)) {
+ newConstraints.add(new EncapsulationConstraint(encap));
+ }
+
+ // Submit new constraint list as immutable list
+ builder.constraints(ImmutableList.copyOf(newConstraints));
+ }
+
+ /**
+ * Builds filtered connected point by a given network interface.
+ *
+ * @param iface the network interface
+ * @return the filtered connected point of a given network interface
+ */
+ protected static FilteredConnectPoint buildFilteredConnectedPoint(Interface iface) {
+ Objects.requireNonNull(iface);
+ TrafficSelector.Builder trafficSelector = DefaultTrafficSelector.builder();
+
+ if (iface.vlan() != null && !iface.vlan().equals(VlanId.NONE)) {
+ trafficSelector.matchVlanId(iface.vlan());
+ }
+
+ return new FilteredConnectPoint(iface.connectPoint(), trafficSelector.build());
+ }
+
+ /**
+ * Builds filtered connected point by a given host.
+ *
+ * @param host the host
+ * @return the filtered connected point of the given host
+ */
+ protected static FilteredConnectPoint buildFilteredConnectedPoint(Host host) {
+ requireNonNull(host);
+ TrafficSelector.Builder trafficSelector = DefaultTrafficSelector.builder();
+
+ if (host.vlan() != null && !host.vlan().equals(VlanId.NONE)) {
+ trafficSelector.matchVlanId(host.vlan());
+ }
+ return new FilteredConnectPoint(host.location(), trafficSelector.build());
+ }
+}
diff --git a/apps/vpls/src/main/java/org/onosproject/vpls/config/impl/package-info.java b/apps/vpls/src/main/java/org/onosproject/vpls/intent/package-info.java
similarity index 79%
copy from apps/vpls/src/main/java/org/onosproject/vpls/config/impl/package-info.java
copy to apps/vpls/src/main/java/org/onosproject/vpls/intent/package-info.java
index b5d6ec9..197ea02 100644
--- a/apps/vpls/src/main/java/org/onosproject/vpls/config/impl/package-info.java
+++ b/apps/vpls/src/main/java/org/onosproject/vpls/intent/package-info.java
@@ -1,5 +1,5 @@
/*
- * Copyright 2016-present Open Networking Laboratory
+ * Copyright 2017-present 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.
@@ -15,6 +15,6 @@
*/
/**
- * Configuration service implementation for VPLS.
+ * Utility for generate Intent for VPLS.
*/
-package org.onosproject.vpls.config.impl;
+package org.onosproject.vpls.intent;
\ No newline at end of file
diff --git a/apps/vpls/src/main/java/org/onosproject/vpls/store/DistributedVplsStore.java b/apps/vpls/src/main/java/org/onosproject/vpls/store/DistributedVplsStore.java
new file mode 100644
index 0000000..1743491
--- /dev/null
+++ b/apps/vpls/src/main/java/org/onosproject/vpls/store/DistributedVplsStore.java
@@ -0,0 +1,223 @@
+/*
+ * Copyright 2017-present 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.vpls.store;
+
+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.util.KryoNamespace;
+import org.onosproject.core.ApplicationId;
+import org.onosproject.core.CoreService;
+import org.onosproject.incubator.net.intf.Interface;
+import org.onosproject.net.config.NetworkConfigService;
+import org.onosproject.store.AbstractStore;
+import org.onosproject.store.StoreDelegate;
+import org.onosproject.store.serializers.KryoNamespaces;
+import org.onosproject.store.service.EventuallyConsistentMap;
+import org.onosproject.store.service.EventuallyConsistentMapEvent;
+import org.onosproject.store.service.EventuallyConsistentMapListener;
+import org.onosproject.store.service.StorageService;
+import org.onosproject.store.service.WallClockTimestamp;
+import org.onosproject.vpls.VplsManager;
+import org.onosproject.vpls.api.VplsData;
+import org.onosproject.vpls.api.VplsOperation;
+import org.onosproject.vpls.config.VplsAppConfig;
+import org.onosproject.vpls.api.VplsStore;
+import org.onosproject.vpls.config.VplsConfig;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+import java.util.Collection;
+import java.util.Set;
+import java.util.concurrent.CompletableFuture;
+import java.util.stream.Collectors;
+
+import static java.util.Objects.*;
+
+/**
+ * Implementation of VPLSConfigurationService which reads VPLS configuration
+ * from the network configuration service.
+ */
+@Component(immediate = true)
+@Service
+public class DistributedVplsStore
+ extends AbstractStore<VplsStoreEvent, StoreDelegate<VplsStoreEvent>>
+ implements VplsStore {
+
+ private static final KryoNamespace APP_KRYO = KryoNamespace.newBuilder()
+ .register(KryoNamespaces.API)
+ .register(VplsData.class)
+ .register(VplsOperation.class)
+ .build();
+
+ private final Logger log = LoggerFactory.getLogger(getClass());
+
+ @Reference(cardinality = ReferenceCardinality.MANDATORY_UNARY)
+ protected CoreService coreService;
+
+ @Reference(cardinality = ReferenceCardinality.MANDATORY_UNARY)
+ protected StorageService storageService;
+
+ @Reference(cardinality = ReferenceCardinality.MANDATORY_UNARY)
+ protected NetworkConfigService networkConfigService;
+
+ private EventuallyConsistentMap<String, VplsData> vplsDataStore;
+ private EventuallyConsistentMapListener<String, VplsData> vplsDataListener;
+ private ApplicationId appId;
+
+ @Activate
+ protected void active() {
+ appId = coreService.registerApplication(VplsManager.VPLS_APP);
+
+ vplsDataStore = storageService.<String, VplsData>eventuallyConsistentMapBuilder()
+ .withName("VPLS-Data")
+ .withTimestampProvider((name, vpls) -> new WallClockTimestamp())
+ .withSerializer(APP_KRYO)
+ .build();
+ vplsDataListener = new InternalVplsDataListener();
+ vplsDataStore.addListener(vplsDataListener);
+ log.info("Started");
+ }
+
+ @Deactivate
+ protected void deactive() {
+ vplsDataStore.removeListener(vplsDataListener);
+ log.info("Stopped");
+ }
+
+ @Override
+ public void addVpls(VplsData vplsData) {
+ requireNonNull(vplsData);
+ if (vplsData.name().isEmpty()) {
+ throw new IllegalArgumentException("VPLS name is empty.");
+ }
+ vplsData.state(VplsData.VplsState.ADDING);
+ this.vplsDataStore.put(vplsData.name(), vplsData);
+ }
+
+ @Override
+ public void removeVpls(VplsData vplsData) {
+ requireNonNull(vplsData);
+ if (vplsData.name().isEmpty()) {
+ throw new IllegalArgumentException("VPLS name is empty.");
+ }
+ vplsData.state(VplsData.VplsState.REMOVING);
+ if (!this.vplsDataStore.containsKey(vplsData.name())) {
+ // notify the delegate asynchronously if VPLS does not exists
+ CompletableFuture.runAsync(() -> {
+ VplsStoreEvent event = new VplsStoreEvent(VplsStoreEvent.Type.REMOVE,
+ vplsData);
+ notifyDelegate(event);
+ });
+ return;
+ }
+ this.vplsDataStore.remove(vplsData.name());
+ }
+
+ @Override
+ public void updateVpls(VplsData vplsData) {
+ switch (vplsData.state()) {
+ case ADDED:
+ case REMOVED:
+ case FAILED:
+ // state update only
+ this.vplsDataStore.put(vplsData.name(), vplsData);
+ break;
+ default:
+ vplsData.state(VplsData.VplsState.UPDATING);
+ this.vplsDataStore.put(vplsData.name(), vplsData);
+ break;
+ }
+ }
+
+ @Override
+ public VplsData getVpls(String vplsName) {
+ return vplsDataStore.get(vplsName);
+ }
+
+ @Override
+ public Collection<VplsData> getAllVpls() {
+ return vplsDataStore.values();
+ }
+
+ /**
+ * Writes all VPLS data to the network configuration store.
+ *
+ * @param vplsDataCollection the VPLSs data
+ */
+ public void writeVplsToNetConfig(Collection<VplsData> vplsDataCollection) {
+ VplsAppConfig config = networkConfigService.addConfig(appId, VplsAppConfig.class);
+ config.clearVplsConfig();
+
+ // Setup update time for this VPLS application configuration
+ WallClockTimestamp ts = new WallClockTimestamp();
+ config.updateTime(ts.unixTimestamp());
+
+ vplsDataCollection.forEach(vplsData -> {
+ Set<String> interfaceNames = vplsData.interfaces()
+ .stream()
+ .map(Interface::name)
+ .collect(Collectors.toSet());
+ VplsConfig vplsConfig = new VplsConfig(vplsData.name(), interfaceNames,
+ vplsData.encapsulationType());
+ config.addVpls(vplsConfig);
+ });
+
+ networkConfigService.applyConfig(appId, VplsAppConfig.class, config.node());
+ }
+
+ /**
+ * Listener for VPLS data store.
+ */
+ private class InternalVplsDataListener implements EventuallyConsistentMapListener<String, VplsData> {
+ private static final String STATE_UPDATE = "VPLS state updated, new VPLS: {}";
+
+ @Override
+ public void event(EventuallyConsistentMapEvent<String, VplsData> event) {
+ VplsData vplsData = event.value();
+ // Update network config
+ writeVplsToNetConfig(getAllVpls());
+ switch (event.type()) {
+ case PUT:
+ // Add or Update
+ if (vplsData.state() == VplsData.VplsState.ADDING) {
+ VplsStoreEvent vplsStoreEvent =
+ new VplsStoreEvent(VplsStoreEvent.Type.ADD, vplsData);
+ notifyDelegate(vplsStoreEvent);
+ } else if (vplsData.state() == VplsData.VplsState.UPDATING) {
+ VplsStoreEvent vplsStoreEvent =
+ new VplsStoreEvent(VplsStoreEvent.Type.UPDATE, vplsData);
+ notifyDelegate(vplsStoreEvent);
+ } else {
+ // Do nothing here, just update state from operation service
+ log.debug(STATE_UPDATE, vplsData);
+ }
+ break;
+ case REMOVE:
+ VplsStoreEvent vplsStoreEvent =
+ new VplsStoreEvent(VplsStoreEvent.Type.REMOVE, vplsData);
+ notifyDelegate(vplsStoreEvent);
+ break;
+ default:
+ break;
+ }
+
+ }
+ }
+}
\ No newline at end of file
diff --git a/apps/vpls/src/main/java/org/onosproject/vpls/store/VplsStoreEvent.java b/apps/vpls/src/main/java/org/onosproject/vpls/store/VplsStoreEvent.java
new file mode 100644
index 0000000..210470c
--- /dev/null
+++ b/apps/vpls/src/main/java/org/onosproject/vpls/store/VplsStoreEvent.java
@@ -0,0 +1,46 @@
+/*
+ * Copyright 2017-present 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.vpls.store;
+
+import org.onosproject.event.AbstractEvent;
+import org.onosproject.vpls.api.VplsData;
+
+/**
+ * A class to represent a VPLS store related event.
+ */
+public class VplsStoreEvent extends AbstractEvent<VplsStoreEvent.Type, VplsData> {
+
+ /**
+ * VPLS store event type.
+ */
+ public enum Type {
+ ADD,
+ REMOVE,
+ UPDATE
+ }
+
+ /**
+ * Constructs a store event with given event type and VPLS information.
+ *
+ * @param type the event type
+ * @param subject the VPLS
+ */
+ public VplsStoreEvent(Type type, VplsData subject) {
+ super(type, subject);
+ }
+
+}
diff --git a/apps/vpls/src/main/java/org/onosproject/vpls/config/impl/package-info.java b/apps/vpls/src/main/java/org/onosproject/vpls/store/package-info.java
similarity index 78%
copy from apps/vpls/src/main/java/org/onosproject/vpls/config/impl/package-info.java
copy to apps/vpls/src/main/java/org/onosproject/vpls/store/package-info.java
index b5d6ec9..0f1a807 100644
--- a/apps/vpls/src/main/java/org/onosproject/vpls/config/impl/package-info.java
+++ b/apps/vpls/src/main/java/org/onosproject/vpls/store/package-info.java
@@ -1,5 +1,5 @@
/*
- * Copyright 2016-present Open Networking Laboratory
+ * Copyright 2017-present 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.
@@ -14,7 +14,4 @@
* limitations under the License.
*/
-/**
- * Configuration service implementation for VPLS.
- */
-package org.onosproject.vpls.config.impl;
+package org.onosproject.vpls.store;
\ No newline at end of file
diff --git a/apps/vpls/src/test/java/org/onosproject/vpls/VplsConfigServiceAdapter.java b/apps/vpls/src/test/java/org/onosproject/vpls/VplsConfigServiceAdapter.java
deleted file mode 100644
index e5844fb..0000000
--- a/apps/vpls/src/test/java/org/onosproject/vpls/VplsConfigServiceAdapter.java
+++ /dev/null
@@ -1,99 +0,0 @@
-/*
- * Copyright 2016-present 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.vpls;
-
-import com.google.common.collect.SetMultimap;
-import org.onlab.packet.VlanId;
-import org.onosproject.incubator.net.intf.Interface;
-import org.onosproject.net.ConnectPoint;
-import org.onosproject.net.EncapsulationType;
-import org.onosproject.vpls.config.VplsConfigService;
-
-import java.util.Map;
-import java.util.Set;
-
-/**
- * Test adapter for VPLS configuration service.
- */
-public class VplsConfigServiceAdapter implements VplsConfigService {
- @Override
- public void addVpls(String vplsName, Set<String> ifaces, String encap) {}
-
- @Override
- public void removeVpls(String vplsName) {}
-
- @Override
- public void addIface(String vplsName, String iface) {}
-
- @Override
- public void setEncap(String vplsName, String encap) {}
-
- @Override
- public EncapsulationType encap(String vplsName) {
- return null;
- }
-
- @Override
- public void removeIface(String iface) {}
-
- @Override
- public void cleanVplsConfig() {}
-
- @Override
- public Set<String> vplsAffectedByApi() {
- return null;
- }
-
- @Override
- public Set<Interface> allIfaces() {
- return null;
- }
-
- @Override
- public Set<Interface> ifaces() {
- return null;
- }
-
- @Override
- public Set<Interface> ifaces(String vplsName) {
- return null;
- }
-
- @Override
- public Set<String> vplsNames() {
- return null;
- }
-
- @Override
- public Set<String> vplsNamesOld() {
- return null;
- }
-
- @Override
- public SetMultimap<String, Interface> ifacesByVplsName() {
- return null;
- }
-
- @Override
- public SetMultimap<String, Interface> ifacesByVplsName(VlanId vlan, ConnectPoint connectPoint) {
- return null;
- }
-
- @Override
- public Map<String, EncapsulationType> encapByVplsName() {
- return null;
- }
-}
diff --git a/apps/vpls/src/test/java/org/onosproject/vpls/VplsIntentTest.java b/apps/vpls/src/test/java/org/onosproject/vpls/VplsIntentTest.java
new file mode 100644
index 0000000..7ee9292
--- /dev/null
+++ b/apps/vpls/src/test/java/org/onosproject/vpls/VplsIntentTest.java
@@ -0,0 +1,537 @@
+/*
+ * Copyright 2016-present 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.vpls;
+
+import com.google.common.collect.ImmutableSet;
+import com.google.common.collect.Lists;
+import com.google.common.collect.Maps;
+import com.google.common.collect.Sets;
+import org.junit.After;
+import org.junit.Before;
+import org.junit.Test;
+import org.onlab.packet.MacAddress;
+import org.onlab.packet.VlanId;
+import org.onosproject.incubator.net.intf.Interface;
+import org.onosproject.incubator.net.intf.InterfaceListener;
+import org.onosproject.incubator.net.intf.InterfaceService;
+import org.onosproject.net.ConnectPoint;
+import org.onosproject.net.EncapsulationType;
+import org.onosproject.net.FilteredConnectPoint;
+import org.onosproject.net.Host;
+import org.onosproject.net.flow.DefaultTrafficSelector;
+import org.onosproject.net.flow.TrafficSelector;
+import org.onosproject.net.flow.criteria.Criterion;
+import org.onosproject.net.flow.criteria.VlanIdCriterion;
+import org.onosproject.net.intent.Intent;
+import org.onosproject.net.intent.IntentService;
+import org.onosproject.net.intent.IntentServiceAdapter;
+import org.onosproject.net.intent.IntentUtils;
+import org.onosproject.net.intent.Key;
+import org.onosproject.net.intent.MultiPointToSinglePointIntent;
+import org.onosproject.net.intent.SinglePointToMultiPointIntent;
+import org.onosproject.vpls.api.VplsData;
+import org.onosproject.vpls.intent.VplsIntentUtility;
+
+import java.util.Collection;
+import java.util.List;
+import java.util.Map;
+import java.util.Set;
+import java.util.stream.Collectors;
+
+import static java.lang.String.format;
+import static org.easymock.EasyMock.anyObject;
+import static org.easymock.EasyMock.createMock;
+import static org.easymock.EasyMock.expect;
+import static org.easymock.EasyMock.expectLastCall;
+import static org.easymock.EasyMock.replay;
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertTrue;
+import static org.onosproject.net.EncapsulationType.NONE;
+import static org.onosproject.net.EncapsulationType.VLAN;
+
+/**
+ * Tests for {@link VplsIntentUtility}.
+ */
+public class VplsIntentTest extends VplsTest {
+
+ private Set<Host> hostsAvailable;
+ private IntentService intentService;
+ private InterfaceService interfaceService;
+
+ @Before
+ public void setUp() throws Exception {
+ idGenerator = new TestIdGenerator();
+ Intent.unbindIdGenerator(idGenerator);
+ Intent.bindIdGenerator(idGenerator);
+ hostsAvailable = Sets.newHashSet();
+ intentService = new TestIntentService();
+ interfaceService = createMock(InterfaceService.class);
+ interfaceService.addListener(anyObject(InterfaceListener.class));
+ expectLastCall().anyTimes();
+ addIfaceConfig();
+ }
+
+ @After
+ public void tearDown() {
+ Intent.unbindIdGenerator(idGenerator);
+ }
+
+ /**
+ * Creates the interface configuration:
+ * On devices 1 and 2 is configured an interface on port 1 with vlan 100.
+ * On device 3 is configured an interface on port 3 with no vlan.
+ * On devices 3 and 4 is configured an interface on port 1 with vlan 200.
+ * On device 4 is an interface configured on port 2 with vlan 400.
+ * On device 5 are configured two interfaces on port 1 and 2 with no vlan.
+ * On device 5 and 6 is configured an interface on port 1 with vlan 300.
+ */
+ private void addIfaceConfig() {
+ Set<Interface> interfaces = ImmutableSet.copyOf(AVAILABLE_INTERFACES);
+ Set<Interface> vlanOneSet = ImmutableSet.of(V100H1, V100H2);
+ Set<Interface> vlanTwoSet = ImmutableSet.of(V200H1, V200H2);
+ Set<Interface> vlanThreeSet = ImmutableSet.of(VNONEH1, VNONEH2);
+ Set<Interface> vlanFourSet = ImmutableSet.of(V400H1, VNONEH3);
+
+ AVAILABLE_INTERFACES.forEach(intf -> {
+ expect(interfaceService.getInterfacesByPort(intf.connectPoint()))
+ .andReturn(Sets.newHashSet(intf)).anyTimes();
+ });
+ expect(interfaceService.getInterfacesByVlan(VLAN100))
+ .andReturn(vlanOneSet).anyTimes();
+ expect(interfaceService.getInterfacesByVlan(VLAN200))
+ .andReturn(vlanTwoSet).anyTimes();
+ expect(interfaceService.getInterfacesByVlan(VLAN300))
+ .andReturn(vlanThreeSet).anyTimes();
+ expect(interfaceService.getInterfacesByVlan(VLAN400))
+ .andReturn(vlanFourSet).anyTimes();
+ expect(interfaceService.getInterfacesByVlan(VlanId.NONE))
+ .andReturn(vlanFourSet).anyTimes();
+ expect(interfaceService.getInterfaces()).andReturn(interfaces).anyTimes();
+
+ replay(interfaceService);
+ }
+
+ /**
+ * Seven ports are configured with VLANs, while three ports are not. No hosts are
+ * registered by the HostService.
+ *
+ * The first three ports have an interface configured on VPLS 1,
+ * the other three on VPLS 2. Two ports are defined for VPLS 3, while
+ * the two remaining ports are configured on VPLS 4.
+ *
+ * The number of intents expected is 10: three for VPLS 1, three for VPLS 2,
+ * two for VPLS 3, two for VPLS 4. Eight MP2SP intents.
+ * Checks if the number of intents submitted to the intent framework is
+ * equal to the number of intents expected and if all intents are equivalent.
+ */
+ @Test
+ public void activateNoHosts() {
+ List<Intent> expectedIntents = Lists.newArrayList();
+ Set<FilteredConnectPoint> fcPoints;
+ Set<Interface> interfaces;
+
+ interfaces = ImmutableSet.of(V100H1, V200H1, V300H1);
+ VplsData vplsData = createVplsData(VPLS1, VLAN, interfaces);
+ Set<Intent> brcIntents = VplsIntentUtility.buildBrcIntents(vplsData, APPID);
+ brcIntents.forEach(intentService::submit);
+ fcPoints = buildFCPoints(interfaces);
+ expectedIntents.addAll(generateVplsBrc(fcPoints, VPLS1, VLAN));
+
+ checkIntents(expectedIntents);
+
+ interfaces = ImmutableSet.of(V100H2, V200H2, V300H2);
+ vplsData = createVplsData(VPLS2, NONE, interfaces);
+ brcIntents = VplsIntentUtility.buildBrcIntents(vplsData, APPID);
+ brcIntents.forEach(intentService::submit);
+ fcPoints = buildFCPoints(interfaces);
+ expectedIntents.addAll(generateVplsBrc(fcPoints, VPLS2, NONE));
+
+ checkIntents(expectedIntents);
+
+ interfaces = ImmutableSet.of(VNONEH1, VNONEH2);
+ vplsData = createVplsData(VPLS3, NONE, interfaces);
+ brcIntents = VplsIntentUtility.buildBrcIntents(vplsData, APPID);
+ brcIntents.forEach(intentService::submit);
+ fcPoints = buildFCPoints(interfaces);
+ expectedIntents.addAll(generateVplsBrc(fcPoints, VPLS3, NONE));
+
+ checkIntents(expectedIntents);
+
+ interfaces = ImmutableSet.of(V400H1, VNONEH3);
+ vplsData = createVplsData(VPLS4, NONE, interfaces);
+ brcIntents = VplsIntentUtility.buildBrcIntents(vplsData, APPID);
+ brcIntents.forEach(intentService::submit);
+ fcPoints = buildFCPoints(interfaces);
+ expectedIntents.addAll(generateVplsBrc(fcPoints, VPLS4, NONE));
+
+ checkIntents(expectedIntents);
+ }
+
+
+
+ /**
+ * Ten ports are configured with VLANs and ten hosts are registered by the
+ * HostService.
+ *
+ * The first three ports have an interface configured on VPLS 1,
+ * the other three on VPLS 2, two on VPLS3 and two on VPLS4.
+ *
+ * The number of intents expected is twenty: six
+ * for VPLS 1, six for VPLS 2. four for VPLS 3, four for VPLS 4.
+ * That is ten sp2mp intents, ten mp2sp intents. For VPLS 1
+ * IPs are added to demonstrate this doesn't influence the number of intents
+ * created. Checks if the number of intents submitted to the intent
+ * framework is equal to the number of intents expected and if all intents
+ * are equivalent.
+ */
+ @Test
+ public void tenInterfacesConfiguredHostsPresent() {
+ hostsAvailable.addAll(AVAILABLE_HOSTS);
+
+ List<Intent> expectedIntents = Lists.newArrayList();
+ Set<FilteredConnectPoint> fcPoints;
+ Set<Host> hosts;
+ Set<Interface> interfaces;
+ VplsData vplsData;
+ Set<Intent> brcIntents;
+ Set<Intent> uniIntents;
+
+ interfaces = ImmutableSet.of(V100H1, V200H1, V300H1);
+ fcPoints = buildFCPoints(interfaces);
+ hosts = ImmutableSet.of(V100HOST1, V200HOST1, V300HOST1);
+ vplsData = createVplsData(VPLS1, VLAN, interfaces);
+ brcIntents = VplsIntentUtility.buildBrcIntents(vplsData, APPID);
+ uniIntents = VplsIntentUtility.buildUniIntents(vplsData, hosts, APPID);
+ brcIntents.forEach(intentService::submit);
+ uniIntents.forEach(intentService::submit);
+ expectedIntents.addAll(generateVplsBrc(fcPoints, VPLS1, VLAN));
+ expectedIntents.addAll(generateVplsUni(fcPoints, hosts, VPLS1, VLAN));
+
+ interfaces = ImmutableSet.of(V100H2, V200H2, V300H2);
+ fcPoints = buildFCPoints(interfaces);
+ hosts = ImmutableSet.of(V100HOST2, V200HOST2, V300HOST2);
+ vplsData = createVplsData(VPLS2, NONE, interfaces);
+ brcIntents = VplsIntentUtility.buildBrcIntents(vplsData, APPID);
+ uniIntents = VplsIntentUtility.buildUniIntents(vplsData, hosts, APPID);
+ brcIntents.forEach(intentService::submit);
+ uniIntents.forEach(intentService::submit);
+ expectedIntents.addAll(generateVplsBrc(fcPoints, VPLS2, NONE));
+ expectedIntents.addAll(generateVplsUni(fcPoints, hosts, VPLS2, NONE));
+
+ interfaces = ImmutableSet.of(VNONEH1, VNONEH2);
+ fcPoints = buildFCPoints(interfaces);
+ hosts = ImmutableSet.of(VNONEHOST1, VNONEHOST2);
+ vplsData = createVplsData(VPLS3, NONE, interfaces);
+ brcIntents = VplsIntentUtility.buildBrcIntents(vplsData, APPID);
+ uniIntents = VplsIntentUtility.buildUniIntents(vplsData, hosts, APPID);
+ brcIntents.forEach(intentService::submit);
+ uniIntents.forEach(intentService::submit);
+ expectedIntents.addAll(generateVplsBrc(fcPoints, VPLS3, NONE));
+ expectedIntents.addAll(generateVplsUni(fcPoints, hosts, VPLS3, NONE));
+
+ interfaces = ImmutableSet.of(V400H1, VNONEH3);
+ fcPoints = buildFCPoints(interfaces);
+ hosts = ImmutableSet.of(V400HOST1, VNONEHOST3);
+ vplsData = createVplsData(VPLS4, NONE, interfaces);
+ brcIntents = VplsIntentUtility.buildBrcIntents(vplsData, APPID);
+ uniIntents = VplsIntentUtility.buildUniIntents(vplsData, hosts, APPID);
+ brcIntents.forEach(intentService::submit);
+ uniIntents.forEach(intentService::submit);
+ expectedIntents.addAll(generateVplsBrc(fcPoints, VPLS4, NONE));
+ expectedIntents.addAll(generateVplsUni(fcPoints, hosts, VPLS4, NONE));
+
+ checkIntents(expectedIntents);
+ }
+
+ /**
+ * Generates a list of the expected sp2mp intents for a VPLS.
+ *
+ * @param fcPoints the filtered connect point
+ * @param name the name of the VPLS
+ * @param encap the encapsulation type
+ * @return the list of expected sp2mp intents for the given VPLS
+ */
+ private List<SinglePointToMultiPointIntent>
+ generateVplsBrc(Set<FilteredConnectPoint> fcPoints, String name, EncapsulationType encap) {
+ List<SinglePointToMultiPointIntent> intents = Lists.newArrayList();
+
+ fcPoints.forEach(point -> {
+ Set<FilteredConnectPoint> otherPoints =
+ fcPoints.stream()
+ .filter(fcp -> !fcp.equals(point))
+ .collect(Collectors.toSet());
+
+ Key brckey = buildKey(VplsIntentUtility.PREFIX_BROADCAST,
+ point.connectPoint(),
+ name,
+ MacAddress.BROADCAST);
+
+ intents.add(buildBrcIntent(brckey, point, otherPoints, encap));
+ });
+
+ return intents;
+ }
+
+ /**
+ * Generates a list of expected mp2sp intents for a given VPLS.
+ *
+ * @param fcPoints the filtered connect point
+ * @param hosts the hosts
+ * @param name the name of the VPLS
+ * @param encap the encapsulation type
+ * @return the list of expected mp2sp intents for the given VPLS
+ */
+ private List<MultiPointToSinglePointIntent>
+ generateVplsUni(Set<FilteredConnectPoint> fcPoints, Set<Host> hosts,
+ String name, EncapsulationType encap) {
+ List<MultiPointToSinglePointIntent> intents = Lists.newArrayList();
+
+ hosts.forEach(host -> {
+ FilteredConnectPoint hostPoint = getHostPoint(host, fcPoints);
+
+ Set<FilteredConnectPoint> otherPoints =
+ fcPoints.stream()
+ .filter(fcp -> !fcp.equals(hostPoint))
+ .collect(Collectors.toSet());
+
+ Key uniKey = buildKey(VplsIntentUtility.PREFIX_UNICAST,
+ host.location(), name, host.mac());
+
+ intents.add(buildUniIntent(uniKey, otherPoints, hostPoint, host, encap));
+ });
+
+ return intents;
+ }
+
+ /**
+ * Checks if the number of intents submitted to the intent framework is equal
+ * to the number of intents expected and if all intents are equivalent.
+ *
+ * @param intents the list of intents expected
+ */
+ private void checkIntents(List<Intent> intents) {
+ assertEquals("The number of intents submitted differs from the number" +
+ " of intents expected. ",
+ intents.size(), intentService.getIntentCount());
+ for (Intent intentOne : intents) {
+ boolean found = false;
+ for (Intent intentTwo : intentService.getIntents()) {
+ if (intentOne.key().equals(intentTwo.key())) {
+ found = true;
+ assertTrue(format("The intent submitted is different from" +
+ " the intent expected. %s %s",
+ intentOne, intentTwo),
+ IntentUtils.intentsAreEqual(intentOne, intentTwo));
+ break;
+ }
+ }
+ assertTrue("The intent submitted is not equal to any of the expected" +
+ " intents. ", found);
+ }
+ }
+
+ /**
+ * Builds a broadcast intent.
+ *
+ * @param key the key to identify the intent
+ * @param src the ingress connect point
+ * @param dsts the egress connect points
+ * @return the generated single-point to multi-point intent
+ */
+ private SinglePointToMultiPointIntent buildBrcIntent(Key key,
+ FilteredConnectPoint src,
+ Set<FilteredConnectPoint> dsts,
+ EncapsulationType encap) {
+ SinglePointToMultiPointIntent.Builder intentBuilder;
+ TrafficSelector selector = DefaultTrafficSelector.builder()
+ .matchEthDst(MacAddress.BROADCAST)
+ .build();
+ intentBuilder = SinglePointToMultiPointIntent.builder()
+ .appId(APPID)
+ .key(key)
+ .selector(selector)
+ .filteredIngressPoint(src)
+ .filteredEgressPoints(dsts)
+ .constraints(VplsIntentUtility.PARTIAL_FAILURE_CONSTRAINT)
+ .priority(PRIORITY_OFFSET);
+ VplsIntentUtility.setEncap(intentBuilder,
+ VplsIntentUtility.PARTIAL_FAILURE_CONSTRAINT,
+ encap);
+
+ return intentBuilder.build();
+ }
+
+ /**
+ * Builds a unicast intent.
+ *
+ * @param key the key to identify the intent
+ * @param srcs the ingress connect points
+ * @param dst the egress connect point
+ * @param host the destination Host
+ * @return the generated multi-point to single-point intent
+ */
+ private MultiPointToSinglePointIntent buildUniIntent(Key key,
+ Set<FilteredConnectPoint> srcs,
+ FilteredConnectPoint dst,
+ Host host,
+ EncapsulationType encap) {
+ MultiPointToSinglePointIntent.Builder intentBuilder;
+ TrafficSelector selector = DefaultTrafficSelector.builder()
+ .matchEthDst(host.mac())
+ .build();
+ intentBuilder = MultiPointToSinglePointIntent.builder()
+ .appId(APPID)
+ .key(key)
+ .selector(selector)
+ .filteredIngressPoints(srcs)
+ .filteredEgressPoint(dst)
+ .constraints(VplsIntentUtility.PARTIAL_FAILURE_CONSTRAINT)
+ .priority(PRIORITY_OFFSET);
+ VplsIntentUtility.setEncap(intentBuilder,
+ VplsIntentUtility.PARTIAL_FAILURE_CONSTRAINT,
+ encap);
+
+ return intentBuilder.build();
+ }
+
+ /**
+ * Returns the filtered connect point associated to a given host.
+ *
+ * @param host the target host
+ * @param fcps the filtered connected points
+ * @return the filtered connect point associated to the given host; null
+ * otherwise
+ */
+ private FilteredConnectPoint getHostPoint(Host host,
+ Set<FilteredConnectPoint> fcps) {
+ return fcps.stream()
+ .filter(fcp -> fcp.connectPoint().equals(host.location()))
+ .filter(fcp -> {
+ VlanIdCriterion vlanCriterion =
+ (VlanIdCriterion) fcp.trafficSelector().
+ getCriterion(Criterion.Type.VLAN_VID);
+ return vlanCriterion == null ||
+ vlanCriterion.vlanId().equals(host.vlan());
+ })
+ .findFirst()
+ .orElse(null);
+ }
+
+ /**
+ * Computes a set of filtered connect points from a list of given interfaces.
+ *
+ * @param interfaces the interfaces to compute
+ * @return the set of filtered connect points
+ */
+ private Set<FilteredConnectPoint> buildFCPoints(Collection<Interface> interfaces) {
+ // Build all filtered connected points in the VPLS
+ return interfaces
+ .stream()
+ .map(intf -> {
+ TrafficSelector.Builder selectorBuilder =
+ DefaultTrafficSelector.builder();
+ if (!intf.vlan().equals(VlanId.NONE)) {
+ selectorBuilder.matchVlanId(intf.vlan());
+ }
+ return new FilteredConnectPoint(intf.connectPoint(),
+ selectorBuilder.build());
+ })
+ .collect(Collectors.toSet());
+ }
+
+ /**
+ * Builds an intent Key either for a single-point to multi-point or
+ * multi-point to single-point intent, based on a prefix that defines
+ * the intent type, the connection point representing the source or the
+ * destination and the VLAN Id representing the VPLS.
+ *
+ * @param prefix the key prefix
+ * @param cPoint the ingress/egress connect point
+ * @param vplsName the VPLS name
+ * @param hostMac the ingress/egress MAC address
+ * @return the key to identify the intent
+ */
+ private Key buildKey(String prefix,
+ ConnectPoint cPoint,
+ String vplsName,
+ MacAddress hostMac) {
+ String keyString = vplsName +
+ DASH +
+ prefix +
+ DASH +
+ cPoint.deviceId() +
+ DASH +
+ cPoint.port() +
+ DASH +
+ hostMac;
+
+ return Key.of(keyString, APPID);
+ }
+
+ /**
+ * Creates VPLS data by given name, encapsulation type and network
+ * interfaces.
+ *
+ * @param name the VPLS name
+ * @param encap the encapsulation type
+ * @param interfaces the network interfaces
+ * @return the VPLS data
+ */
+ private VplsData createVplsData(String name, EncapsulationType encap,
+ Set<Interface> interfaces) {
+ VplsData vplsData = VplsData.of(name, encap);
+ vplsData.addInterfaces(interfaces);
+ return vplsData;
+ }
+
+ /**
+ * Represents a fake IntentService class that allows to store and retrieve
+ * intents without implementing the IntentService logic.
+ */
+ private class TestIntentService extends IntentServiceAdapter {
+ private Map<Key, Intent> intents;
+
+ public TestIntentService() {
+ intents = Maps.newHashMap();
+ }
+
+ @Override
+ public void submit(Intent intent) {
+ intents.put(intent.key(), intent);
+ }
+
+ @Override
+ public long getIntentCount() {
+ return intents.size();
+ }
+
+ @Override
+ public Iterable<Intent> getIntents() {
+ return intents.values();
+ }
+
+ @Override
+ public Intent getIntent(Key intentKey) {
+ for (Intent intent : intents.values()) {
+ if (intent.key().equals(intentKey)) {
+ return intent;
+ }
+ }
+ return null;
+ }
+ }
+
+}
diff --git a/apps/vpls/src/test/java/org/onosproject/vpls/VplsManagerTest.java b/apps/vpls/src/test/java/org/onosproject/vpls/VplsManagerTest.java
new file mode 100644
index 0000000..67128db
--- /dev/null
+++ b/apps/vpls/src/test/java/org/onosproject/vpls/VplsManagerTest.java
@@ -0,0 +1,339 @@
+/*
+ * Copyright 2017-present 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.vpls;
+
+import com.google.common.collect.ImmutableSet;
+import org.junit.After;
+import org.junit.Before;
+import org.junit.Test;
+import org.onosproject.net.EncapsulationType;
+import org.onosproject.net.host.HostEvent;
+import org.onosproject.vpls.api.VplsData;
+import org.onosproject.vpls.api.VplsOperation;
+import org.onosproject.vpls.api.VplsOperationService;
+import org.onosproject.vpls.store.VplsStoreEvent;
+
+import java.util.Collection;
+
+import static org.junit.Assert.*;
+import static org.onosproject.net.EncapsulationType.*;
+import static org.onosproject.vpls.api.VplsData.VplsState.*;
+
+/**
+ * Test for {@link VplsManager}
+ */
+public class VplsManagerTest extends VplsTest {
+ private VplsManager vplsManager;
+ private TestVplsStore vplsStore = new TestVplsStore();
+ private TestHostService hostService = new TestHostService();
+ private TestInterfaceService interfaceService = new TestInterfaceService();
+ private TestVplsOperationService vplsOperationService = new TestVplsOperationService();
+
+ @Before
+ public void setup() {
+ vplsManager = new VplsManager();
+ vplsManager.hostService = hostService;
+ vplsManager.vplsStore = vplsStore;
+ vplsManager.operationService = vplsOperationService;
+ vplsManager.interfaceService = interfaceService;
+ vplsStore.clear();
+ vplsOperationService.clear();
+ vplsManager.activate();
+ }
+
+ @After
+ public void tearDown() {
+ vplsManager.deactivate();
+ }
+
+ /**
+ * Creates VPLS by given name and encapsulation type.
+ */
+ @Test
+ public void testCreateVpls() {
+ VplsData vplsData = vplsManager.createVpls(VPLS1, NONE);
+ assertEquals(VPLS1, vplsData.name());
+ assertEquals(NONE, vplsData.encapsulationType());
+
+ vplsData = vplsStore.getVpls(VPLS1);
+ assertEquals(vplsData.state(), ADDING);
+ }
+
+ /**
+ * Gets VPLS by VPLS name.
+ */
+ @Test
+ public void testGetVpls() {
+ VplsData vplsData = VplsData.of(VPLS1);
+ vplsData.state(ADDED);
+ vplsStore.addVpls(vplsData);
+
+ VplsData result = vplsManager.getVpls(VPLS1);
+ assertEquals(vplsData, result);
+
+ result = vplsManager.getVpls(VPLS2);
+ assertNull(result);
+ }
+
+ /**
+ * Removes a VPLS.
+ */
+ @Test
+ public void testRemoveVpls() {
+ VplsData vplsData = vplsManager.createVpls(VPLS1, NONE);
+ vplsManager.removeVpls(vplsData);
+ assertEquals(vplsData.state(), REMOVING);
+ vplsData = vplsStore.getVpls(VPLS1);
+ assertNull(vplsData);
+ Collection<VplsData> allVpls = vplsStore.getAllVpls();
+ assertEquals(0, allVpls.size());
+ }
+
+ /**
+ * Removes all VPLS.
+ */
+ @Test
+ public void testRemoveAllVpls() {
+ VplsData vplsData = VplsData.of(VPLS1);
+ vplsData.state(ADDED);
+ vplsStore.addVpls(vplsData);
+
+ vplsData = VplsData.of(VPLS2, VLAN);
+ vplsData.state(ADDED);
+ vplsStore.addVpls(vplsData);
+
+ vplsManager.removeAllVpls();
+ assertEquals(0, vplsStore.getAllVpls().size());
+ }
+
+ /**
+ * Adds network interfaces one by one to a VPLS.
+ */
+ @Test
+ public void testAddInterface() {
+ VplsData vplsData = vplsManager.createVpls(VPLS1, NONE);
+ vplsManager.addInterface(vplsData, V100H1);
+ vplsManager.addInterface(vplsData, V100H2);
+ vplsData = vplsStore.getVpls(VPLS1);
+ assertNotNull(vplsData);
+ assertEquals(vplsData.state(), UPDATING);
+ assertEquals(2, vplsData.interfaces().size());
+ assertTrue(vplsData.interfaces().contains(V100H1));
+ assertTrue(vplsData.interfaces().contains(V100H2));
+ }
+
+ /**
+ * Adds network interfaces to a VPLS.
+ */
+ @Test
+ public void testAddInterfaces() {
+ VplsData vplsData = vplsManager.createVpls(VPLS1, NONE);
+ vplsManager.addInterfaces(vplsData, ImmutableSet.of(V100H1, V100H2));
+ vplsData = vplsStore.getVpls(VPLS1);
+ assertNotNull(vplsData);
+ assertEquals(vplsData.state(), UPDATING);
+ assertEquals(2, vplsData.interfaces().size());
+ assertTrue(vplsData.interfaces().contains(V100H1));
+ assertTrue(vplsData.interfaces().contains(V100H2));
+ }
+
+ /**
+ * Removes network interfaces one by one from a VPLS.
+ */
+ @Test
+ public void testRemoveInterface() {
+ VplsData vplsData = vplsManager.createVpls(VPLS1, NONE);
+ vplsManager.addInterface(vplsData, V100H1);
+ vplsManager.addInterface(vplsData, V100H2);
+ vplsManager.removeInterface(vplsData, V100H1);
+ vplsData = vplsStore.getVpls(VPLS1);
+ assertNotNull(vplsData);
+ assertEquals(vplsData.state(), UPDATING);
+ assertEquals(1, vplsData.interfaces().size());
+ assertTrue(vplsData.interfaces().contains(V100H2));
+ }
+
+ /**
+ * Removes network interfaces from a VPLS.
+ */
+ @Test
+ public void testRemoveInterfaces() {
+ VplsData vplsData = vplsManager.createVpls(VPLS1, NONE);
+ vplsManager.addInterface(vplsData, V100H1);
+ vplsManager.addInterface(vplsData, V100H2);
+ vplsManager.removeInterfaces(vplsData, ImmutableSet.of(V100H1, V100H2));
+ vplsData = vplsStore.getVpls(VPLS1);
+ assertNotNull(vplsData);
+ assertEquals(vplsData.state(), UPDATING);
+ assertEquals(0, vplsData.interfaces().size());
+ }
+
+ /**
+ * Sets encapsulation type for a VPLS.
+ */
+ @Test
+ public void testSetEncapsulationType() {
+ VplsData vplsData = vplsManager.createVpls(VPLS1, NONE);
+ vplsManager.setEncapsulationType(vplsData, EncapsulationType.VLAN);
+ vplsData = vplsStore.getVpls(VPLS1);
+ assertNotNull(vplsData);
+ assertEquals(vplsData.state(), UPDATING);
+ assertEquals(vplsData.encapsulationType(), EncapsulationType.VLAN);
+ }
+
+ /**
+ * Adds hosts to a VPLS.
+ */
+ @Test
+ public void testAddHost() {
+ VplsData vplsData = VplsData.of(VPLS1, NONE);
+ vplsData.addInterface(V100H1);
+ vplsData.state(ADDED);
+ vplsStore.addVpls(vplsData);
+
+ HostEvent hostEvent = new HostEvent(HostEvent.Type.HOST_ADDED, V100HOST1);
+ hostService.postHostEvent(hostEvent);
+
+ vplsData = vplsStore.getVpls(VPLS1);
+ assertNotNull(vplsData);
+
+ assertEquals(vplsData.state(), UPDATING);
+ }
+
+ /**
+ * Removes hosts from a VPLS.
+ */
+ @Test
+ public void testRemoveHost() {
+ VplsData vplsData = VplsData.of(VPLS1, NONE);
+ vplsData.addInterface(V100H1);
+ vplsData.state(ADDED);
+ vplsStore.addVpls(vplsData);
+
+ HostEvent hostEvent = new HostEvent(HostEvent.Type.HOST_REMOVED, V100HOST1);
+ hostService.postHostEvent(hostEvent);
+ vplsData = vplsStore.getVpls(VPLS1);
+ assertNotNull(vplsData);
+
+ assertEquals(vplsData.state(), UPDATING);
+ }
+
+ /**
+ * Pass different VPLS store event to store delegate.
+ * Include these cases:
+ * <ul>
+ * <li>VPLS added</li>
+ * <li>VPLS updated</li>
+ * <li>VPLS state updated</li>
+ * <li>VPLS removed</li>
+ * </ul>
+ */
+ @Test
+ public void testStoreDelegate() {
+ // Add
+ VplsData vplsData = vplsManager.createVpls(VPLS1, NONE);
+ VplsStoreEvent event = new VplsStoreEvent(VplsStoreEvent.Type.ADD, vplsData);
+ vplsStore.delegate().notify(event);
+
+ VplsOperation vplsOperation = vplsOperationService.operation();
+ assertEquals(vplsOperation.op(), VplsOperation.Operation.ADD);
+ assertEquals(vplsOperation.vpls(), vplsData);
+ vplsOperationService.clear();
+
+ // Update info
+ vplsData.encapsulationType(EncapsulationType.VLAN);
+ vplsData.state(UPDATING);
+ event = new VplsStoreEvent(VplsStoreEvent.Type.UPDATE, vplsData);
+ vplsStore.delegate().notify(event);
+ vplsOperation = vplsOperationService.operation();
+ assertEquals(vplsOperation.op(), VplsOperation.Operation.UPDATE);
+ assertEquals(vplsOperation.vpls(), vplsData);
+ vplsOperationService.clear();
+
+ // Update state (no operation)
+ vplsData.state(VplsData.VplsState.ADDED);
+ event = new VplsStoreEvent(VplsStoreEvent.Type.UPDATE, vplsData);
+ vplsStore.delegate().notify(event);
+ vplsOperation = vplsOperationService.operation();
+ assertNull(vplsOperation);
+ vplsOperationService.clear();
+
+ // Remove
+ event = new VplsStoreEvent(VplsStoreEvent.Type.REMOVE, vplsData);
+ vplsStore.delegate().notify(event);
+ vplsOperation = vplsOperationService.operation();
+ assertEquals(vplsOperation.op(), VplsOperation.Operation.REMOVE);
+ assertEquals(vplsOperation.vpls(), vplsData);
+ vplsOperationService.clear();
+ }
+
+ /**
+ * Trigger host event listener by HOST_ADDED event.
+ */
+ @Test
+ public void hostAddEventTest() {
+ VplsData vplsData = vplsManager.createVpls(VPLS1, NONE);
+ vplsManager.addInterface(vplsData, V100H1);
+ HostEvent hostEvent = new HostEvent(HostEvent.Type.HOST_ADDED, V100HOST1);
+ hostService.postHostEvent(hostEvent);
+
+ vplsData = vplsStore.getVpls(VPLS1);
+ assertEquals(UPDATING, vplsData.state());
+ }
+
+ /**
+ * Trigger host event listener by HOST_REMOVED event.
+ */
+ @Test
+ public void hostRemoveEventTest() {
+ VplsData vplsData = vplsManager.createVpls(VPLS1, NONE);
+ vplsManager.addInterface(vplsData, V100H1);
+ HostEvent hostEvent = new HostEvent(HostEvent.Type.HOST_REMOVED, V100HOST1);
+ hostService.postHostEvent(hostEvent);
+
+ vplsData = vplsStore.getVpls(VPLS1);
+ assertEquals(UPDATING, vplsData.state());
+ }
+
+ /**
+ * Test VPLS operation service.
+ * Stores last operation submitted by VPLS manager.
+ */
+ class TestVplsOperationService implements VplsOperationService {
+ VplsOperation operation;
+
+ @Override
+ public void submit(VplsOperation vplsOperation) {
+ this.operation = vplsOperation;
+ }
+
+ /**
+ * Clears the VPLS operation.
+ */
+ public void clear() {
+ operation = null;
+ }
+
+ /**
+ * Gets the latest VPLS operation.
+ * @return the latest VPLS operation.
+ */
+ public VplsOperation operation() {
+ return operation;
+ }
+ }
+
+}
diff --git a/apps/vpls/src/test/java/org/onosproject/vpls/VplsNeighbourHandlerTest.java b/apps/vpls/src/test/java/org/onosproject/vpls/VplsNeighbourHandlerTest.java
index 412e937..2acc871 100644
--- a/apps/vpls/src/test/java/org/onosproject/vpls/VplsNeighbourHandlerTest.java
+++ b/apps/vpls/src/test/java/org/onosproject/vpls/VplsNeighbourHandlerTest.java
@@ -17,8 +17,6 @@
import com.google.common.collect.HashMultimap;
import com.google.common.collect.ImmutableSet;
-import com.google.common.collect.ImmutableSetMultimap;
-import com.google.common.collect.Maps;
import com.google.common.collect.SetMultimap;
import com.google.common.collect.Sets;
import org.junit.After;
@@ -30,8 +28,6 @@
import org.onlab.packet.VlanId;
import org.onosproject.core.ApplicationId;
import org.onosproject.incubator.net.intf.Interface;
-import org.onosproject.incubator.net.intf.InterfaceListener;
-import org.onosproject.incubator.net.intf.InterfaceService;
import org.onosproject.incubator.net.neighbour.NeighbourHandlerRegistration;
import org.onosproject.incubator.net.neighbour.NeighbourMessageContext;
import org.onosproject.incubator.net.neighbour.NeighbourMessageHandler;
@@ -39,122 +35,26 @@
import org.onosproject.incubator.net.neighbour.NeighbourProtocol;
import org.onosproject.incubator.net.neighbour.NeighbourResolutionService;
import org.onosproject.net.ConnectPoint;
-import org.onosproject.net.DefaultHost;
-import org.onosproject.net.DeviceId;
-import org.onosproject.net.EncapsulationType;
import org.onosproject.net.Host;
-import org.onosproject.net.HostId;
-import org.onosproject.net.HostLocation;
-import org.onosproject.net.PortNumber;
import org.onosproject.net.host.HostService;
-import org.onosproject.net.host.HostServiceAdapter;
-import org.onosproject.net.provider.ProviderId;
+import org.onosproject.vpls.api.VplsData;
import java.util.Collection;
-import java.util.HashMap;
import java.util.Map;
import java.util.Set;
-import java.util.stream.Collectors;
import static junit.framework.TestCase.assertEquals;
+import static junit.framework.TestCase.assertTrue;
/**
- * Tests the the {@link VplsNeighbourHandler} class.
+ * Tests the the {@link VplsNeighbourHandler}.
*/
-public class VplsNeighbourHandlerTest {
+public class VplsNeighbourHandlerTest extends VplsTest {
private static final String IFACES_NOT_EXPECTED =
"The interfaces reached by the packet are not equal to the " +
"interfaces expected.";
-
- private static final DeviceId DID1 = getDeviceId(1);
- private static final DeviceId DID2 = getDeviceId(2);
- private static final DeviceId DID3 = getDeviceId(3);
- private static final DeviceId DID4 = getDeviceId(4);
- private static final DeviceId DID5 = getDeviceId(5);
-
- private static final PortNumber P1 = PortNumber.portNumber(1);
- private static final PortNumber P2 = PortNumber.portNumber(2);
- private static final PortNumber P3 = PortNumber.portNumber(3);
-
- private static final ConnectPoint OF1P1 = new ConnectPoint(DID1, P1);
- private static final ConnectPoint OF2P1 = new ConnectPoint(DID2, P1);
- private static final ConnectPoint OF3P1 = new ConnectPoint(DID3, P1);
- private static final ConnectPoint OF4P1 = new ConnectPoint(DID4, P1);
- private static final ConnectPoint OF4P2 = new ConnectPoint(DID4, P2);
- private static final ConnectPoint OF4P3 = new ConnectPoint(DID4, P3);
- private static final ConnectPoint OF5P1 = new ConnectPoint(DID5, P1);
- private static final ConnectPoint OF5P2 = new ConnectPoint(DID5, P2);
- private static final ConnectPoint OF5P3 = new ConnectPoint(DID5, P3);
-
- private static final String VPLS1 = "vpls1";
- private static final String VPLS2 = "vpls2";
- private static final String VPLS3 = "vpls3";
- private static final String VPLS4 = "vpls4";
-
- private static final VlanId VLAN100 = VlanId.vlanId("100");
- private static final VlanId VLAN200 = VlanId.vlanId("200");
- private static final VlanId VLAN300 = VlanId.vlanId("300");
- private static final VlanId VLAN400 = VlanId.vlanId("400");
- private static final VlanId VLAN_NONE = VlanId.NONE;
-
- private static final Interface V100H1 =
- new Interface("v100h1", OF1P1, null, null, VLAN100);
- private static final Interface V100H2 =
- new Interface("v100h2", OF4P1, null, null, VLAN100);
- private static final Interface V200H1 =
- new Interface("v200h1", OF4P2, null, null, VLAN200);
- private static final Interface V200H2 =
- new Interface("v200h2", OF2P1, null, null, VLAN200);
- private static final Interface V300H1 =
- new Interface("v300h1", OF3P1, null, null, VLAN300);
- private static final Interface V400H1 =
- new Interface("v400h1", OF5P1, null, null, VLAN400);
- private static final Interface VNONEH1 =
- new Interface("vNoneh1", OF5P2, null, null, VLAN_NONE);
- private static final Interface VNONEH2 =
- new Interface("vNoneh2", OF5P3, null, null, VLAN_NONE);
- private static final Interface VNONEH3 =
- new Interface("vNoneh3", OF4P3, null, null, VLAN_NONE);
-
- private static final MacAddress MAC1 = MacAddress.valueOf("00:00:00:00:00:01");
- private static final MacAddress MAC2 = MacAddress.valueOf("00:00:00:00:00:02");
- private static final MacAddress MAC3 = MacAddress.valueOf("00:00:00:00:00:03");
- private static final MacAddress MAC4 = MacAddress.valueOf("00:00:00:00:00:04");
- private static final MacAddress MAC5 = MacAddress.valueOf("00:00:00:00:00:05");
- private static final MacAddress MAC6 = MacAddress.valueOf("00:00:00:00:00:06");
- private static final MacAddress MAC7 = MacAddress.valueOf("00:00:00:00:00:07");
- private static final MacAddress MAC8 = MacAddress.valueOf("00:00:00:00:00:08");
- private static final MacAddress MAC9 = MacAddress.valueOf("00:00:00:00:00:09");
-
- private static final ProviderId PID = new ProviderId("of", "foo");
-
- private final Host v100Host1 = makeHost(MAC1, VLAN100, OF1P1);
- private final Host v100Host2 = makeHost(MAC2, VLAN100, OF4P1);
- private final Host v200Host1 = makeHost(MAC3, VLAN200, OF4P2);
- private final Host v200Host2 = makeHost(MAC5, VLAN200, OF2P1);
- private final Host v300Host1 = makeHost(MAC4, VLAN300, OF3P1);
- private final Host v400Host1 = makeHost(MAC6, VLAN400, OF5P1);
- private final Host vNoneHost1 = makeHost(MAC7, VLAN_NONE, OF5P2);
- private final Host vNoneHost2 = makeHost(MAC8, VLAN_NONE, OF5P3);
- private final Host vNoneHost3 = makeHost(MAC9, VLAN_NONE, OF4P3);
-
- private final Set<Host> availableHosts = ImmutableSet.of(v100Host1,
- v100Host2,
- v200Host1,
- v300Host1,
- v200Host2,
- v400Host1,
- vNoneHost1,
- vNoneHost2,
- vNoneHost3);
-
- private final Set<Interface> availableInterfaces =
- ImmutableSet.of(V100H1, V100H2, V200H1, V200H2, V300H1,
- V400H1, VNONEH1, VNONEH2, VNONEH3);
-
private VplsNeighbourHandler vplsNeighbourHandler;
-
private HostService hostService;
/**
@@ -167,29 +67,46 @@
@Before
public void setUp() {
vplsNeighbourHandler = new VplsNeighbourHandler();
- SetMultimap<String, Interface> ifacesByVpls =
- HashMultimap.create();
- ifacesByVpls.put(VPLS1, V100H1);
- ifacesByVpls.put(VPLS1, V200H1);
- ifacesByVpls.put(VPLS1, V300H1);
- ifacesByVpls.put(VPLS2, V100H2);
- ifacesByVpls.put(VPLS2, V200H2);
- ifacesByVpls.put(VPLS3, VNONEH1);
- ifacesByVpls.put(VPLS3, VNONEH2);
- ifacesByVpls.put(VPLS4, V400H1);
- ifacesByVpls.put(VPLS4, VNONEH3);
- HashMap<String, EncapsulationType> encap = Maps.newHashMap();
- vplsNeighbourHandler.vplsConfigService =
- new TestVplsConfigService(ifacesByVpls, encap);
- vplsNeighbourHandler.interfaceService =
- new TestInterfaceService();
- vplsNeighbourHandler.neighbourService =
- new TestNeighbourService();
hostService = new TestHostService();
+ vplsNeighbourHandler.vplsStore = new TestVplsStore();
+ vplsNeighbourHandler.interfaceService = new TestInterfaceService();
+ vplsNeighbourHandler.neighbourService = new TestNeighbourService();
+ vplsNeighbourHandler.coreService = new TestCoreService();
+ vplsNeighbourHandler.configService = new TestConfigService();
+
+ // Init VPLS store
+ VplsData vplsData = VplsData.of(VPLS1);
+ vplsData.addInterfaces(ImmutableSet.of(V100H1, V200H1, V300H1));
+ vplsNeighbourHandler.vplsStore.addVpls(vplsData);
+
+ vplsData = VplsData.of(VPLS2);
+ vplsData.addInterfaces(ImmutableSet.of(V100H2, V200H2));
+ vplsNeighbourHandler.vplsStore.addVpls(vplsData);
+
+ vplsData = VplsData.of(VPLS3);
+ vplsData.addInterfaces(ImmutableSet.of(VNONEH1, VNONEH2));
+ vplsNeighbourHandler.vplsStore.addVpls(vplsData);
+
+ vplsData = VplsData.of(VPLS4);
+ vplsData.addInterfaces(ImmutableSet.of(V400H1, VNONEH3));
+ vplsNeighbourHandler.vplsStore.addVpls(vplsData);
+
+ vplsNeighbourHandler.activate();
+
}
@After
public void tearDown() {
+ vplsNeighbourHandler.deactivate();
+ }
+
+ /**
+ * Registers neighbour handler to all available interfaces.
+ */
+ @Test
+ public void testConfigNeighbourHandler() {
+ vplsNeighbourHandler.configNeighbourHandler();
+ assertEquals(9, vplsNeighbourHandler.neighbourService.getHandlerRegistrations().size());
}
/**
@@ -200,21 +117,21 @@
public void vpls1RequestMessage() {
// Request messages from v100h1 (VPLS 1) should be received by v200h1 and v300h1
TestMessageContext requestMessage =
- makeBroadcastRequestContext(v100Host1);
+ makeBroadcastRequestContext(V100HOST1);
Set<Interface> expectInterfaces = ImmutableSet.of(V200H1, V300H1);
- vplsNeighbourHandler.handleRequest(requestMessage);
+ ((TestNeighbourService) vplsNeighbourHandler.neighbourService).sendNeighourMessage(requestMessage);
assertEquals(IFACES_NOT_EXPECTED, expectInterfaces, requestMessage.forwardResults);
// Request messages from v200h1 (VPLS 1) should be received by v100h1 and v300h1
- requestMessage = makeBroadcastRequestContext(v200Host1);
+ requestMessage = makeBroadcastRequestContext(V200HOST1);
expectInterfaces = ImmutableSet.of(V100H1, V300H1);
- vplsNeighbourHandler.handleRequest(requestMessage);
+ ((TestNeighbourService) vplsNeighbourHandler.neighbourService).sendNeighourMessage(requestMessage);
assertEquals(IFACES_NOT_EXPECTED, expectInterfaces, requestMessage.forwardResults);
// Request from v300h1 (VPLS 1) should be received by v100h1 and v200h1
- requestMessage = makeBroadcastRequestContext(v300Host1);
+ requestMessage = makeBroadcastRequestContext(V300HOST1);
expectInterfaces = ImmutableSet.of(V100H1, V200H1);
- vplsNeighbourHandler.handleRequest(requestMessage);
+ ((TestNeighbourService) vplsNeighbourHandler.neighbourService).sendNeighourMessage(requestMessage);
assertEquals(IFACES_NOT_EXPECTED, expectInterfaces, requestMessage.forwardResults);
}
@@ -226,15 +143,15 @@
public void vpls2RequestMessage() {
// Request messages from v100h2 (VPLS 2) should be received by v200h2
TestMessageContext requestMessage =
- makeBroadcastRequestContext(v100Host2);
+ makeBroadcastRequestContext(V100HOST2);
Set<Interface> expectInterfaces = ImmutableSet.of(V200H2);
- vplsNeighbourHandler.handleRequest(requestMessage);
+ ((TestNeighbourService) vplsNeighbourHandler.neighbourService).sendNeighourMessage(requestMessage);
assertEquals(IFACES_NOT_EXPECTED, expectInterfaces, requestMessage.forwardResults);
// Request messages from v200h2 (VPLS 2) should be received by v100h2
- requestMessage = makeBroadcastRequestContext(v200Host2);
+ requestMessage = makeBroadcastRequestContext(V200HOST2);
expectInterfaces = ImmutableSet.of(V100H2);
- vplsNeighbourHandler.handleRequest(requestMessage);
+ ((TestNeighbourService) vplsNeighbourHandler.neighbourService).sendNeighourMessage(requestMessage);
assertEquals(IFACES_NOT_EXPECTED, expectInterfaces, requestMessage.forwardResults);
}
@@ -246,17 +163,17 @@
*/
@Test
public void vpls3RequestMessage() {
- // Request messages from vNoneHost1 (VPLS 3) should be received by vNoneHost2
+ // Request messages from VNONEHOST1 (VPLS 3) should be received by VNONEHOST2
TestMessageContext requestMessage =
- makeBroadcastRequestContext(vNoneHost1);
+ makeBroadcastRequestContext(VNONEHOST1);
Set<Interface> expectInterfaces = ImmutableSet.of(VNONEH2);
- vplsNeighbourHandler.handleRequest(requestMessage);
+ ((TestNeighbourService) vplsNeighbourHandler.neighbourService).sendNeighourMessage(requestMessage);
assertEquals(IFACES_NOT_EXPECTED, expectInterfaces, requestMessage.forwardResults);
// Request messages from vNoneh2 (VPLS 3) should be received by vNoneh1
- requestMessage = makeBroadcastRequestContext(vNoneHost2);
+ requestMessage = makeBroadcastRequestContext(VNONEHOST2);
expectInterfaces = ImmutableSet.of(VNONEH1);
- vplsNeighbourHandler.handleRequest(requestMessage);
+ ((TestNeighbourService) vplsNeighbourHandler.neighbourService).sendNeighourMessage(requestMessage);
assertEquals(IFACES_NOT_EXPECTED, expectInterfaces, requestMessage.forwardResults);
}
@@ -268,17 +185,17 @@
*/
@Test
public void vpls4RequestMessage() {
- // Request messages from v400Host1 (VPLS 4) should be received by vNoneHost3
+ // Request messages from V400HOST1 (VPLS 4) should be received by VNONEHOST3
TestMessageContext requestMessage =
- makeBroadcastRequestContext(v400Host1);
+ makeBroadcastRequestContext(V400HOST1);
Set<Interface> expectInterfaces = ImmutableSet.of(VNONEH3);
- vplsNeighbourHandler.handleRequest(requestMessage);
+ ((TestNeighbourService) vplsNeighbourHandler.neighbourService).sendNeighourMessage(requestMessage);
assertEquals(IFACES_NOT_EXPECTED, expectInterfaces, requestMessage.forwardResults);
- // Request messages from vNoneHost3 (VPLS 4) should be received by v400Host1
- requestMessage = makeBroadcastRequestContext(vNoneHost3);
+ // Request messages from VNONEHOST3 (VPLS 4) should be received by V400HOST1
+ requestMessage = makeBroadcastRequestContext(VNONEHOST3);
expectInterfaces = ImmutableSet.of(V400H1);
- vplsNeighbourHandler.handleRequest(requestMessage);
+ ((TestNeighbourService) vplsNeighbourHandler.neighbourService).sendNeighourMessage(requestMessage);
assertEquals(IFACES_NOT_EXPECTED, expectInterfaces, requestMessage.forwardResults);
}
@@ -291,21 +208,21 @@
public void vpls1ReplyMessage() {
// Reply messages from v100h1 (VPLS 1) should be received by v200h1
TestMessageContext replyMessage =
- makeReplyContext(v100Host1, v200Host1);
+ makeReplyContext(V100HOST1, V200HOST1);
Set<Interface> expectInterfaces = ImmutableSet.of(V200H1);
- vplsNeighbourHandler.handleReply(replyMessage, hostService);
+ ((TestNeighbourService) vplsNeighbourHandler.neighbourService).sendNeighourMessage(replyMessage);
assertEquals(IFACES_NOT_EXPECTED, expectInterfaces, replyMessage.forwardResults);
// Reply messages from v200h1 (VPLS 1) should be received by v300h1
- replyMessage = makeReplyContext(v200Host1, v300Host1);
+ replyMessage = makeReplyContext(V200HOST1, V300HOST1);
expectInterfaces = ImmutableSet.of(V300H1);
- vplsNeighbourHandler.handleReply(replyMessage, hostService);
+ ((TestNeighbourService) vplsNeighbourHandler.neighbourService).sendNeighourMessage(replyMessage);
assertEquals(IFACES_NOT_EXPECTED, expectInterfaces, replyMessage.forwardResults);
// Reply messages from v300h1 (VPLS 1) should be received by v100h1
- replyMessage = makeReplyContext(v300Host1, v100Host1);
+ replyMessage = makeReplyContext(V300HOST1, V100HOST1);
expectInterfaces = ImmutableSet.of(V100H1);
- vplsNeighbourHandler.handleReply(replyMessage, hostService);
+ ((TestNeighbourService) vplsNeighbourHandler.neighbourService).sendNeighourMessage(replyMessage);
assertEquals(IFACES_NOT_EXPECTED, expectInterfaces, replyMessage.forwardResults);
}
@@ -318,15 +235,15 @@
public void vpls2ReplyMessage() {
// Reply messages from v100h2 (VPLS 2) should be received by v200h2
TestMessageContext replyMessage =
- makeReplyContext(v100Host2, v200Host2);
+ makeReplyContext(V100HOST2, V200HOST2);
Set<Interface> expectInterfaces = ImmutableSet.of(V200H2);
- vplsNeighbourHandler.handleReply(replyMessage, hostService);
+ ((TestNeighbourService) vplsNeighbourHandler.neighbourService).sendNeighourMessage(replyMessage);
assertEquals(IFACES_NOT_EXPECTED, expectInterfaces, replyMessage.forwardResults);
// Reply messages from v200h2 (VPLS 2) should be received by v100h2
- replyMessage = makeReplyContext(v200Host2, v100Host2);
+ replyMessage = makeReplyContext(V200HOST2, V100HOST2);
expectInterfaces = ImmutableSet.of(V100H2);
- vplsNeighbourHandler.handleReply(replyMessage, hostService);
+ ((TestNeighbourService) vplsNeighbourHandler.neighbourService).sendNeighourMessage(replyMessage);
assertEquals(IFACES_NOT_EXPECTED, expectInterfaces, replyMessage.forwardResults);
}
@@ -339,15 +256,15 @@
public void vpls3ReplyMessage() {
// Reply messages from vNoneh1 (VPLS 3) should be received by vNoneh2
TestMessageContext replyMessage =
- makeReplyContext(vNoneHost1, vNoneHost2);
+ makeReplyContext(VNONEHOST1, VNONEHOST2);
Set<Interface> expectInterfaces = ImmutableSet.of(VNONEH2);
- vplsNeighbourHandler.handleReply(replyMessage, hostService);
+ ((TestNeighbourService) vplsNeighbourHandler.neighbourService).sendNeighourMessage(replyMessage);
assertEquals(IFACES_NOT_EXPECTED, expectInterfaces, replyMessage.forwardResults);
// Reply messages from vNoneh2 (VPLS 3) should be received by vNoneh1
- replyMessage = makeReplyContext(vNoneHost2, vNoneHost1);
+ replyMessage = makeReplyContext(VNONEHOST2, VNONEHOST1);
expectInterfaces = ImmutableSet.of(VNONEH1);
- vplsNeighbourHandler.handleReply(replyMessage, hostService);
+ ((TestNeighbourService) vplsNeighbourHandler.neighbourService).sendNeighourMessage(replyMessage);
assertEquals(IFACES_NOT_EXPECTED, expectInterfaces, replyMessage.forwardResults);
}
@@ -360,15 +277,15 @@
public void vpls4ReplyMessage() {
// Reply messages from v400h1 (VPLS 4) should be received by vNoneh3
TestMessageContext replyMessage =
- makeReplyContext(v400Host1, vNoneHost3);
+ makeReplyContext(V400HOST1, VNONEHOST3);
Set<Interface> expectInterfaces = ImmutableSet.of(VNONEH3);
- vplsNeighbourHandler.handleReply(replyMessage, hostService);
+ ((TestNeighbourService) vplsNeighbourHandler.neighbourService).sendNeighourMessage(replyMessage);
assertEquals(IFACES_NOT_EXPECTED, expectInterfaces, replyMessage.forwardResults);
// Reply messages from vNoneh3 (VPLS 4) should be received by v400h1
- replyMessage = makeReplyContext(vNoneHost3, v400Host1);
+ replyMessage = makeReplyContext(VNONEHOST3, V400HOST1);
expectInterfaces = ImmutableSet.of(V400H1);
- vplsNeighbourHandler.handleReply(replyMessage, hostService);
+ ((TestNeighbourService) vplsNeighbourHandler.neighbourService).sendNeighourMessage(replyMessage);
assertEquals(IFACES_NOT_EXPECTED, expectInterfaces, replyMessage.forwardResults);
}
@@ -381,52 +298,56 @@
public void wrongReplyMessage() {
// Reply message from v100h1 (VPLS 1) to v100h2 (VPLS 2).
// Forward results should be empty
- TestMessageContext replyMessage = makeReplyContext(v100Host1, v100Host2);
+ TestMessageContext replyMessage = makeReplyContext(V100HOST1, V100HOST2);
Set<Interface> expectInterfaces = ImmutableSet.of();
- vplsNeighbourHandler.handleReply(replyMessage, hostService);
+ ((TestNeighbourService) vplsNeighbourHandler.neighbourService).sendNeighourMessage(replyMessage);
assertEquals(IFACES_NOT_EXPECTED, expectInterfaces, replyMessage.forwardResults);
// Reply message from v200h2 (VPLS 2) to v300h1 (VPLS 1).
// Forward results should be empty
- replyMessage = makeReplyContext(v200Host2, v300Host1);
+ replyMessage = makeReplyContext(V200HOST2, V300HOST1);
expectInterfaces = ImmutableSet.of();
- vplsNeighbourHandler.handleReply(replyMessage, hostService);
+ ((TestNeighbourService) vplsNeighbourHandler.neighbourService).sendNeighourMessage(replyMessage);
assertEquals(IFACES_NOT_EXPECTED, expectInterfaces, replyMessage.forwardResults);
// Reply message from vNoneh1 (VPLS 3) to v400h1 (VPLS 4).
// Forward results should be empty
- replyMessage = makeReplyContext(vNoneHost1, v400Host1);
+ replyMessage = makeReplyContext(VNONEHOST1, V400HOST1);
expectInterfaces = ImmutableSet.of();
- vplsNeighbourHandler.handleReply(replyMessage, hostService);
+ ((TestNeighbourService) vplsNeighbourHandler.neighbourService).sendNeighourMessage(replyMessage);
assertEquals(IFACES_NOT_EXPECTED, expectInterfaces, replyMessage.forwardResults);
// Reply message from vNoneh3 (VPLS 4) to vNoneH2 (VPLS 3).
// Forward results should be empty
- replyMessage = makeReplyContext(vNoneHost3, vNoneHost2);
+ replyMessage = makeReplyContext(VNONEHOST3, VNONEHOST2);
expectInterfaces = ImmutableSet.of();
- vplsNeighbourHandler.handleReply(replyMessage, hostService);
+ ((TestNeighbourService) vplsNeighbourHandler.neighbourService).sendNeighourMessage(replyMessage);
assertEquals(IFACES_NOT_EXPECTED, expectInterfaces, replyMessage.forwardResults);
}
/**
- * Returns the device Id of the ith device.
- *
- * @param i the device to get the Id of
- * @return the device Id
+ * Sends reply and request message from a host which not related to any VPLS.
*/
- private static DeviceId getDeviceId(int i) {
- return DeviceId.deviceId("" + i);
+ @Test
+ public void testVplsNotfound() {
+ TestMessageContext replyMessage = makeReplyContext(V300HOST2, V100HOST1);
+ Set<Interface> expectInterfaces = ImmutableSet.of();
+ ((TestNeighbourService) vplsNeighbourHandler.neighbourService).sendNeighourMessage(replyMessage);
+ assertEquals(IFACES_NOT_EXPECTED, expectInterfaces, replyMessage.forwardResults);
+ assertTrue(replyMessage.dropped());
+
+ TestMessageContext requestMessage = makeBroadcastRequestContext(V300HOST2);
+ ((TestNeighbourService) vplsNeighbourHandler.neighbourService).sendNeighourMessage(requestMessage);
+ assertEquals(IFACES_NOT_EXPECTED, expectInterfaces, requestMessage.forwardResults);
+ assertTrue(requestMessage.dropped());
}
- private Host makeHost(MacAddress mac, VlanId vlan, ConnectPoint cp) {
- return new DefaultHost(PID,
- HostId.hostId(mac, vlan),
- mac,
- vlan,
- new HostLocation(cp, 0),
- Sets.newHashSet());
- }
-
+ /**
+ * Generates broadcast request message context by given source host.
+ *
+ * @param host the source host
+ * @return the request message context
+ */
private TestMessageContext makeBroadcastRequestContext(Host host) {
return new TestMessageContext(host.location(),
host.mac(),
@@ -435,6 +356,13 @@
NeighbourMessageType.REQUEST);
}
+ /**
+ * Generates reply message context by given source and destination host.
+ *
+ * @param src the source host
+ * @param dst the destination host
+ * @return the reply message context
+ */
private TestMessageContext makeReplyContext(Host src, Host dst) {
return new TestMessageContext(src.location(),
src.mac(),
@@ -443,15 +371,16 @@
NeighbourMessageType.REPLY);
}
+ /**
+ * Test message context.
+ */
private class TestMessageContext implements NeighbourMessageContext {
-
-
private final NeighbourMessageType type;
private final MacAddress srcMac;
private final MacAddress dstMac;
private final ConnectPoint inPort;
private final VlanId vlanId;
-
+ private boolean dropped = false;
public Set<Interface> forwardResults;
/**
@@ -475,8 +404,8 @@
this.dstMac = dstMac;
this.vlanId = vlanId;
this.type = type;
-
this.forwardResults = Sets.newHashSet();
+ this.dropped = false;
}
@Override
@@ -518,6 +447,10 @@
public void forward(ConnectPoint outPort) {
}
+ /**
+ * Records all forward network interface information.
+ * @param outIntf output interface
+ */
@Override
public void forward(Interface outIntf) {
forwardResults.add(outIntf);
@@ -533,6 +466,7 @@
@Override
public void drop() {
+ this.dropped = true;
}
@Override
@@ -544,141 +478,16 @@
public NeighbourProtocol protocol() {
return null;
}
- }
- private class TestVplsConfigService extends VplsConfigServiceAdapter {
-
- private final SetMultimap<String, Interface> ifacesByVplsName;
-
- public TestVplsConfigService(SetMultimap<String, Interface> ifacesByVplsName,
- HashMap<String, EncapsulationType> encapByVplsName) {
- this.ifacesByVplsName = ifacesByVplsName;
- }
-
- @Override
- public void addVpls(String vplsName, Set<String> ifaceNames, String encap) {
- if (!ifacesByVplsName.containsKey(vplsName)) {
- ifaceNames.forEach(ifaceName -> {
- availableInterfaces.forEach(iface -> {
- if (iface.name().equals(ifaceName)) {
- ifacesByVplsName.put(vplsName, iface);
- }
- });
- });
- }
- }
-
- @Override
- public void removeVpls(String vplsName) {
- if (ifacesByVplsName.containsKey(vplsName)) {
- ifacesByVplsName.removeAll(vplsName);
- }
- }
-
- @Override
- public void addIface(String vplsName, String ifaceName) {
- availableInterfaces.forEach(intf -> {
- if (intf.name().equals(ifaceName)) {
- ifacesByVplsName.put(vplsName, intf);
- }
- });
- }
-
- @Override
- public void removeIface(String ifaceName) {
- SetMultimap<String, Interface> toBeRemoved = HashMultimap.create();
- ifacesByVplsName.entries().forEach(e -> {
- if (e.getValue().name().equals(ifaceName)) {
- toBeRemoved.put(e.getKey(), e.getValue());
- }
- });
- toBeRemoved.entries()
- .forEach(e -> ifacesByVplsName.remove(e.getKey(),
- e.getValue()));
- }
-
- @Override
- public void cleanVplsConfig() {
- ifacesByVplsName.clear();
- }
-
- @Override
- public Set<Interface> allIfaces() {
- return ImmutableSet.copyOf(ifacesByVplsName.values());
- }
-
- @Override
- public Set<Interface> ifaces(String name) {
- return ifacesByVplsName.get(name)
- .stream()
- .collect(Collectors.toSet());
- }
-
- @Override
- public Set<String> vplsNames() {
- return ifacesByVplsName.keySet();
- }
-
- @Override
- public SetMultimap<String, Interface> ifacesByVplsName() {
- return ImmutableSetMultimap.copyOf(ifacesByVplsName);
- }
-
- @Override
- public SetMultimap<String, Interface> ifacesByVplsName(VlanId vlan,
- ConnectPoint connectPoint) {
- String vplsName =
- ifacesByVplsName.entries().stream()
- .filter(e -> e.getValue().connectPoint().equals(connectPoint))
- .filter(e -> e.getValue().vlan().equals(vlan))
- .map(Map.Entry::getKey)
- .findFirst()
- .orElse(null);
- SetMultimap<String, Interface> result = HashMultimap.create();
- if (vplsName != null &&
- ifacesByVplsName.containsKey(vplsName)) {
- ifacesByVplsName.get(vplsName)
- .forEach(intf -> result.put(vplsName, intf));
- return result;
- }
- return null;
+ public boolean dropped() {
+ return dropped;
}
}
- class TestHostService extends HostServiceAdapter {
- @Override
- public Set<Host> getHostsByMac(MacAddress mac) {
- return availableHosts.stream()
- .filter(host -> host.mac().equals(mac))
- .collect(Collectors.toSet());
- }
-
- @Override
- public Iterable<Host> getHosts() {
- return availableHosts;
- }
-
- @Override
- public Set<Host> getHostsByVlan(VlanId vlanId) {
- return availableHosts.stream()
- .filter(host -> host.vlan().equals(vlanId))
- .collect(Collectors.toSet());
- }
-
- @Override
- public int getHostCount() {
- return availableHosts.size();
- }
-
- @Override
- public Host getHost(HostId hostId) {
- return availableHosts.stream()
- .filter(host -> host.id().equals(hostId))
- .findFirst()
- .orElse(null);
- }
- }
-
+ /**
+ * Test neighbour service; records all registrations between neighbour
+ * message handler and interfaces.
+ */
private class TestNeighbourService implements NeighbourResolutionService {
private SetMultimap<ConnectPoint, NeighbourHandlerRegistration> handlerRegs;
@@ -732,6 +541,26 @@
return handlerRegs.asMap();
}
+ /**
+ * Sends neighbour message context to all handler which related to the
+ * context.
+ *
+ * @param context the neighbour message context
+ */
+ public void sendNeighourMessage(NeighbourMessageContext context) {
+ ConnectPoint connectPoint = context.inPort();
+ VlanId vlanId = context.vlan();
+ Collection<NeighbourHandlerRegistration> registrations = handlerRegs.get(connectPoint);
+ registrations.forEach(reg -> {
+ if (reg.intf().vlan().equals(vlanId)) {
+ reg.handler().handleMessage(context, hostService);
+ }
+ });
+ }
+
+ /**
+ * Test handler registration.
+ */
private class HandlerRegistration implements NeighbourHandlerRegistration {
private final Interface intf;
private final NeighbourMessageHandler handler;
@@ -767,65 +596,4 @@
}
}
}
-
- class TestInterfaceService implements InterfaceService {
-
- @Override
- public void addListener(InterfaceListener listener) {
- }
-
- @Override
- public void removeListener(InterfaceListener listener) {
- }
-
- @Override
- public Set<Interface> getInterfaces() {
- return availableInterfaces;
- }
-
- @Override
- public Interface getInterfaceByName(ConnectPoint connectPoint,
- String name) {
- return availableInterfaces.stream()
- .filter(intf -> intf.name().equals(name))
- .findFirst()
- .orElse(null);
- }
-
- @Override
- public Set<Interface> getInterfacesByPort(ConnectPoint port) {
- return availableInterfaces.stream()
- .filter(intf -> intf.connectPoint().equals(port))
- .collect(Collectors.toSet());
- }
-
- @Override
- public Set<Interface> getInterfacesByIp(IpAddress ip) {
- return availableInterfaces.stream()
- .filter(intf -> intf.ipAddressesList().contains(ip))
- .collect(Collectors.toSet());
- }
-
- @Override
- public Set<Interface> getInterfacesByVlan(VlanId vlan) {
- return availableInterfaces.stream()
- .filter(intf -> intf.vlan().equals(vlan))
- .collect(Collectors.toSet());
- }
-
- @Override
- public Interface getMatchingInterface(IpAddress ip) {
- return availableInterfaces.stream()
- .filter(intf -> intf.ipAddressesList().contains(ip))
- .findFirst()
- .orElse(null);
- }
-
- @Override
- public Set<Interface> getMatchingInterfaces(IpAddress ip) {
- return availableInterfaces.stream()
- .filter(intf -> intf.ipAddressesList().contains(ip))
- .collect(Collectors.toSet());
- }
- }
}
diff --git a/apps/vpls/src/test/java/org/onosproject/vpls/VplsOperationManagerTest.java b/apps/vpls/src/test/java/org/onosproject/vpls/VplsOperationManagerTest.java
new file mode 100644
index 0000000..36ffda9
--- /dev/null
+++ b/apps/vpls/src/test/java/org/onosproject/vpls/VplsOperationManagerTest.java
@@ -0,0 +1,543 @@
+/*
+ * Copyright 2017-present 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.vpls;
+
+import com.google.common.collect.ImmutableList;
+import com.google.common.collect.ImmutableSet;
+import com.google.common.collect.Sets;
+import org.junit.After;
+import org.junit.Before;
+import org.junit.Test;
+import org.onosproject.cluster.ClusterServiceAdapter;
+import org.onosproject.cluster.Leader;
+import org.onosproject.cluster.Leadership;
+import org.onosproject.cluster.LeadershipEvent;
+import org.onosproject.net.ConnectPoint;
+import org.onosproject.net.EncapsulationType;
+import org.onosproject.net.Host;
+import org.onosproject.net.host.HostServiceAdapter;
+import org.onosproject.net.intent.Intent;
+import org.onosproject.net.intent.IntentData;
+import org.onosproject.net.intent.IntentEvent;
+import org.onosproject.net.intent.IntentState;
+import org.onosproject.store.service.WallClockTimestamp;
+import org.onosproject.vpls.api.VplsData;
+import org.onosproject.vpls.api.VplsOperation;
+
+import java.util.ArrayDeque;
+import java.util.Collection;
+import java.util.Deque;
+import java.util.Set;
+
+import static org.junit.Assert.*;
+import static org.onlab.junit.TestTools.assertAfter;
+import static org.onlab.junit.TestTools.delay;
+
+/**
+ * Tests for {@link VplsOperationManager}.
+ */
+public class VplsOperationManagerTest extends VplsTest {
+
+ VplsOperationManager vplsOperationManager;
+ private static final int OPERATION_DELAY = 1000;
+ private static final int OPERATION_DURATION = 1500;
+
+ @Before
+ public void setup() {
+ if (idGenerator == null) {
+ idGenerator = new TestIdGenerator();
+ }
+ Intent.unbindIdGenerator(idGenerator);
+ Intent.bindIdGenerator(idGenerator);
+ vplsOperationManager = new VplsOperationManager();
+ vplsOperationManager.coreService = new TestCoreService();
+ vplsOperationManager.intentService = new TestIntentService();
+ vplsOperationManager.leadershipService = new TestLeadershipService();
+ vplsOperationManager.clusterService = new ClusterServiceAdapter();
+ vplsOperationManager.hostService = new TestHostService();
+ vplsOperationManager.vplsStore = new TestVplsStore();
+ vplsOperationManager.isLeader = true;
+ vplsOperationManager.activate();
+ }
+
+ @After
+ public void tearDown() {
+ vplsOperationManager.deactivate();
+ }
+
+ /**
+ * Sends leadership event to the manager and checks if the manager is
+ * leader or not.
+ */
+ @Test
+ public void testLeadershipEvent() {
+ vplsOperationManager.isLeader = false;
+ vplsOperationManager.localNodeId = NODE_ID_1;
+
+ // leader changed to self
+ Leader leader = new Leader(NODE_ID_1, 0, 0);
+ Leadership leadership = new Leadership(APP_NAME, leader, ImmutableList.of());
+ LeadershipEvent event = new LeadershipEvent(LeadershipEvent.Type.LEADER_CHANGED, leadership);
+ ((TestLeadershipService) vplsOperationManager.leadershipService).sendEvent(event);
+ assertTrue(vplsOperationManager.isLeader);
+
+ // leader changed to other
+ leader = new Leader(NODE_ID_2, 0, 0);
+ leadership = new Leadership(APP_NAME, leader, ImmutableList.of());
+ event = new LeadershipEvent(LeadershipEvent.Type.LEADER_CHANGED, leadership);
+ ((TestLeadershipService) vplsOperationManager.leadershipService).sendEvent(event);
+ assertFalse(vplsOperationManager.isLeader);
+ }
+
+ /**
+ * Submits an ADD operation to the operation manager; check if the VPLS
+ * store changed after a period.
+ */
+ @Test
+ public void testSubmitAddOperation() {
+ VplsData vplsData = VplsData.of(VPLS1);
+ vplsData.addInterfaces(ImmutableSet.of(V100H1, V100H2));
+
+ VplsOperation vplsOperation = VplsOperation.of(vplsData,
+ VplsOperation.Operation.ADD);
+
+ vplsOperationManager.submit(vplsOperation);
+ assertAfter(OPERATION_DELAY, OPERATION_DURATION, () -> {
+ Collection<VplsData> vplss = vplsOperationManager.vplsStore.getAllVpls();
+ assertEquals(1, vplss.size());
+ VplsData result = vplss.iterator().next();
+
+ assertEquals(vplsData, result);
+ assertEquals(VplsData.VplsState.ADDED, result.state());
+
+ Set<Intent> intentsInstalled =
+ Sets.newHashSet(vplsOperationManager.intentService.getIntents());
+ assertEquals(4, intentsInstalled.size());
+ });
+ }
+
+ /**
+ * Submits an ADD operation to the operation manager; check the VPLS state
+ * from store if Intent install failed.
+ */
+ @Test
+ public void testSubmitAddOperationFail() {
+ vplsOperationManager.intentService = new AlwaysFailureIntentService();
+ VplsData vplsData = VplsData.of(VPLS1);
+ vplsData.addInterfaces(ImmutableSet.of(V100H1, V100H2));
+
+ VplsOperation vplsOperation = VplsOperation.of(vplsData,
+ VplsOperation.Operation.ADD);
+ vplsOperationManager.submit(vplsOperation);
+ assertAfter(OPERATION_DELAY, OPERATION_DURATION, () -> {
+ Collection<VplsData> vplss = vplsOperationManager.vplsStore.getAllVpls();
+ assertEquals(1, vplss.size());
+ VplsData result = vplss.iterator().next();
+
+ assertEquals(vplsData, result);
+ assertEquals(VplsData.VplsState.FAILED, result.state());
+ });
+ }
+
+ /**
+ * Submits an REMOVE operation to the operation manager; check if the VPLS
+ * store changed after a period.
+ */
+ @Test
+ public void testSubmitRemoveOperation() {
+ VplsData vplsData = VplsData.of(VPLS1);
+ vplsData.addInterfaces(ImmutableSet.of(V100H1, V100H2));
+ vplsData.state(VplsData.VplsState.REMOVING);
+
+ VplsOperation vplsOperation = VplsOperation.of(vplsData,
+ VplsOperation.Operation.REMOVE);
+
+ vplsOperationManager.submit(vplsOperation);
+
+ assertAfter(OPERATION_DELAY, OPERATION_DURATION, () -> {
+ Collection<VplsData> vplss = vplsOperationManager.vplsStore.getAllVpls();
+ assertEquals(0, vplss.size());
+ });
+ }
+
+ /**
+ * Submits an UPDATE operation with VPLS interface update to the operation manager; check if the VPLS
+ * store changed after a period.
+ */
+ @Test
+ public void testSubmitUpdateOperation() {
+ VplsData vplsData = VplsData.of(VPLS1);
+ vplsData.addInterfaces(ImmutableSet.of(V100H1));
+ vplsData.state(VplsData.VplsState.ADDED);
+ vplsOperationManager.vplsStore.addVpls(vplsData);
+
+ vplsData = VplsData.of(VPLS1, EncapsulationType.VLAN);
+ vplsData.addInterfaces(ImmutableSet.of(V100H1, V100H2));
+ vplsData.state(VplsData.VplsState.UPDATING);
+
+ VplsOperation vplsOperation = VplsOperation.of(vplsData,
+ VplsOperation.Operation.UPDATE);
+
+ vplsOperationManager.submit(vplsOperation);
+
+ assertAfter(OPERATION_DELAY, OPERATION_DURATION, () -> {
+ Collection<VplsData> vplss = vplsOperationManager.vplsStore.getAllVpls();
+ VplsData result = vplss.iterator().next();
+ VplsData expected = VplsData.of(VPLS1, EncapsulationType.VLAN);
+ expected.addInterfaces(ImmutableSet.of(V100H1, V100H2));
+ expected.state(VplsData.VplsState.ADDED);
+
+ assertEquals(1, vplss.size());
+ assertEquals(expected, result);
+
+ Set<Intent> intentsInstalled =
+ Sets.newHashSet(vplsOperationManager.intentService.getIntents());
+ assertEquals(4, intentsInstalled.size());
+ });
+ }
+
+ /**
+ * Submits an UPDATE operation with VPLS host update to the operation manager; check if the VPLS
+ * store changed after a period.
+ */
+ @Test
+ public void testSubmitUpdateHostOperation() {
+ vplsOperationManager.hostService = new EmptyHostService();
+ VplsData vplsData = VplsData.of(VPLS1);
+ vplsData.addInterfaces(ImmutableSet.of(V100H1, V100H2));
+
+ VplsOperation vplsOperation = VplsOperation.of(vplsData,
+ VplsOperation.Operation.ADD);
+ vplsOperationManager.submit(vplsOperation);
+ delay(1000);
+ vplsOperationManager.hostService = new TestHostService();
+
+ vplsData = VplsData.of(VPLS1);
+ vplsData.addInterfaces(ImmutableSet.of(V100H1, V100H2));
+ vplsData.state(VplsData.VplsState.UPDATING);
+
+ vplsOperation = VplsOperation.of(vplsData,
+ VplsOperation.Operation.UPDATE);
+
+ vplsOperationManager.submit(vplsOperation);
+
+ assertAfter(OPERATION_DELAY, OPERATION_DURATION, () -> {
+ Collection<VplsData> vplss = vplsOperationManager.vplsStore.getAllVpls();
+ VplsData result = vplss.iterator().next();
+ VplsData expected = VplsData.of(VPLS1);
+ expected.addInterfaces(ImmutableSet.of(V100H1, V100H2));
+ expected.state(VplsData.VplsState.ADDED);
+ assertEquals(1, vplss.size());
+ assertEquals(expected, result);
+
+ assertEquals(4, vplsOperationManager.intentService.getIntentCount());
+ });
+ }
+
+ /**
+ * Submits same operation twice to the manager; the manager should ignore
+ * duplicated operation.
+ */
+ @Test
+ public void testDuplicateOperationInQueue() {
+ VplsData vplsData = VplsData.of(VPLS1);
+ vplsData.addInterfaces(ImmutableSet.of(V100H1, V100H2));
+
+ VplsOperation vplsOperation = VplsOperation.of(vplsData,
+ VplsOperation.Operation.ADD);
+
+ vplsOperationManager.submit(vplsOperation);
+ vplsOperationManager.submit(vplsOperation);
+ Deque<VplsOperation> opQueue = vplsOperationManager.pendingVplsOperations.get(VPLS1);
+ assertEquals(1, opQueue.size());
+
+ // Clear operation queue before scheduler process it
+ opQueue.clear();
+ }
+
+ /**
+ * Submits REMOVE operation after submits ADD operation; there should be no
+ * pending or running operation in the manager.
+ */
+ @Test
+ public void testDoNothingOperation() {
+ VplsData vplsData = VplsData.of(VPLS1);
+ vplsData.addInterfaces(ImmutableSet.of(V100H1, V100H2));
+
+ VplsOperation vplsOperation = VplsOperation.of(vplsData,
+ VplsOperation.Operation.ADD);
+ vplsOperationManager.submit(vplsOperation);
+ vplsOperation = VplsOperation.of(vplsData,
+ VplsOperation.Operation.REMOVE);
+ vplsOperationManager.submit(vplsOperation);
+ assertAfter(OPERATION_DELAY, OPERATION_DURATION, () -> {
+ assertEquals(0, vplsOperationManager.pendingVplsOperations.size());
+
+ // Should not have any running operation
+ assertEquals(0, vplsOperationManager.runningOperations.size());
+ });
+ }
+
+ /**
+ * Optimize operations which don't need to be optimized.
+ */
+ @Test
+ public void testOptimizeOperationsNoOptimize() {
+ // empty queue
+ Deque<VplsOperation> operations = new ArrayDeque<>();
+ VplsOperation vplsOperation =
+ VplsOperationManager.getOptimizedVplsOperation(operations);
+ assertNull(vplsOperation);
+
+ // one operation
+ VplsData vplsData = VplsData.of(VPLS1);
+ vplsOperation = VplsOperation.of(vplsData, VplsOperation.Operation.ADD);
+ operations.add(vplsOperation);
+ VplsOperation result =
+ VplsOperationManager.getOptimizedVplsOperation(operations);
+ assertEquals(vplsOperation, result);
+
+ }
+
+ /**
+ * Optimize operations with first is ADD operation and last is also ADD
+ * operation.
+ */
+ @Test
+ public void testOptimizeOperationsAToA() {
+ Deque<VplsOperation> operations = new ArrayDeque<>();
+ VplsData vplsData = VplsData.of(VPLS1);
+ vplsData.addInterfaces(ImmutableSet.of(V100H1));
+ VplsOperation vplsOperation = VplsOperation.of(vplsData,
+ VplsOperation.Operation.ADD);
+ operations.add(vplsOperation);
+ vplsData = VplsData.of(VPLS1, EncapsulationType.VLAN);
+ vplsData.addInterfaces(ImmutableSet.of(V100H1, V100H2));
+ vplsOperation = VplsOperation.of(vplsData,
+ VplsOperation.Operation.ADD);
+ operations.add(vplsOperation);
+ vplsOperation = VplsOperationManager.getOptimizedVplsOperation(operations);
+ assertEquals(VplsOperation.of(vplsData, VplsOperation.Operation.ADD), vplsOperation);
+ }
+
+ /**
+ * Optimize operations with first is ADD operation and last is REMOVE
+ * operation.
+ */
+ @Test
+ public void testOptimizeOperationsAToR() {
+ Deque<VplsOperation> operations = new ArrayDeque<>();
+ VplsData vplsData = VplsData.of(VPLS1);
+ vplsData.addInterfaces(ImmutableSet.of(V100H1));
+ VplsOperation vplsOperation = VplsOperation.of(vplsData,
+ VplsOperation.Operation.ADD);
+ operations.add(vplsOperation);
+ vplsOperation = VplsOperation.of(vplsData,
+ VplsOperation.Operation.REMOVE);
+ operations.add(vplsOperation);
+ vplsOperation = VplsOperationManager.getOptimizedVplsOperation(operations);
+ assertNull(vplsOperation);
+ }
+
+ /**
+ * Optimize operations with first is ADD operation and last is UPDATE
+ * operation.
+ */
+ @Test
+ public void testOptimizeOperationsAToU() {
+ Deque<VplsOperation> operations = new ArrayDeque<>();
+ VplsData vplsData = VplsData.of(VPLS1);
+ vplsData.addInterfaces(ImmutableSet.of(V100H1));
+ VplsOperation vplsOperation = VplsOperation.of(vplsData,
+ VplsOperation.Operation.ADD);
+ operations.add(vplsOperation);
+ vplsData = VplsData.of(VPLS1, EncapsulationType.VLAN);
+ vplsData.addInterfaces(ImmutableSet.of(V100H1, V100H2));
+ vplsOperation = VplsOperation.of(vplsData,
+ VplsOperation.Operation.UPDATE);
+ operations.add(vplsOperation);
+ vplsOperation = VplsOperationManager.getOptimizedVplsOperation(operations);
+ assertEquals(VplsOperation.of(vplsData, VplsOperation.Operation.ADD), vplsOperation);
+ }
+
+ /**
+ * Optimize operations with first is REMOVE operation and last is ADD
+ * operation.
+ */
+ @Test
+ public void testOptimizeOperationsRToA() {
+ Deque<VplsOperation> operations = new ArrayDeque<>();
+ VplsData vplsData = VplsData.of(VPLS1);
+ vplsData.addInterfaces(ImmutableSet.of(V100H1));
+ VplsOperation vplsOperation = VplsOperation.of(vplsData,
+ VplsOperation.Operation.REMOVE);
+ operations.add(vplsOperation);
+ vplsData = VplsData.of(VPLS1, EncapsulationType.VLAN);
+ vplsData.addInterfaces(ImmutableSet.of(V100H1, V100H2));
+ vplsOperation = VplsOperation.of(vplsData,
+ VplsOperation.Operation.ADD);
+ operations.add(vplsOperation);
+ vplsOperation = VplsOperationManager.getOptimizedVplsOperation(operations);
+ assertEquals(VplsOperation.of(vplsData, VplsOperation.Operation.UPDATE), vplsOperation);
+ }
+
+ /**
+ * Optimize operations with first is REMOVE operation and last is also
+ * REMOVE operation.
+ */
+ @Test
+ public void testOptimizeOperationsRToR() {
+ Deque<VplsOperation> operations = new ArrayDeque<>();
+ VplsData vplsData = VplsData.of(VPLS1);
+ vplsData.addInterfaces(ImmutableSet.of(V100H1));
+ VplsOperation vplsOperation = VplsOperation.of(vplsData,
+ VplsOperation.Operation.REMOVE);
+ operations.add(vplsOperation);
+ vplsData = VplsData.of(VPLS1, EncapsulationType.VLAN);
+ vplsData.addInterfaces(ImmutableSet.of(V100H1, V100H2));
+ vplsOperation = VplsOperation.of(vplsData,
+ VplsOperation.Operation.REMOVE);
+ operations.add(vplsOperation);
+ vplsOperation = VplsOperationManager.getOptimizedVplsOperation(operations);
+ vplsData = VplsData.of(VPLS1);
+ vplsData.addInterfaces(ImmutableSet.of(V100H1));
+ assertEquals(VplsOperation.of(vplsData, VplsOperation.Operation.REMOVE), vplsOperation);
+ }
+
+ /**
+ * Optimize operations with first is REMOVE operation and last is UPDATE
+ * operation.
+ */
+ @Test
+ public void testOptimizeOperationsRToU() {
+ Deque<VplsOperation> operations = new ArrayDeque<>();
+ VplsData vplsData = VplsData.of(VPLS1);
+ vplsData.addInterfaces(ImmutableSet.of(V100H1));
+ VplsOperation vplsOperation = VplsOperation.of(vplsData,
+ VplsOperation.Operation.REMOVE);
+ operations.add(vplsOperation);
+ vplsData = VplsData.of(VPLS1, EncapsulationType.VLAN);
+ vplsData.addInterfaces(ImmutableSet.of(V100H1, V100H2));
+ vplsOperation = VplsOperation.of(vplsData,
+ VplsOperation.Operation.UPDATE);
+ operations.add(vplsOperation);
+ vplsOperation = VplsOperationManager.getOptimizedVplsOperation(operations);
+ assertEquals(VplsOperation.of(vplsData, VplsOperation.Operation.UPDATE), vplsOperation);
+ }
+
+ /**
+ * Optimize operations with first is UPDATE operation and last is ADD
+ * operation.
+ */
+ @Test
+ public void testOptimizeOperationsUToA() {
+ Deque<VplsOperation> operations = new ArrayDeque<>();
+ VplsData vplsData = VplsData.of(VPLS1);
+ vplsData.addInterfaces(ImmutableSet.of(V100H1));
+ VplsOperation vplsOperation = VplsOperation.of(vplsData,
+ VplsOperation.Operation.UPDATE);
+ operations.add(vplsOperation);
+ vplsData = VplsData.of(VPLS1, EncapsulationType.VLAN);
+ vplsData.addInterfaces(ImmutableSet.of(V100H1, V100H2));
+ vplsOperation = VplsOperation.of(vplsData,
+ VplsOperation.Operation.ADD);
+ operations.add(vplsOperation);
+ vplsOperation = VplsOperationManager.getOptimizedVplsOperation(operations);
+ assertEquals(VplsOperation.of(vplsData, VplsOperation.Operation.UPDATE), vplsOperation);
+ }
+
+ /**
+ * Optimize operations with first is UPDATE operation and last is REMOVE
+ * operation.
+ */
+ @Test
+ public void testOptimizeOperationsUToR() {
+ Deque<VplsOperation> operations = new ArrayDeque<>();
+ VplsData vplsData = VplsData.of(VPLS1);
+ vplsData.addInterfaces(ImmutableSet.of(V100H1));
+ VplsOperation vplsOperation = VplsOperation.of(vplsData,
+ VplsOperation.Operation.UPDATE);
+ operations.add(vplsOperation);
+ vplsData = VplsData.of(VPLS1, EncapsulationType.VLAN);
+ vplsData.addInterfaces(ImmutableSet.of(V100H1, V100H2));
+ vplsOperation = VplsOperation.of(vplsData,
+ VplsOperation.Operation.REMOVE);
+ operations.add(vplsOperation);
+ vplsOperation = VplsOperationManager.getOptimizedVplsOperation(operations);
+ assertEquals(VplsOperation.of(vplsData, VplsOperation.Operation.REMOVE), vplsOperation);
+ }
+
+ /**
+ * Optimize operations with first is UPDATE operation and last is also
+ * UPDATE operation.
+ */
+ @Test
+ public void testOptimizeOperationsUToU() {
+ Deque<VplsOperation> operations = new ArrayDeque<>();
+ VplsData vplsData = VplsData.of(VPLS1);
+ vplsData.addInterfaces(ImmutableSet.of(V100H1));
+ VplsOperation vplsOperation = VplsOperation.of(vplsData,
+ VplsOperation.Operation.UPDATE);
+ operations.add(vplsOperation);
+ vplsData = VplsData.of(VPLS1, EncapsulationType.VLAN);
+ vplsData.addInterfaces(ImmutableSet.of(V100H1, V100H2));
+ vplsOperation = VplsOperation.of(vplsData,
+ VplsOperation.Operation.UPDATE);
+ operations.add(vplsOperation);
+ vplsOperation = VplsOperationManager.getOptimizedVplsOperation(operations);
+ assertEquals(VplsOperation.of(vplsData, VplsOperation.Operation.UPDATE), vplsOperation);
+ }
+
+ /**
+ * Test Intent service which always fail when submit or withdraw Intents.
+ */
+ class AlwaysFailureIntentService extends TestIntentService {
+ @Override
+ public void submit(Intent intent) {
+ intents.add(new IntentData(intent, IntentState.FAILED, new WallClockTimestamp()));
+ if (listener != null) {
+ IntentEvent event = IntentEvent.getEvent(IntentState.FAILED, intent).get();
+ listener.event(event);
+ }
+ }
+
+ @Override
+ public void withdraw(Intent intent) {
+ intents.forEach(intentData -> {
+ if (intentData.intent().key().equals(intent.key())) {
+ intentData.setState(IntentState.FAILED);
+
+ if (listener != null) {
+ IntentEvent event = IntentEvent.getEvent(IntentState.FAILED, intent).get();
+ listener.event(event);
+ }
+ }
+ });
+ }
+ }
+
+ /**
+ * Test host service without any hosts.
+ */
+ class EmptyHostService extends HostServiceAdapter {
+ @Override
+ public Set<Host> getConnectedHosts(ConnectPoint connectPoint) {
+ return ImmutableSet.of();
+ }
+ }
+
+}
diff --git a/apps/vpls/src/test/java/org/onosproject/vpls/VplsTest.java b/apps/vpls/src/test/java/org/onosproject/vpls/VplsTest.java
index 6dfcea5..716b331 100644
--- a/apps/vpls/src/test/java/org/onosproject/vpls/VplsTest.java
+++ b/apps/vpls/src/test/java/org/onosproject/vpls/VplsTest.java
@@ -1,5 +1,5 @@
/*
- * Copyright 2016-present Open Networking Laboratory
+ * Copyright 2017-present 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.
@@ -13,704 +13,213 @@
* See the License for the specific language governing permissions and
* limitations under the License.
*/
+
package org.onosproject.vpls;
-import com.google.common.collect.HashMultimap;
+import com.fasterxml.jackson.databind.JsonNode;
+import com.fasterxml.jackson.databind.ObjectMapper;
import com.google.common.collect.ImmutableSet;
-import com.google.common.collect.ImmutableSetMultimap;
import com.google.common.collect.Lists;
import com.google.common.collect.Maps;
-import com.google.common.collect.SetMultimap;
import com.google.common.collect.Sets;
-import org.junit.After;
-import org.junit.Before;
-import org.junit.Test;
import org.onlab.packet.Ip4Address;
+import org.onlab.packet.IpAddress;
import org.onlab.packet.MacAddress;
import org.onlab.packet.VlanId;
import org.onosproject.TestApplicationId;
-import org.onosproject.app.ApplicationService;
+import org.onosproject.cluster.LeadershipEvent;
+import org.onosproject.cluster.LeadershipEventListener;
+import org.onosproject.cluster.LeadershipServiceAdapter;
+import org.onosproject.cluster.NodeId;
import org.onosproject.core.ApplicationId;
-import org.onosproject.core.CoreService;
+import org.onosproject.core.CoreServiceAdapter;
import org.onosproject.core.IdGenerator;
import org.onosproject.incubator.net.intf.Interface;
import org.onosproject.incubator.net.intf.InterfaceListener;
import org.onosproject.incubator.net.intf.InterfaceService;
-import org.onosproject.intentsync.IntentSynchronizationService;
import org.onosproject.net.ConnectPoint;
import org.onosproject.net.DefaultHost;
import org.onosproject.net.DeviceId;
import org.onosproject.net.EncapsulationType;
-import org.onosproject.net.FilteredConnectPoint;
import org.onosproject.net.Host;
import org.onosproject.net.HostId;
import org.onosproject.net.HostLocation;
import org.onosproject.net.PortNumber;
-import org.onosproject.net.config.NetworkConfigService;
-import org.onosproject.net.flow.DefaultTrafficSelector;
-import org.onosproject.net.flow.TrafficSelector;
-import org.onosproject.net.flow.criteria.Criterion;
-import org.onosproject.net.flow.criteria.VlanIdCriterion;
+import org.onosproject.net.config.Config;
+import org.onosproject.net.config.ConfigApplyDelegate;
+import org.onosproject.net.config.NetworkConfigEvent;
+import org.onosproject.net.config.NetworkConfigListener;
+import org.onosproject.net.config.NetworkConfigServiceAdapter;
import org.onosproject.net.host.HostEvent;
import org.onosproject.net.host.HostListener;
-import org.onosproject.net.host.HostService;
import org.onosproject.net.host.HostServiceAdapter;
import org.onosproject.net.intent.Intent;
-import org.onosproject.net.intent.IntentService;
+import org.onosproject.net.intent.IntentData;
+import org.onosproject.net.intent.IntentEvent;
+import org.onosproject.net.intent.IntentListener;
import org.onosproject.net.intent.IntentServiceAdapter;
-import org.onosproject.net.intent.IntentUtils;
-import org.onosproject.net.intent.Key;
-import org.onosproject.net.intent.MultiPointToSinglePointIntent;
-import org.onosproject.net.intent.SinglePointToMultiPointIntent;
+import org.onosproject.net.intent.IntentState;
import org.onosproject.net.provider.ProviderId;
-import org.onosproject.vpls.config.VplsConfigService;
+import org.onosproject.store.StoreDelegate;
+import org.onosproject.store.service.WallClockTimestamp;
+import org.onosproject.vpls.api.Vpls;
+import org.onosproject.vpls.api.VplsData;
+import org.onosproject.vpls.config.VplsAppConfig;
+import org.onosproject.vpls.config.VplsAppConfigTest;
+import org.onosproject.vpls.config.VplsConfig;
+import org.onosproject.vpls.store.VplsStoreAdapter;
+import org.onosproject.vpls.store.VplsStoreEvent;
+import java.io.IOException;
import java.util.Collection;
import java.util.Collections;
-import java.util.HashMap;
-import java.util.HashSet;
import java.util.List;
import java.util.Map;
import java.util.Set;
import java.util.concurrent.atomic.AtomicLong;
import java.util.stream.Collectors;
-import static java.lang.String.format;
-import static org.easymock.EasyMock.anyObject;
-import static org.easymock.EasyMock.createMock;
-import static org.easymock.EasyMock.expect;
-import static org.easymock.EasyMock.expectLastCall;
-import static org.easymock.EasyMock.replay;
-import static org.junit.Assert.assertEquals;
-import static org.junit.Assert.assertTrue;
-import static org.onosproject.net.EncapsulationType.NONE;
-import static org.onosproject.net.EncapsulationType.VLAN;
-import static org.onosproject.net.EncapsulationType.valueOf;
-import static org.onosproject.vpls.IntentInstaller.PARTIAL_FAILURE_CONSTRAINT;
-import static org.onosproject.vpls.IntentInstaller.PREFIX_BROADCAST;
-import static org.onosproject.vpls.IntentInstaller.PREFIX_UNICAST;
-import static org.onosproject.vpls.IntentInstaller.setEncap;
-
/**
- * Tests for the {@link Vpls} class.
+ * Class provides data for VPLS testing.
*/
-public class VplsTest {
- private static final String APP_NAME = "org.onosproject.vpls";
- private static final ApplicationId APPID = TestApplicationId.create(APP_NAME);
- private static final String DASH = "-";
- private static final int PRIORITY_OFFSET = 1000;
- private static final String VPLS1 = "vpls1";
- private static final String VPLS2 = "vpls2";
- private static final String VPLS3 = "vpls3";
- private static final String VPLS4 = "vpls4";
+public abstract class VplsTest {
+ protected static final String APP_NAME = "org.onosproject.vpls";
+ protected static final ApplicationId APPID = TestApplicationId.create(APP_NAME);
+ protected static final String DASH = "-";
+ protected static final int PRIORITY_OFFSET = 1000;
+ protected static final String VPLS1 = "vpls1";
+ protected static final String VPLS2 = "vpls2";
+ protected static final String VPLS3 = "vpls3";
+ protected static final String VPLS4 = "vpls4";
- private static final PortNumber P1 = PortNumber.portNumber(1);
- private static final PortNumber P2 = PortNumber.portNumber(2);
+ protected static final PortNumber P1 = PortNumber.portNumber(1);
+ protected static final PortNumber P2 = PortNumber.portNumber(2);
- private static final DeviceId DID1 = getDeviceId(1);
- private static final DeviceId DID2 = getDeviceId(2);
- private static final DeviceId DID3 = getDeviceId(3);
- private static final DeviceId DID4 = getDeviceId(4);
- private static final DeviceId DID5 = getDeviceId(5);
- private static final DeviceId DID6 = getDeviceId(6);
+ protected static final DeviceId DID1 = getDeviceId(1);
+ protected static final DeviceId DID2 = getDeviceId(2);
+ protected static final DeviceId DID3 = getDeviceId(3);
+ protected static final DeviceId DID4 = getDeviceId(4);
+ protected static final DeviceId DID5 = getDeviceId(5);
+ protected static final DeviceId DID6 = getDeviceId(6);
- private static final ConnectPoint CP1 = new ConnectPoint(DID1, P1);
- private static final ConnectPoint CP2 = new ConnectPoint(DID2, P1);
- private static final ConnectPoint CP3 = new ConnectPoint(DID3, P1);
- private static final ConnectPoint CP4 = new ConnectPoint(DID4, P1);
- private static final ConnectPoint CP5 = new ConnectPoint(DID5, P1);
- private static final ConnectPoint CP6 = new ConnectPoint(DID6, P1);
- private static final ConnectPoint CP7 = new ConnectPoint(DID4, P2);
- private static final ConnectPoint CP8 = new ConnectPoint(DID3, P2);
- private static final ConnectPoint CP9 = new ConnectPoint(DID5, P1);
- private static final ConnectPoint CP10 = new ConnectPoint(DID5, P2);
+ protected static final ConnectPoint CP1 = new ConnectPoint(DID1, P1);
+ protected static final ConnectPoint CP2 = new ConnectPoint(DID2, P1);
+ protected static final ConnectPoint CP3 = new ConnectPoint(DID3, P1);
+ protected static final ConnectPoint CP4 = new ConnectPoint(DID4, P1);
+ protected static final ConnectPoint CP5 = new ConnectPoint(DID5, P1);
+ protected static final ConnectPoint CP6 = new ConnectPoint(DID6, P1);
+ protected static final ConnectPoint CP7 = new ConnectPoint(DID4, P2);
+ protected static final ConnectPoint CP8 = new ConnectPoint(DID3, P2);
+ protected static final ConnectPoint CP9 = new ConnectPoint(DID5, P1);
+ protected static final ConnectPoint CP10 = new ConnectPoint(DID5, P2);
- private static final VlanId VLAN100 = VlanId.vlanId((short) 100);
- private static final VlanId VLAN200 = VlanId.vlanId((short) 200);
- private static final VlanId VLAN300 = VlanId.vlanId((short) 300);
- private static final VlanId VLAN400 = VlanId.vlanId((short) 400);
- private static final VlanId VLAN_NONE = VlanId.NONE;
+ protected static final VlanId VLAN100 = VlanId.vlanId((short) 100);
+ protected static final VlanId VLAN200 = VlanId.vlanId((short) 200);
+ protected static final VlanId VLAN300 = VlanId.vlanId((short) 300);
+ protected static final VlanId VLAN400 = VlanId.vlanId((short) 400);
+ protected static final VlanId VLAN_NONE = VlanId.NONE;
- private static final MacAddress MAC1 = getMac(1);
- private static final MacAddress MAC2 = getMac(2);
- private static final MacAddress MAC3 = getMac(3);
- private static final MacAddress MAC4 = getMac(4);
- private static final MacAddress MAC5 = getMac(5);
- private static final MacAddress MAC6 = getMac(6);
- private static final MacAddress MAC7 = getMac(7);
- private static final MacAddress MAC8 = getMac(8);
- private static final MacAddress MAC9 = getMac(9);
- private static final MacAddress MAC10 = getMac(10);
- private static final MacAddress MAC11 = getMac(11);
+ protected static final MacAddress MAC1 = getMac(1);
+ protected static final MacAddress MAC2 = getMac(2);
+ protected static final MacAddress MAC3 = getMac(3);
+ protected static final MacAddress MAC4 = getMac(4);
+ protected static final MacAddress MAC5 = getMac(5);
+ protected static final MacAddress MAC6 = getMac(6);
+ protected static final MacAddress MAC7 = getMac(7);
+ protected static final MacAddress MAC8 = getMac(8);
+ protected static final MacAddress MAC9 = getMac(9);
+ protected static final MacAddress MAC10 = getMac(10);
+ protected static final MacAddress MAC11 = getMac(11);
- private static final Ip4Address IP1 = Ip4Address.valueOf("192.168.1.1");
- private static final Ip4Address IP2 = Ip4Address.valueOf("192.168.1.2");
+ protected static final Ip4Address IP1 = Ip4Address.valueOf("192.168.1.1");
+ protected static final Ip4Address IP2 = Ip4Address.valueOf("192.168.1.2");
- private static final HostId HID1 = HostId.hostId(MAC1, VLAN100);
- private static final HostId HID2 = HostId.hostId(MAC2, VLAN100);
- private static final HostId HID3 = HostId.hostId(MAC3, VLAN200);
- private static final HostId HID4 = HostId.hostId(MAC4, VLAN200);
- private static final HostId HID5 = HostId.hostId(MAC5, VLAN300);
- private static final HostId HID6 = HostId.hostId(MAC6, VLAN300);
- private static final HostId HID7 = HostId.hostId(MAC7, VLAN300);
- private static final HostId HID8 = HostId.hostId(MAC8, VLAN400);
- private static final HostId HID9 = HostId.hostId(MAC9);
- private static final HostId HID10 = HostId.hostId(MAC10);
- private static final HostId HID11 = HostId.hostId(MAC11);
+ protected static final HostId HID1 = HostId.hostId(MAC1, VLAN100);
+ protected static final HostId HID2 = HostId.hostId(MAC2, VLAN100);
+ protected static final HostId HID3 = HostId.hostId(MAC3, VLAN200);
+ protected static final HostId HID4 = HostId.hostId(MAC4, VLAN200);
+ protected static final HostId HID5 = HostId.hostId(MAC5, VLAN300);
+ protected static final HostId HID6 = HostId.hostId(MAC6, VLAN300);
+ protected static final HostId HID7 = HostId.hostId(MAC7, VLAN300);
+ protected static final HostId HID8 = HostId.hostId(MAC8, VLAN400);
+ protected static final HostId HID9 = HostId.hostId(MAC9);
+ protected static final HostId HID10 = HostId.hostId(MAC10);
+ protected static final HostId HID11 = HostId.hostId(MAC11);
- private static final ProviderId PID = new ProviderId("of", "foo");
+ protected static final ProviderId PID = new ProviderId("of", "foo");
- private static IdGenerator idGenerator;
+ protected static final NodeId NODE_ID_1 = new NodeId("Node1");
+ protected static final NodeId NODE_ID_2 = new NodeId("Node2");
- private static final Interface V100H1 =
+ protected static IdGenerator idGenerator;
+
+ protected static final Interface V100H1 =
new Interface("v100h1", CP1, null, null, VLAN100);
- private static final Interface V100H2 =
+ protected static final Interface V100H2 =
new Interface("v100h2", CP2, null, null, VLAN100);
- private static final Interface V200H1 =
+ protected static final Interface V200H1 =
new Interface("v200h1", CP3, null, null, VLAN200);
- private static final Interface V200H2 =
+ protected static final Interface V200H2 =
new Interface("v200h2", CP4, null, null, VLAN200);
- private static final Interface V300H1 =
+ protected static final Interface V300H1 =
new Interface("v300h1", CP5, null, null, VLAN300);
- private static final Interface V300H2 =
+ protected static final Interface V300H2 =
new Interface("v300h2", CP6, null, null, VLAN300);
- private static final Interface V400H1 =
+ protected static final Interface V400H1 =
new Interface("v400h1", CP7, null, null, VLAN400);
- private static final Interface VNONEH1 =
+ protected static final Interface VNONEH1 =
new Interface("vNoneh1", CP8, null, null, VLAN_NONE);
- private static final Interface VNONEH2 =
+ protected static final Interface VNONEH2 =
new Interface("vNoneh2", CP9, null, null, VLAN_NONE);
- private static final Interface VNONEH3 =
+ protected static final Interface VNONEH3 =
new Interface("vNoneh3", CP10, null, null, VLAN_NONE);
- private static final Host V100HOST1 =
+ protected static final Host V100HOST1 =
new DefaultHost(PID, HID1, MAC1, VLAN100,
getLocation(1), Collections.singleton(IP1));
- private static final Host V100HOST2 =
+ protected static final Host V100HOST2 =
new DefaultHost(PID, HID2, MAC2, VLAN100,
getLocation(2), Sets.newHashSet());
- private static final Host V200HOST1 =
+ protected static final Host V200HOST1 =
new DefaultHost(PID, HID3, MAC3, VLAN200,
getLocation(3), Collections.singleton(IP2));
- private static final Host V200HOST2 =
+ protected static final Host V200HOST2 =
new DefaultHost(PID, HID4, MAC4, VLAN200,
getLocation(4), Sets.newHashSet());
- private static final Host V300HOST1 =
+ protected static final Host V300HOST1 =
new DefaultHost(PID, HID5, MAC5, VLAN300,
getLocation(5), Sets.newHashSet());
- private static final Host V300HOST2 =
+ protected static final Host V300HOST2 =
new DefaultHost(PID, HID6, MAC6, VLAN300,
getLocation(6), Sets.newHashSet());
- private static final Host V300HOST3 =
+ protected static final Host V300HOST3 =
new DefaultHost(PID, HID7, MAC7, VLAN300,
getLocation(7), Sets.newHashSet());
- private static final Host V400HOST1 =
+ protected static final Host V400HOST1 =
new DefaultHost(PID, HID8, MAC8, VLAN400,
getLocation(4, 2), Sets.newHashSet());
- private static final Host VNONEHOST1 =
+ protected static final Host VNONEHOST1 =
new DefaultHost(PID, HID9, MAC9, VlanId.NONE,
getLocation(3, 2), Sets.newHashSet());
- private static final Host VNONEHOST2 =
+ protected static final Host VNONEHOST2 =
new DefaultHost(PID, HID10, MAC10, VlanId.NONE,
getLocation(5, 1), Sets.newHashSet());
- private static final Host VNONEHOST3 =
+ protected static final Host VNONEHOST3 =
new DefaultHost(PID, HID11, MAC11, VlanId.NONE,
getLocation(5, 2), Sets.newHashSet());
- private static final Set<Interface> AVAILABLE_INTERFACES =
+ protected static final Set<Interface> AVAILABLE_INTERFACES =
ImmutableSet.of(V100H1, V100H2, V200H1, V200H2, V300H1, V300H2,
- V400H1, VNONEH1, VNONEH2);
+ V400H1, VNONEH1, VNONEH2, VNONEH3);
- private static final Set<Host> AVAILABLE_HOSTS =
+ protected static final Set<Host> AVAILABLE_HOSTS =
ImmutableSet.of(V100HOST1, V100HOST2, V200HOST1,
V200HOST2, V300HOST1, V300HOST2, V300HOST3,
VNONEHOST1, VNONEHOST2,
V400HOST1, VNONEHOST3);
- private SetMultimap<String, Interface> interfacesByVpls = HashMultimap.create();
-
- private ApplicationService applicationService;
- private CoreService coreService;
- private HostListener hostListener;
- private NetworkConfigService configService;
- private Set<Host> hostsAvailable;
- private HostService hostService;
- private IntentService intentService;
- private InterfaceService interfaceService;
- private VplsConfigService vplsConfigService;
- private Vpls vpls;
-
- @Before
- public void setUp() throws Exception {
- idGenerator = new TestIdGenerator();
- Intent.unbindIdGenerator(idGenerator);
- Intent.bindIdGenerator(idGenerator);
-
- applicationService = createMock(ApplicationService.class);
-
- configService = createMock(NetworkConfigService.class);
-
- coreService = createMock(CoreService.class);
- expect(coreService.registerApplication(APP_NAME))
- .andReturn(APPID);
- replay(coreService);
-
- hostsAvailable = Sets.newHashSet();
- hostService = new TestHostService(hostsAvailable);
-
- intentService = new TestIntentService();
-
- TestIntentSynchronizer intentSynchronizer =
- new TestIntentSynchronizer(intentService);
-
- interfaceService = createMock(InterfaceService.class);
- interfaceService.addListener(anyObject(InterfaceListener.class));
- expectLastCall().anyTimes();
- addIfaceConfig();
-
- interfacesByVpls.put(VPLS1, V100H1);
- interfacesByVpls.put(VPLS1, V200H1);
- interfacesByVpls.put(VPLS1, V300H1);
- interfacesByVpls.put(VPLS2, V100H2);
- interfacesByVpls.put(VPLS2, V200H2);
- interfacesByVpls.put(VPLS2, V300H2);
- interfacesByVpls.put(VPLS3, VNONEH1);
- interfacesByVpls.put(VPLS3, VNONEH2);
- interfacesByVpls.put(VPLS4, V400H1);
- interfacesByVpls.put(VPLS4, VNONEH3);
-
- Map<String, EncapsulationType> encapByVpls = new HashMap<>();
- encapByVpls.put(VPLS1, VLAN);
- encapByVpls.put(VPLS2, NONE);
- encapByVpls.put(VPLS3, NONE);
- encapByVpls.put(VPLS4, NONE);
-
- vplsConfigService = new TestVplsConfigService(interfacesByVpls, encapByVpls);
-
- vpls = new Vpls();
- vpls.applicationService = applicationService;
- vpls.coreService = coreService;
- vpls.hostService = hostService;
- vpls.vplsConfigService = vplsConfigService;
- vpls.intentService = intentService;
- vpls.interfaceService = interfaceService;
- vpls.configService = configService;
- vpls.intentSynchronizer = intentSynchronizer;
-
- }
-
- @After
- public void tearDown() {
- Intent.unbindIdGenerator(idGenerator);
- }
-
- /**
- * Creates the interface configuration:
- * On devices 1 and 2 is configured an interface on port 1 with vlan 100.
- * On device 3 is configured an interface on port 3 with no vlan.
- * On devices 3 and 4 is configured an interface on port 1 with vlan 200.
- * On device 4 is an interface configured on port 2 with vlan 400.
- * On device 5 are configured two interfaces on port 1 and 2 with no vlan.
- * On device 5 and 6 is configured an interface on port 1 with vlan 300.
- */
- private void addIfaceConfig() {
- Set<Interface> interfaces = ImmutableSet.copyOf(AVAILABLE_INTERFACES);
- Set<Interface> vlanOneSet = ImmutableSet.of(V100H1, V100H2);
- Set<Interface> vlanTwoSet = ImmutableSet.of(V200H1, V200H2);
- Set<Interface> vlanThreeSet = ImmutableSet.of(VNONEH1, VNONEH2);
- Set<Interface> vlanFourSet = ImmutableSet.of(V400H1, VNONEH3);
-
- AVAILABLE_INTERFACES.forEach(intf -> {
- expect(interfaceService.getInterfacesByPort(intf.connectPoint()))
- .andReturn(Sets.newHashSet(intf)).anyTimes();
- });
- expect(interfaceService.getInterfacesByVlan(VLAN100))
- .andReturn(vlanOneSet).anyTimes();
- expect(interfaceService.getInterfacesByVlan(VLAN200))
- .andReturn(vlanTwoSet).anyTimes();
- expect(interfaceService.getInterfacesByVlan(VLAN300))
- .andReturn(vlanThreeSet).anyTimes();
- expect(interfaceService.getInterfacesByVlan(VLAN400))
- .andReturn(vlanFourSet).anyTimes();
- expect(interfaceService.getInterfacesByVlan(VlanId.NONE))
- .andReturn(vlanFourSet).anyTimes();
- expect(interfaceService.getInterfaces()).andReturn(interfaces).anyTimes();
-
- replay(interfaceService);
- }
-
- /**
- * Seven ports are configured with VLANs, while three ports are not. No hosts are
- * registered by the HostService.
- *
- * The first three ports have an interface configured on VPLS 1,
- * the other three on VPLS 2. Two ports are defined for VPLS 3, while
- * the two remaining ports are configured on VPLS 4.
- *
- * The number of intents expected is 10: three for VPLS 1, three for VPLS 2,
- * two for VPLS 3, two for VPLS 4. Eight MP2SP intents.
- * Checks if the number of intents submitted to the intent framework is
- * equal to the number of intents expected and if all intents are equivalent.
- */
- @Test
- public void activateNoHosts() {
- vpls.activate();
-
- List<Intent> expectedIntents = Lists.newArrayList();
- Set<FilteredConnectPoint> fcPoints;
-
- fcPoints = buildFCPoints(ImmutableSet.of(V100H1, V200H1, V300H1));
- expectedIntents.addAll(generateVplsBrc(fcPoints, VPLS1, VLAN));
-
- fcPoints = buildFCPoints(ImmutableSet.of(V100H2, V200H2, V300H2));
- expectedIntents.addAll(generateVplsBrc(fcPoints, VPLS2, NONE));
-
- fcPoints = buildFCPoints(ImmutableSet.of(VNONEH1, VNONEH2));
- expectedIntents.addAll(generateVplsBrc(fcPoints, VPLS3, NONE));
-
- fcPoints = buildFCPoints(ImmutableSet.of(V400H1, VNONEH3));
- expectedIntents.addAll(generateVplsBrc(fcPoints, VPLS4, NONE));
-
- checkIntents(expectedIntents);
- }
-
- /**
- * Ten ports are configured with VLANs and ten hosts are registered by the
- * HostService.
- *
- * The first three ports have an interface configured on VPLS 1,
- * the other three on VPLS 2, two on VPLS3 and two on VPLS4.
- *
- * The number of intents expected is twenty: six
- * for VPLS 1, six for VPLS 2. four for VPLS 3, four for VPLS 4.
- * That is ten sp2mp intents, ten mp2sp intents. For VPLS 1
- * IPs are added to demonstrate this doesn't influence the number of intents
- * created. Checks if the number of intents submitted to the intent
- * framework is equal to the number of intents expected and if all intents
- * are equivalent.
- */
- @Test
- public void tenInterfacesConfiguredHostsPresent() {
- hostsAvailable.addAll(AVAILABLE_HOSTS);
-
- vpls.activate();
-
- List<Intent> expectedIntents = Lists.newArrayList();
- Set<FilteredConnectPoint> fcPoints;
- Set<Host> hosts;
-
- fcPoints = buildFCPoints(ImmutableSet.of(V100H1, V200H1, V300H1));
- hosts = ImmutableSet.of(V100HOST1, V200HOST1, V300HOST1);
- expectedIntents.addAll(generateVplsBrc(fcPoints, VPLS1, VLAN));
- expectedIntents.addAll(generateVplsUni(fcPoints, hosts, VPLS1, VLAN));
-
- fcPoints = buildFCPoints(ImmutableSet.of(V100H2, V200H2, V300H2));
- hosts = ImmutableSet.of(V100HOST2, V200HOST2, V300HOST2);
- expectedIntents.addAll(generateVplsBrc(fcPoints, VPLS2, NONE));
- expectedIntents.addAll(generateVplsUni(fcPoints, hosts, VPLS2, NONE));
-
- fcPoints = buildFCPoints(ImmutableSet.of(VNONEH1, VNONEH2));
- hosts = ImmutableSet.of(VNONEHOST1, VNONEHOST2);
- expectedIntents.addAll(generateVplsBrc(fcPoints, VPLS3, NONE));
- expectedIntents.addAll(generateVplsUni(fcPoints, hosts, VPLS3, NONE));
-
- fcPoints = buildFCPoints(ImmutableSet.of(V400H1, VNONEH3));
- hosts = ImmutableSet.of(V400HOST1, VNONEHOST3);
- expectedIntents.addAll(generateVplsBrc(fcPoints, VPLS4, NONE));
- expectedIntents.addAll(generateVplsUni(fcPoints, hosts, VPLS4, NONE));
-
- checkIntents(expectedIntents);
- }
-
- /**
- * Ten ports are configured; seven have VLANs and three do not.
- * Initially, no hosts are registered by the HostService.
- *
- * The first three ports have an interface configured on
- * VPLS 1, three have an interface configured on VPLS 2, two have an
- * interface configured on VPLS 3 and two have an interface configured
- * on VPLS 4, three have an interface configure. When the
- * module starts up, three hosts attached to device one, two and three -
- * port 1, are registered by the HostService and events are sent to the
- * application. sp2mp intents are created for all interfaces configured and
- * mp2sp intents are created only for the hosts attached.
- *
- * The number of intents expected is seventeen: six for VPLS 1,
- * three for VPLS 2, four for VPLS3 and four for VPLS4.
- * Ten sp2mp intents, seven mp2sp intents. IPs are added on the first two
- * hosts only to demonstrate this doesn't influence the number of intents
- * created.
- * An additional host is added on device seven - port 1, to demonstrate that
- * the application does not generate intents, even if the interface uses the
- * same VLAN Id of the other interfaces configured for the specifc VPLS.
- * Checks if the number of intents submitted to the intent framework is equal
- * to the number of intents expected and if all intents are equivalent.
- */
- @Test
- public void tenInterfacesThreeHostEventsSameVpls() {
- vpls.activate();
-
- List<Intent> expectedIntents = Lists.newArrayList();
- Set<FilteredConnectPoint> fcPoints;
- Set<Host> hosts;
-
- hostsAvailable.addAll(Sets.newHashSet(V100HOST1, V200HOST1,
- V300HOST1, V300HOST3,
- VNONEHOST1, VNONEHOST2,
- V400HOST1, VNONEHOST3));
- hostsAvailable.forEach(host ->
- hostListener.event(new HostEvent(HostEvent.Type.HOST_ADDED, host)));
-
- fcPoints = buildFCPoints(ImmutableSet.of(V100H1, V200H1, V300H1));
- hosts = ImmutableSet.of(V100HOST1, V200HOST1, V300HOST1);
- expectedIntents.addAll(generateVplsBrc(fcPoints, VPLS1, VLAN));
- expectedIntents.addAll(generateVplsUni(fcPoints, hosts, VPLS1, VLAN));
-
- fcPoints = buildFCPoints(ImmutableSet.of(V100H2, V200H2, V300H2));
- expectedIntents.addAll(generateVplsBrc(fcPoints, VPLS2, NONE));
-
- fcPoints = buildFCPoints(ImmutableSet.of(VNONEH1, VNONEH2));
- hosts = ImmutableSet.of(VNONEHOST1, VNONEHOST2);
- expectedIntents.addAll(generateVplsBrc(fcPoints, VPLS3, NONE));
- expectedIntents.addAll(generateVplsUni(fcPoints, hosts, VPLS3, NONE));
-
- fcPoints = buildFCPoints(ImmutableSet.of(V400H1, VNONEH3));
- hosts = ImmutableSet.of(V400HOST1, VNONEHOST3);
- expectedIntents.addAll(generateVplsBrc(fcPoints, VPLS4, NONE));
- expectedIntents.addAll(generateVplsUni(fcPoints, hosts, VPLS4, NONE));
-
- checkIntents(expectedIntents);
- }
-
- /**
- * Generates a list of the expected sp2mp intents for a VPLS.
- *
- * @param fcPoints the filtered connect point
- * @param name the name of the VPLS
- * @param encap the encapsulation type
- * @return the list of expected sp2mp intents for the given VPLS
- */
- private List<SinglePointToMultiPointIntent>
- generateVplsBrc(Set<FilteredConnectPoint> fcPoints, String name, EncapsulationType encap) {
- List<SinglePointToMultiPointIntent> intents = Lists.newArrayList();
-
- fcPoints.forEach(point -> {
- Set<FilteredConnectPoint> otherPoints =
- fcPoints.stream()
- .filter(fcp -> !fcp.equals(point))
- .collect(Collectors.toSet());
-
- Key brckey = buildKey(PREFIX_BROADCAST,
- point.connectPoint(),
- name,
- MacAddress.BROADCAST);
-
- intents.add(buildBrcIntent(brckey, point, otherPoints, encap));
- });
-
- return intents;
- }
-
- /**
- * Generates a list of expected mp2sp intents for a given VPLS.
- *
- * @param fcPoints the filtered connect point
- * @param hosts the hosts
- * @param name the name of the VPLS
- * @param encap the encapsulation type
- * @return the list of expected mp2sp intents for the given VPLS
- */
- private List<MultiPointToSinglePointIntent>
- generateVplsUni(Set<FilteredConnectPoint> fcPoints, Set<Host> hosts,
- String name, EncapsulationType encap) {
- List<MultiPointToSinglePointIntent> intents = Lists.newArrayList();
-
- hosts.forEach(host -> {
- FilteredConnectPoint hostPoint = getHostPoint(host, fcPoints);
-
- Set<FilteredConnectPoint> otherPoints =
- fcPoints.stream()
- .filter(fcp -> !fcp.equals(hostPoint))
- .collect(Collectors.toSet());
-
- Key uniKey = buildKey(PREFIX_UNICAST,
- host.location(), name, host.mac());
-
- intents.add(buildUniIntent(uniKey, otherPoints, hostPoint, host, encap));
- });
-
- return intents;
- }
-
- /**
- * Checks if the number of intents submitted to the intent framework is equal
- * to the number of intents expected and if all intents are equivalent.
- *
- * @param intents the list of intents expected
- */
- private void checkIntents(List<Intent> intents) {
- assertEquals("The number of intents submitted differs from the number" +
- " of intents expected. ",
- intents.size(), intentService.getIntentCount());
-
- for (Intent intentOne : intents) {
- boolean found = false;
- for (Intent intentTwo : intentService.getIntents()) {
- if (intentOne.key().equals(intentTwo.key())) {
- found = true;
- assertTrue(format("The intent submitted is different from" +
- " the intent expected. %s %s",
- intentOne, intentTwo),
- IntentUtils.intentsAreEqual(intentOne, intentTwo));
- break;
- }
- }
- assertTrue("The intent submitted is not equal to any of the expected" +
- " intents. ", found);
- }
- }
-
- /**
- * Builds a broadcast intent.
- *
- * @param key the key to identify the intent
- * @param src the ingress connect point
- * @param dsts the egress connect points
- * @return the generated single-point to multi-point intent
- */
- private SinglePointToMultiPointIntent buildBrcIntent(Key key,
- FilteredConnectPoint src,
- Set<FilteredConnectPoint> dsts,
- EncapsulationType encap) {
- SinglePointToMultiPointIntent.Builder intentBuilder;
-
- TrafficSelector selector = DefaultTrafficSelector.builder()
- .matchEthDst(MacAddress.BROADCAST)
- .build();
-
- intentBuilder = SinglePointToMultiPointIntent.builder()
- .appId(APPID)
- .key(key)
- .selector(selector)
- .filteredIngressPoint(src)
- .filteredEgressPoints(dsts)
- .constraints(PARTIAL_FAILURE_CONSTRAINT)
- .priority(PRIORITY_OFFSET);
-
- setEncap(intentBuilder, PARTIAL_FAILURE_CONSTRAINT, encap);
-
- return intentBuilder.build();
- }
-
- /**
- * Builds a unicast intent.
- *
- * @param key the key to identify the intent
- * @param srcs the ingress connect points
- * @param dst the egress connect point
- * @param host the destination Host
- * @return the generated multi-point to single-point intent
- */
- private MultiPointToSinglePointIntent buildUniIntent(Key key,
- Set<FilteredConnectPoint> srcs,
- FilteredConnectPoint dst,
- Host host,
- EncapsulationType encap) {
- MultiPointToSinglePointIntent.Builder intentBuilder;
-
- TrafficSelector selector = DefaultTrafficSelector.builder()
- .matchEthDst(host.mac())
- .build();
-
- intentBuilder = MultiPointToSinglePointIntent.builder()
- .appId(APPID)
- .key(key)
- .selector(selector)
- .filteredIngressPoints(srcs)
- .filteredEgressPoint(dst)
- .constraints(PARTIAL_FAILURE_CONSTRAINT)
- .priority(PRIORITY_OFFSET);
-
- setEncap(intentBuilder, PARTIAL_FAILURE_CONSTRAINT, encap);
-
- return intentBuilder.build();
- }
-
- /**
- * Returns the filtered connect point associated to a given host.
- *
- * @param host the target host
- * @param fcps the filtered connected points
- * @return the filtered connect point associated to the given host; null
- * otherwise
- */
- private FilteredConnectPoint getHostPoint(Host host,
- Set<FilteredConnectPoint> fcps) {
- return fcps.stream()
- .filter(fcp -> fcp.connectPoint().equals(host.location()))
- .filter(fcp -> {
- VlanIdCriterion vlanCriterion =
- (VlanIdCriterion) fcp.trafficSelector().
- getCriterion(Criterion.Type.VLAN_VID);
- return vlanCriterion == null ||
- vlanCriterion.vlanId().equals(host.vlan());
- })
- .findFirst()
- .orElse(null);
- }
-
- /**
- * Computes a set of filtered connect points from a list of given interfaces.
- *
- * @param interfaces the interfaces to compute
- * @return the set of filtered connect points
- */
- private Set<FilteredConnectPoint> buildFCPoints(Collection<Interface> interfaces) {
- // Build all filtered connected points in the VPLS
- return interfaces
- .stream()
- .map(intf -> {
- TrafficSelector.Builder selectorBuilder =
- DefaultTrafficSelector.builder();
- if (!intf.vlan().equals(VlanId.NONE)) {
- selectorBuilder.matchVlanId(intf.vlan());
- }
- return new FilteredConnectPoint(intf.connectPoint(),
- selectorBuilder.build());
- })
- .collect(Collectors.toSet());
- }
-
- /**
- * Builds an intent Key either for a single-point to multi-point or
- * multi-point to single-point intent, based on a prefix that defines
- * the intent type, the connection point representing the source or the
- * destination and the VLAN Id representing the VPLS.
- *
- * @param prefix the key prefix
- * @param cPoint the ingress/egress connect point
- * @param vplsName the VPLS name
- * @param hostMac the ingress/egress MAC address
- * @return the key to identify the intent
- */
- private Key buildKey(String prefix,
- ConnectPoint cPoint,
- String vplsName,
- MacAddress hostMac) {
- String keyString = vplsName +
- DASH +
- prefix +
- DASH +
- cPoint.deviceId() +
- DASH +
- cPoint.port() +
- DASH +
- hostMac;
-
- return Key.of(keyString, APPID);
- }
/**
* Returns the device Id of the ith device.
@@ -718,38 +227,91 @@
* @param i the device to get the Id of
* @return the device Id
*/
- private static DeviceId getDeviceId(int i) {
+ protected static DeviceId getDeviceId(int i) {
return DeviceId.deviceId("" + i);
}
- private static MacAddress getMac(int n) {
+ /**
+ * Generates a mac address by given number.
+ *
+ * @param n the number to generate mac address
+ * @return the mac address
+ */
+ protected static MacAddress getMac(int n) {
return MacAddress.valueOf(String.format("00:00:00:00:00:%s", n));
}
- private static HostLocation getLocation(int i) {
+ /**
+ * Generates a host location by given device number.
+ *
+ * @param i the given number
+ * @return the host location
+ */
+ protected static HostLocation getLocation(int i) {
return new HostLocation(new ConnectPoint(getDeviceId(i), P1), 123L);
}
- private static HostLocation getLocation(int d, int p) {
+ /**
+ * Generates host location by given device number and port number.
+ *
+ * @param d the device number
+ * @param p the port number
+ * @return the host location
+ */
+ protected static HostLocation getLocation(int d, int p) {
return new HostLocation(new ConnectPoint(getDeviceId(d),
PortNumber.portNumber(p)), 123L);
}
/**
- * Represents a fake IntentService class that allows to store and retrieve
- * intents without implementing the IntentService logic.
+ * Test core service; For generate test application ID.
*/
- private class TestIntentService extends IntentServiceAdapter {
+ public class TestCoreService extends CoreServiceAdapter {
+ @Override
+ public ApplicationId registerApplication(String name) {
+ return TestApplicationId.create(name);
+ }
+ }
- private Map<Key, Intent> intents;
+ /**
+ * Test intent service.
+ * Always install or withdraw success for any Intents.
+ */
+ public class TestIntentService extends IntentServiceAdapter {
+ IntentListener listener;
+ List<IntentData> intents;
public TestIntentService() {
- intents = Maps.newHashMap();
+ intents = Lists.newArrayList();
}
@Override
public void submit(Intent intent) {
- intents.put(intent.key(), intent);
+ intents.add(new IntentData(intent, IntentState.INSTALLED, new WallClockTimestamp()));
+ if (listener != null) {
+ IntentEvent.getEvent(IntentState.INSTALLED, intent).ifPresent(listener::event);
+
+ }
+ }
+
+ @Override
+ public void withdraw(Intent intent) {
+ intents.forEach(intentData -> {
+ if (intentData.intent().key().equals(intent.key())) {
+ intentData.setState(IntentState.WITHDRAWN);
+
+ if (listener != null) {
+ IntentEvent.getEvent(IntentState.WITHDRAWN, intent).ifPresent(listener::event);
+ }
+ }
+ });
+ }
+
+ @Override
+ public Iterable<Intent> getIntents() {
+ return intents.stream()
+ .map(IntentData::intent)
+ .collect(Collectors.toList());
}
@Override
@@ -758,52 +320,227 @@
}
@Override
- public Iterable<Intent> getIntents() {
- return intents.values();
+ public void addListener(IntentListener listener) {
+ this.listener = listener;
}
@Override
- public Intent getIntent(Key intentKey) {
- for (Intent intent : intents.values()) {
- if (intent.key().equals(intentKey)) {
- return intent;
- }
- }
- return null;
+ public void removeListener(IntentListener listener) {
+ this.listener = null;
}
}
/**
- * Represents a fake HostService class which allows to add hosts manually
- * in each test, when needed.
+ * Test leadership service.
*/
- private class TestHostService extends HostServiceAdapter {
+ public class TestLeadershipService extends LeadershipServiceAdapter {
+ LeadershipEventListener listener;
- private Set<Host> hosts;
-
- public TestHostService(Set<Host> hosts) {
- this.hosts = hosts;
+ @Override
+ public void addListener(LeadershipEventListener listener) {
+ this.listener = listener;
}
@Override
- public void addListener(HostListener listener) {
- VplsTest.this.hostListener = listener;
+ public void removeListener(LeadershipEventListener listener) {
+ this.listener = null;
+ }
+
+ /**
+ * Sends the leadership event to the listener.
+ *
+ * @param event the Intent event
+ */
+ public void sendEvent(LeadershipEvent event) {
+ if (listener != null && listener.isRelevant(event)) {
+ listener.event(event);
+ }
}
@Override
- public Set<Host> getConnectedHosts(ConnectPoint connectPoint) {
- return hosts.stream()
- .filter(h -> h.location().equals(connectPoint))
+ public NodeId getLeader(String path) {
+ return NODE_ID_1;
+ }
+ }
+
+ /**
+ * Test interface service; contains all interfaces which already generated.
+ */
+ public class TestInterfaceService implements InterfaceService {
+
+ @Override
+ public void addListener(InterfaceListener listener) {
+ }
+
+ @Override
+ public void removeListener(InterfaceListener listener) {
+ }
+
+ @Override
+ public Set<Interface> getInterfaces() {
+ return AVAILABLE_INTERFACES;
+ }
+
+ @Override
+ public Interface getInterfaceByName(ConnectPoint connectPoint,
+ String name) {
+ return AVAILABLE_INTERFACES.stream()
+ .filter(intf -> intf.name().equals(name))
+ .findFirst()
+ .orElse(null);
+ }
+
+ @Override
+ public Set<Interface> getInterfacesByPort(ConnectPoint port) {
+ return AVAILABLE_INTERFACES.stream()
+ .filter(intf -> intf.connectPoint().equals(port))
.collect(Collectors.toSet());
}
+ @Override
+ public Set<Interface> getInterfacesByIp(IpAddress ip) {
+ return AVAILABLE_INTERFACES.stream()
+ .filter(intf -> intf.ipAddressesList().contains(ip))
+ .collect(Collectors.toSet());
+ }
+
+ @Override
+ public Set<Interface> getInterfacesByVlan(VlanId vlan) {
+ return AVAILABLE_INTERFACES.stream()
+ .filter(intf -> intf.vlan().equals(vlan))
+ .collect(Collectors.toSet());
+ }
+
+ @Override
+ public Interface getMatchingInterface(IpAddress ip) {
+ return AVAILABLE_INTERFACES.stream()
+ .filter(intf -> intf.ipAddressesList().contains(ip))
+ .findFirst()
+ .orElse(null);
+ }
+
+ @Override
+ public Set<Interface> getMatchingInterfaces(IpAddress ip) {
+ return AVAILABLE_INTERFACES.stream()
+ .filter(intf -> intf.ipAddressesList().contains(ip))
+ .collect(Collectors.toSet());
+ }
+ }
+
+ /**
+ * Test VPLS store.
+ */
+ public class TestVplsStore extends VplsStoreAdapter {
+ /**
+ * Clears the store.
+ */
+ public void clear() {
+ vplsDataMap.clear();
+ }
+
+ /**
+ * Gets the store delegate.
+ *
+ * @return the store delegate
+ */
+ public StoreDelegate<VplsStoreEvent> delegate() {
+ return this.delegate;
+ }
+ }
+
+ /**
+ * Test VPLS.
+ * Provides basic VPLS functionality and stores VPLS information.
+ */
+ public class TestVpls implements Vpls {
+ public Map<String, VplsData> testData;
+
+ public TestVpls() {
+ testData = Maps.newHashMap();
+ }
+
+ public void initSampleData() {
+ testData.clear();
+ VplsData vplsData = VplsData.of(VPLS1);
+ vplsData.addInterfaces(ImmutableSet.of(V100H1, V100H2));
+ vplsData.state(VplsData.VplsState.ADDED);
+ testData.put(VPLS1, vplsData);
+
+ vplsData = VplsData.of(VPLS2);
+ vplsData.addInterfaces(ImmutableSet.of(V200H1, V200H2));
+ vplsData.state(VplsData.VplsState.ADDED);
+ testData.put(VPLS2, vplsData);
+ }
+
+ @Override
+ public VplsData createVpls(String vplsName, EncapsulationType encapsulationType) {
+ VplsData vplsData = VplsData.of(vplsName, encapsulationType);
+ testData.put(vplsName, vplsData);
+ return vplsData;
+ }
+
+ @Override
+ public VplsData removeVpls(VplsData vplsData) {
+ if (!testData.containsKey(vplsData.name())) {
+ return null;
+ }
+
+ testData.remove(vplsData.name());
+ return vplsData;
+ }
+
+ @Override
+ public void addInterfaces(VplsData vplsData, Collection<Interface> interfaces) {
+ vplsData.addInterfaces(interfaces);
+ testData.put(vplsData.name(), vplsData);
+ }
+
+ @Override
+ public void addInterface(VplsData vplsData, Interface iface) {
+ vplsData.addInterface(iface);
+ testData.put(vplsData.name(), vplsData);
+ }
+
+ @Override
+ public void setEncapsulationType(VplsData vplsData, EncapsulationType encapsulationType) {
+ vplsData.encapsulationType(encapsulationType);
+ testData.put(vplsData.name(), vplsData);
+ }
+
+ @Override
+ public VplsData getVpls(String vplsName) {
+ return testData.get(vplsName);
+ }
+
+ @Override
+ public Collection<VplsData> getAllVpls() {
+ return testData.values();
+ }
+
+ @Override
+ public Collection<Interface> removeInterfaces(VplsData vplsData, Collection<Interface> interfaces) {
+ vplsData.removeInterfaces(interfaces);
+ testData.put(vplsData.name(), vplsData);
+ return interfaces;
+ }
+
+ @Override
+ public Interface removeInterface(VplsData vplsData, Interface iface) {
+ vplsData.removeInterface(iface);
+ testData.put(vplsData.name(), vplsData);
+ return iface;
+ }
+
+ @Override
+ public void removeAllVpls() {
+ testData.clear();
+ }
}
/**
* Represents a fake IdGenerator class for intents.
*/
- private static class TestIdGenerator implements IdGenerator {
-
+ protected static class TestIdGenerator implements IdGenerator {
private final AtomicLong id = new AtomicLong(0);
@Override
@@ -814,170 +551,135 @@
}
/**
- * Test IntentSynchronizer that passes all intents straight through to the
- * intent service.
+ * Test host service; contains all hosts which already generated.
+ *
*/
- private class TestIntentSynchronizer implements IntentSynchronizationService {
+ public class TestHostService extends HostServiceAdapter {
- private final IntentService intentService;
+ private HostListener listener;
- /**
- * Creates a new intent test synchronizer.
- *
- * @param intentService intent service
- */
- public TestIntentSynchronizer(IntentService intentService) {
- this.intentService = intentService;
+ @Override
+ public Set<Host> getConnectedHosts(ConnectPoint connectPoint) {
+ return AVAILABLE_HOSTS.stream()
+ .filter(host -> host.location().equals(connectPoint))
+ .collect(Collectors.toSet());
}
@Override
- public void submit(Intent intent) {
- intentService.submit(intent);
+ public Set<Host> getHostsByMac(MacAddress mac) {
+ return AVAILABLE_HOSTS.stream()
+ .filter(host -> host.mac().equals(mac))
+ .collect(Collectors.toSet());
}
@Override
- public void withdraw(Intent intent) {
- intentService.withdraw(intent);
+ public Iterable<Host> getHosts() {
+ return AVAILABLE_HOSTS;
}
@Override
- public void removeIntentsByAppId(ApplicationId applicationId) {
+ public Set<Host> getHostsByVlan(VlanId vlanId) {
+ return AVAILABLE_HOSTS.stream()
+ .filter(host -> host.vlan().equals(vlanId))
+ .collect(Collectors.toSet());
+ }
+
+ @Override
+ public int getHostCount() {
+ return AVAILABLE_HOSTS.size();
+ }
+
+ @Override
+ public Host getHost(HostId hostId) {
+ return AVAILABLE_HOSTS.stream()
+ .filter(host -> host.id().equals(hostId))
+ .findFirst()
+ .orElse(null);
+ }
+
+ @Override
+ public void addListener(HostListener listener) {
+ this.listener = listener;
+ }
+
+ public void postHostEvent(HostEvent hostEvent) {
+ this.listener.event(hostEvent);
}
}
/**
- * Represents a fake VplsConfigService class which is needed for testing.
+ * Test network configuration service.
*/
- private class TestVplsConfigService extends VplsConfigServiceAdapter {
+ public class TestConfigService extends NetworkConfigServiceAdapter {
+ public static final String EMPTY_JSON_TREE = "{}";
+ NetworkConfigListener listener;
+ VplsAppConfig vplsAppConfig;
- private final SetMultimap<String, Interface> ifacesByVplsName;
- private final Map<String, EncapsulationType> encapsByVplsName;
-
- private Set<String> vplsAffectByApi = new HashSet<>();
-
- TestVplsConfigService(SetMultimap<String, Interface> ifacesByVplsName,
- Map<String, EncapsulationType> encapsByVplsName) {
- this.ifacesByVplsName = ifacesByVplsName;
- this.encapsByVplsName = encapsByVplsName;
+ @Override
+ public void addListener(NetworkConfigListener listener) {
+ this.listener = listener;
}
@Override
- public void addVpls(String vplsName, Set<String> ifaceNames, String encap) {
- if (!ifacesByVplsName.containsKey(vplsName)) {
- ifaceNames.forEach(ifaceName -> {
- AVAILABLE_INTERFACES.forEach(iface -> {
- if (iface.name().equals(ifaceName)) {
- ifacesByVplsName.put(vplsName, iface);
- }
- });
- });
- }
- if (!ifacesByVplsName.containsKey(vplsName)) {
- encapsByVplsName.put(vplsName, valueOf(encap));
+ public void removeListener(NetworkConfigListener listener) {
+ this.listener = null;
+ }
+
+ /**
+ * Sends network config event to listener.
+ *
+ * @param event the network config event
+ */
+ public void sendEvent(NetworkConfigEvent event) {
+ if (listener != null) {
+ listener.event(event);
}
}
- @Override
- public void removeVpls(String vplsName) {
- if (ifacesByVplsName.containsKey(vplsName)) {
- ifacesByVplsName.removeAll(vplsName);
+ /**
+ * Constructs test config service.
+ * Generates an VPLS configuration with sample VPLS configs.
+ */
+ public TestConfigService() {
+ vplsAppConfig = new VplsAppConfig();
+ final ObjectMapper mapper = new ObjectMapper();
+ final ConfigApplyDelegate delegate = new VplsAppConfigTest.MockCfgDelegate();
+ JsonNode tree = null;
+ try {
+ tree = new ObjectMapper().readTree(EMPTY_JSON_TREE);
+ } catch (IOException e) {
+ e.printStackTrace();
}
+ vplsAppConfig.init(APPID, APP_NAME, tree, mapper, delegate);
+ VplsConfig vplsConfig = new VplsConfig(VPLS1,
+ ImmutableSet.of(V100H1.name(), V100H2.name()),
+ EncapsulationType.NONE);
+ vplsAppConfig.addVpls(vplsConfig);
+ vplsConfig = new VplsConfig(VPLS2,
+ ImmutableSet.of(V200H1.name(), V200H2.name()),
+ EncapsulationType.VLAN);
+ vplsAppConfig.addVpls(vplsConfig);
+
+ }
+
+ /**
+ * Overrides VPLS config to the config service.
+ *
+ * @param vplsAppConfig the new VPLS config
+ */
+ public void setConfig(VplsAppConfig vplsAppConfig) {
+ this.vplsAppConfig = vplsAppConfig;
}
@Override
- public void addIface(String vplsName, String iface) {
- if (!ifacesByVplsName.containsKey(vplsName)) {
- AVAILABLE_INTERFACES.forEach(intf -> {
- if (intf.name().equals(iface)) {
- ifacesByVplsName.put(vplsName, intf);
- }
- });
- }
+ public <S, C extends Config<S>> C getConfig(S subject, Class<C> configClass) {
+ return (C) vplsAppConfig;
}
@Override
- public void setEncap(String vplsName, String encap) {
- encapsByVplsName.put(vplsName, EncapsulationType.enumFromString(encap));
- }
-
- @Override
- public void removeIface(String iface) {
- SetMultimap<String, Interface> search = HashMultimap.create(ifacesByVplsName);
- search.entries().forEach(e -> {
- if (e.getValue().name().equals(iface)) {
- ifacesByVplsName.remove(e.getKey(), iface);
- }
- });
- }
-
- @Override
- public void cleanVplsConfig() {
- ifacesByVplsName.clear();
- }
-
- @Override
- public EncapsulationType encap(String vplsName) {
- EncapsulationType encap = null;
- if (encapsByVplsName.containsKey(vplsName)) {
- encap = encapsByVplsName.get(vplsName);
- }
- return encap;
- }
-
- @Override
- public Set<String> vplsAffectedByApi() {
- Set<String> vplsNames = ImmutableSet.copyOf(vplsAffectByApi);
-
- vplsAffectByApi.clear();
-
- return vplsNames;
- }
-
- @Override
- public Set<Interface> allIfaces() {
- return ifacesByVplsName.values()
- .stream()
- .collect(Collectors.toSet());
- }
-
- @Override
- public Set<Interface> ifaces(String name) {
- return ifacesByVplsName.get(name)
- .stream()
- .collect(Collectors.toSet());
- }
-
- @Override
- public Set<String> vplsNames() {
- return ifacesByVplsName.keySet();
- }
-
- @Override
- public Set<String> vplsNamesOld() {
- return ifacesByVplsName.keySet();
- }
-
- public SetMultimap<String, Interface> ifacesByVplsName() {
- return ImmutableSetMultimap.copyOf(ifacesByVplsName);
- }
-
- @Override
- public SetMultimap<String, Interface> ifacesByVplsName(VlanId vlan,
- ConnectPoint connectPoint) {
- String vplsName =
- ifacesByVplsName.entries().stream()
- .filter(e -> e.getValue().connectPoint().equals(connectPoint))
- .filter(e -> e.getValue().vlan().equals(vlan))
- .map(Map.Entry::getKey)
- .findFirst()
- .orElse(null);
- SetMultimap<String, Interface> result = HashMultimap.create();
- if (vplsName != null && ifacesByVplsName.containsKey(vplsName)) {
- ifacesByVplsName.get(vplsName)
- .forEach(intf -> result.put(vplsName, intf));
- return result;
- }
- return null;
+ public <S, C extends Config<S>> C addConfig(S subject, Class<C> configClass) {
+ return (C) vplsAppConfig;
}
}
+
}
diff --git a/apps/vpls/src/test/java/org/onosproject/vpls/cli/VplsCommandTest.java b/apps/vpls/src/test/java/org/onosproject/vpls/cli/VplsCommandTest.java
new file mode 100644
index 0000000..eeff5ef
--- /dev/null
+++ b/apps/vpls/src/test/java/org/onosproject/vpls/cli/VplsCommandTest.java
@@ -0,0 +1,247 @@
+/*
+ * Copyright 2017-present 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.vpls.cli;
+
+import org.junit.Before;
+import org.junit.Test;
+import org.onosproject.net.EncapsulationType;
+import org.onosproject.vpls.VplsTest;
+import org.onosproject.vpls.api.VplsData;
+
+import java.io.ByteArrayOutputStream;
+import java.io.PrintStream;
+import java.util.Collection;
+
+import static org.junit.Assert.*;
+
+/**
+ * Test for {@link VplsCommand}.
+ */
+public class VplsCommandTest extends VplsTest {
+ private static final String NEW_LINE = "\n";
+ private static final String SHOW_ALL_RES = "----------------\n" +
+ "VPLS name: \u001B[1mvpls2\u001B[0m\n" +
+ "Associated interfaces: [v200h2, v200h1]\n" +
+ "Encapsulation: NONE\n" +
+ "State: ADDED\n" +
+ "----------------\n" +
+ "VPLS name: \u001B[1mvpls1\u001B[0m\n" +
+ "Associated interfaces: [v100h1, v100h2]\n" +
+ "Encapsulation: NONE\n" +
+ "State: ADDED\n" +
+ "----------------\n";
+ private static final String SHOW_ONE_RES = "VPLS name: \u001B[1mvpls1\u001B[0m\n" +
+ "Associated interfaces: [v100h1, v100h2]\n" +
+ "Encapsulation: NONE\n" +
+ "State: ADDED\n";
+ private static final String IFACE_ALREADY_USED =
+ "\u001B[31mInterface \u001B[1mv200h1\u001B[0m\u001B[31m already associated " +
+ "to VPLS \u001B[1mvpls2\u001B[0m\u001B[31m\u001B[0m\n";
+ private static final String LIST_OUTPUT = VPLS1 + NEW_LINE + VPLS2 + NEW_LINE;
+ VplsCommand vplsCommand;
+
+ @Before
+ public void setup() {
+ vplsCommand = new VplsCommand();
+ vplsCommand.vpls = new TestVpls();
+ vplsCommand.interfaceService = new TestInterfaceService();
+ }
+
+ /**
+ * Creates a new VPLS.
+ */
+ @Test
+ public void testCreate() {
+ vplsCommand.command = VplsCommandEnum.CREATE.toString();
+ vplsCommand.vplsName = VPLS1;
+ vplsCommand.execute();
+ Collection<VplsData> vplss = vplsCommand.vpls.getAllVpls();
+ assertEquals(1, vplss.size());
+ VplsData result = vplss.iterator().next();
+ VplsData expected = VplsData.of(VPLS1, EncapsulationType.NONE);
+ assertEquals(expected, result);
+ }
+
+ /**
+ * Adds new network interface to a VPLS.
+ */
+ @Test
+ public void testAddIf() {
+ vplsCommand.create(VPLS1);
+
+ vplsCommand.command = VplsCommandEnum.ADD_IFACE.toString();
+ vplsCommand.vplsName = VPLS1;
+ vplsCommand.optArg = V100H1.name();
+ vplsCommand.execute();
+
+ vplsCommand.command = VplsCommandEnum.ADD_IFACE.toString();
+ vplsCommand.vplsName = VPLS1;
+ vplsCommand.optArg = V200H1.name();
+ vplsCommand.execute();
+
+ Collection<VplsData> vplss = vplsCommand.vpls.getAllVpls();
+ assertEquals(1, vplss.size());
+ VplsData result = vplss.iterator().next();
+ assertEquals(2, result.interfaces().size());
+ assertTrue(result.interfaces().contains(V100H1));
+ assertTrue(result.interfaces().contains(V200H1));
+ }
+
+ /**
+ * Removes network interface from a VPLS.
+ */
+ @Test
+ public void testRemIf() {
+ vplsCommand.create(VPLS1);
+ vplsCommand.addIface(VPLS1, V100H1.name());
+ vplsCommand.addIface(VPLS1, V200H1.name());
+
+ vplsCommand.command = VplsCommandEnum.REMOVE_IFACE.toString();
+ vplsCommand.vplsName = VPLS1;
+ vplsCommand.optArg = V200H1.name();
+ vplsCommand.execute();
+
+ Collection<VplsData> vplss = vplsCommand.vpls.getAllVpls();
+ assertEquals(1, vplss.size());
+ VplsData result = vplss.iterator().next();
+ assertEquals(1, result.interfaces().size());
+ assertTrue(result.interfaces().contains(V100H1));
+ assertFalse(result.interfaces().contains(V200H1));
+ }
+
+ /**
+ * Lists all VPLS names.
+ */
+ @Test
+ public void testList() {
+ ((TestVpls) vplsCommand.vpls).initSampleData();
+ ByteArrayOutputStream baos = new ByteArrayOutputStream();
+ PrintStream ps = new PrintStream(baos);
+ System.setOut(ps);
+ vplsCommand.command = VplsCommandEnum.LIST.toString();
+ vplsCommand.execute();
+ String result = baos.toString();
+
+ assertEquals(LIST_OUTPUT, result);
+ }
+
+ /**
+ * Sets encapsulation to a VPLS.
+ */
+ @Test
+ public void testSetEncap() {
+ ((TestVpls) vplsCommand.vpls).initSampleData();
+
+ // Sets to NONE
+ vplsCommand.command = VplsCommandEnum.SET_ENCAP.toString();
+ vplsCommand.vplsName = VPLS1;
+ vplsCommand.optArg = EncapsulationType.NONE.name();
+ vplsCommand.execute();
+ VplsData result = vplsCommand.vpls.getVpls(VPLS1);
+ assertEquals(result.encapsulationType(), EncapsulationType.NONE);
+
+ // Sets to VLAN
+ vplsCommand.command = VplsCommandEnum.SET_ENCAP.toString();
+ vplsCommand.vplsName = VPLS1;
+ vplsCommand.optArg = EncapsulationType.VLAN.name();
+ vplsCommand.execute();
+ result = vplsCommand.vpls.getVpls(VPLS1);
+ assertEquals(result.encapsulationType(), EncapsulationType.VLAN);
+
+ // Sets to MPLS
+ vplsCommand.command = VplsCommandEnum.SET_ENCAP.toString();
+ vplsCommand.vplsName = VPLS1;
+ vplsCommand.optArg = EncapsulationType.MPLS.name();
+ vplsCommand.execute();
+ result = vplsCommand.vpls.getVpls(VPLS1);
+ assertEquals(result.encapsulationType(), EncapsulationType.MPLS);
+ }
+
+ /**
+ * Deletes a VPLS.
+ */
+ @Test
+ public void testDelete() {
+ ((TestVpls) vplsCommand.vpls).initSampleData();
+ vplsCommand.command = VplsCommandEnum.DELETE.toString();
+ vplsCommand.vplsName = VPLS1;
+ vplsCommand.execute();
+ Collection<VplsData> vplss = vplsCommand.vpls.getAllVpls();
+ assertEquals(1, vplss.size());
+ }
+
+ /**
+ * Shows all VPLS information.
+ */
+ @Test
+ public void testShowAll() {
+ ((TestVpls) vplsCommand.vpls).initSampleData();
+ ByteArrayOutputStream baos = new ByteArrayOutputStream();
+ PrintStream ps = new PrintStream(baos);
+ System.setOut(ps);
+ vplsCommand.command = VplsCommandEnum.SHOW.toString();
+ vplsCommand.execute();
+ String result = baos.toString();
+ assertEquals(SHOW_ALL_RES, result);
+ }
+
+ /**
+ * Shows a VPLS information.
+ */
+ @Test
+ public void testShowOne() {
+ ((TestVpls) vplsCommand.vpls).initSampleData();
+ ByteArrayOutputStream baos = new ByteArrayOutputStream();
+ PrintStream ps = new PrintStream(baos);
+ System.setOut(ps);
+ vplsCommand.command = VplsCommandEnum.SHOW.toString();
+ vplsCommand.vplsName = VPLS1;
+ vplsCommand.execute();
+ String result = baos.toString();
+ assertEquals(SHOW_ONE_RES, result);
+ }
+
+ /**
+ * Adds a network interface which already related to another VPLS to a VPLS.
+ */
+ @Test
+ public void testIfaceAssociated() {
+ ((TestVpls) vplsCommand.vpls).initSampleData();
+ ByteArrayOutputStream baos = new ByteArrayOutputStream();
+ PrintStream ps = new PrintStream(baos);
+ System.setOut(ps);
+ vplsCommand.command = VplsCommandEnum.ADD_IFACE.toString();
+ vplsCommand.vplsName = VPLS1;
+ vplsCommand.optArg = V200H1.name();
+ vplsCommand.execute();
+
+ String result = baos.toString();
+ assertEquals(IFACE_ALREADY_USED, result);
+ }
+
+ /**
+ * Removes all VPLS.
+ */
+ @Test
+ public void testClean() {
+ ((TestVpls) vplsCommand.vpls).initSampleData();
+ vplsCommand.command = VplsCommandEnum.CLEAN.toString();
+ vplsCommand.execute();
+ Collection<VplsData> vplss = vplsCommand.vpls.getAllVpls();
+ assertEquals(0, vplss.size());
+ }
+}
diff --git a/apps/vpls/src/test/java/org/onosproject/vpls/cli/completer/VplsCommandCompleterTest.java b/apps/vpls/src/test/java/org/onosproject/vpls/cli/completer/VplsCommandCompleterTest.java
new file mode 100644
index 0000000..90d48df
--- /dev/null
+++ b/apps/vpls/src/test/java/org/onosproject/vpls/cli/completer/VplsCommandCompleterTest.java
@@ -0,0 +1,188 @@
+/*
+ * Copyright 2017-present 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.vpls.cli.completer;
+
+import com.google.common.collect.ImmutableList;
+import org.apache.felix.service.command.CommandSession;
+import org.apache.karaf.shell.console.CommandSessionHolder;
+import org.apache.karaf.shell.console.completer.ArgumentCompleter;
+import org.junit.Before;
+import org.junit.Test;
+import org.onosproject.incubator.net.intf.Interface;
+import org.onosproject.net.EncapsulationType;
+import org.onosproject.vpls.VplsTest;
+import org.onosproject.vpls.cli.VplsCommandEnum;
+
+import java.io.InputStream;
+import java.io.PrintStream;
+import java.util.Arrays;
+import java.util.List;
+import java.util.stream.Collectors;
+
+import static org.junit.Assert.*;
+
+public class VplsCommandCompleterTest extends VplsTest {
+ private static final String VPLS_CMD = "vpls";
+ private TestCommandSession commandSession;
+
+ @Before
+ public void setup() {
+ commandSession = new TestCommandSession();
+ CommandSessionHolder.setSession(commandSession);
+ }
+
+ /**
+ * Test VPLS command completer.
+ */
+ @Test
+ public void testCommandCompleter() {
+ VplsCommandCompleter commandCompleter = new VplsCommandCompleter();
+ List<String> choices = commandCompleter.choices();
+ List<String> expected = VplsCommandEnum.toStringList();
+ assertEquals(expected, choices);
+ }
+
+ /**
+ * Test VPLS name completer.
+ */
+ @Test
+ public void testNameCompleter() {
+ VplsNameCompleter vplsNameCompleter = new VplsNameCompleter();
+ vplsNameCompleter.vpls = new TestVpls();
+ ((TestVpls) vplsNameCompleter.vpls).initSampleData();
+ List<String> choices = vplsNameCompleter.choices();
+ List<String> expected = ImmutableList.of(VPLS1, VPLS2);
+
+ // Can not ensure the order, use contains all instead of equals
+ assertEquals(choices.size(), expected.size());
+ assertTrue(choices.containsAll(expected));
+ }
+
+ /**
+ * Test VPLS option arguments completer.
+ */
+ @Test
+ public void testOptArgCompleter() {
+ VplsOptArgCompleter completer = new VplsOptArgCompleter();
+ completer.vpls = new TestVpls();
+ ((TestVpls) completer.vpls).initSampleData();
+ completer.interfaceService = new TestInterfaceService();
+
+ // Add interface to VPLS
+ commandSession.updateArguments(VPLS_CMD, VplsCommandEnum.ADD_IFACE.toString(), VPLS1);
+
+ List<String> choices = completer.choices();
+ List<String> expected = ImmutableList.of(V300H1.name(),
+ V300H2.name(),
+ V400H1.name(),
+ VNONEH1.name(),
+ VNONEH2.name(),
+ VNONEH3.name());
+
+ // Can not ensure the order, use contains all instead of equals
+ assertEquals(choices.size(), expected.size());
+ assertTrue(choices.containsAll(expected));
+
+ // Removes interface from VPLS
+ commandSession.updateArguments(VPLS_CMD, VplsCommandEnum.REMOVE_IFACE.toString(), VPLS1);
+ choices = completer.choices();
+ expected = completer.vpls.getVpls(VPLS1).interfaces().stream()
+ .map(Interface::name)
+ .collect(Collectors.toList());
+
+ // Can not ensure the order, use contains all instead of equals
+ assertEquals(choices.size(), expected.size());
+ assertTrue(choices.containsAll(expected));
+
+ // Sets encapsulation
+ commandSession.updateArguments(VPLS_CMD, VplsCommandEnum.SET_ENCAP.toString(), VPLS1);
+ choices = completer.choices();
+ expected = Arrays.stream(EncapsulationType.values())
+ .map(Enum::toString)
+ .collect(Collectors.toList());
+
+ // Can not ensure the order, use contains all instead of equals
+ assertEquals(choices.size(), expected.size());
+ assertTrue(choices.containsAll(expected));
+ }
+
+ /**
+ * Test command session.
+ */
+ class TestCommandSession implements CommandSession {
+ ArgumentCompleter.ArgumentList argumentList;
+ public TestCommandSession() {
+ String[] emptyStringArr = new String[0];
+ argumentList = new ArgumentCompleter.ArgumentList(emptyStringArr,
+ 0,
+ 0,
+ 0);
+ }
+
+ /**
+ * Updates argument list for the command session.
+ *
+ * @param args new arguments
+ */
+ public void updateArguments(String... args) {
+ argumentList = new ArgumentCompleter.ArgumentList(args,
+ 0,
+ 0,
+ 0);
+ }
+
+ @Override
+ public Object execute(CharSequence charSequence) throws Exception {
+ return null;
+ }
+
+ @Override
+ public void close() {
+
+ }
+
+ @Override
+ public InputStream getKeyboard() {
+ return null;
+ }
+
+ @Override
+ public PrintStream getConsole() {
+ return null;
+ }
+
+ @Override
+ public Object get(String s) {
+ return argumentList;
+ }
+
+ @Override
+ public void put(String s, Object o) {
+
+ }
+
+ @Override
+ public CharSequence format(Object o, int i) {
+ return null;
+ }
+
+ @Override
+ public Object convert(Class<?> aClass, Object o) {
+ return null;
+ }
+ }
+}
diff --git a/apps/vpls/src/test/java/org/onosproject/vpls/config/VplsAppConfigTest.java b/apps/vpls/src/test/java/org/onosproject/vpls/config/VplsAppConfigTest.java
index b3ca89d..37e7598 100644
--- a/apps/vpls/src/test/java/org/onosproject/vpls/config/VplsAppConfigTest.java
+++ b/apps/vpls/src/test/java/org/onosproject/vpls/config/VplsAppConfigTest.java
@@ -246,19 +246,28 @@
vplsAppConfig.getVplsWithName(VPLS1).encap());
}
- private class MockCfgDelegate implements ConfigApplyDelegate {
-
+ public static class MockCfgDelegate implements ConfigApplyDelegate {
@Override
public void onApply(@SuppressWarnings("rawtypes") Config config) {
config.apply();
}
}
+ /**
+ * Creates a basic VPLS config.
+ *
+ * @return the VPLS config
+ */
private VplsConfig createInitialVpls() {
Set<String> ifaces = new HashSet<>(Arrays.asList(IF1, IF2, IF3));
return new VplsConfig(VPLS1, ifaces, EncapsulationType.NONE);
}
+ /**
+ * Creates another basic VPLS config.
+ *
+ * @return the VPLS config
+ */
private VplsConfig createNewVpls() {
Set<String> ifaces = new HashSet<>(Arrays.asList(IF4, IF5));
return new VplsConfig(NEWVPLS, ifaces, EncapsulationType.NONE);
diff --git a/apps/vpls/src/test/java/org/onosproject/vpls/config/VplsConfigManagerTest.java b/apps/vpls/src/test/java/org/onosproject/vpls/config/VplsConfigManagerTest.java
new file mode 100644
index 0000000..8baae6c
--- /dev/null
+++ b/apps/vpls/src/test/java/org/onosproject/vpls/config/VplsConfigManagerTest.java
@@ -0,0 +1,146 @@
+/*
+ * Copyright 2017-present 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.vpls.config;
+
+import com.fasterxml.jackson.databind.JsonNode;
+import com.fasterxml.jackson.databind.ObjectMapper;
+import com.google.common.collect.ImmutableSet;
+import org.junit.After;
+import org.junit.Before;
+import org.junit.Test;
+import org.onosproject.net.EncapsulationType;
+import org.onosproject.net.config.ConfigApplyDelegate;
+import org.onosproject.net.config.NetworkConfigEvent;
+import org.onosproject.net.config.NetworkConfigRegistryAdapter;
+import org.onosproject.vpls.VplsTest;
+import org.onosproject.vpls.api.VplsData;
+
+import java.io.IOException;
+import java.util.Collection;
+
+import static org.junit.Assert.*;
+public class VplsConfigManagerTest extends VplsTest {
+ VplsConfigManager vplsConfigManager;
+
+ @Before
+ public void setup() {
+ vplsConfigManager = new VplsConfigManager();
+ vplsConfigManager.configService = new TestConfigService();
+ vplsConfigManager.coreService = new TestCoreService();
+ vplsConfigManager.interfaceService = new TestInterfaceService();
+ vplsConfigManager.registry = new NetworkConfigRegistryAdapter();
+ vplsConfigManager.vpls = new TestVpls();
+ vplsConfigManager.leadershipService = new TestLeadershipService();
+
+ vplsConfigManager.activate();
+ }
+
+ @After
+ public void tearDown() {
+ vplsConfigManager.deactivate();
+ }
+
+ /**
+ * Reloads network configuration by sending a network config event.
+ */
+ @Test
+ public void testReloadConfig() {
+ NetworkConfigEvent event = new NetworkConfigEvent(NetworkConfigEvent.Type.CONFIG_ADDED,
+ null,
+ VplsAppConfig.class);
+ ((TestConfigService) vplsConfigManager.configService).sendEvent(event);
+
+ Collection<VplsData> vplss = vplsConfigManager.vpls.getAllVpls();
+ assertEquals(2, vplss.size());
+
+ VplsData expect = VplsData.of(VPLS1);
+ expect.addInterfaces(ImmutableSet.of(V100H1, V100H2));
+ expect.state(VplsData.VplsState.ADDED);
+ assertTrue(vplss.contains(expect));
+
+ expect = VplsData.of(VPLS2, EncapsulationType.VLAN);
+ expect.addInterfaces(ImmutableSet.of(V200H1, V200H2));
+ expect.state(VplsData.VplsState.ADDED);
+ System.out.println(vplss);
+ assertTrue(vplss.contains(expect));
+ }
+
+ /**
+ * Sends a network config event with null network config.
+ */
+ @Test
+ public void testReloadNullConfig() {
+ ((TestConfigService) vplsConfigManager.configService).setConfig(null);
+ NetworkConfigEvent event = new NetworkConfigEvent(NetworkConfigEvent.Type.CONFIG_ADDED,
+ null,
+ VplsAppConfig.class);
+ ((TestConfigService) vplsConfigManager.configService).sendEvent(event);
+
+ Collection<VplsData> vplss = vplsConfigManager.vpls.getAllVpls();
+ assertEquals(0, vplss.size());
+ }
+
+ /**
+ * Updates VPLSs by sending new VPLS config.
+ */
+ @Test
+ public void testReloadConfigUpdateVpls() {
+ ((TestVpls) vplsConfigManager.vpls).initSampleData();
+
+ VplsAppConfig vplsAppConfig = new VplsAppConfig();
+ final ObjectMapper mapper = new ObjectMapper();
+ final ConfigApplyDelegate delegate = new VplsAppConfigTest.MockCfgDelegate();
+ JsonNode tree = null;
+ try {
+ tree = new ObjectMapper().readTree(TestConfigService.EMPTY_JSON_TREE);
+ } catch (IOException e) {
+ e.printStackTrace();
+ }
+ vplsAppConfig.init(APPID, APP_NAME, tree, mapper, delegate);
+ VplsConfig vplsConfig = new VplsConfig(VPLS1,
+ ImmutableSet.of(V100H1.name()),
+ EncapsulationType.MPLS);
+ vplsAppConfig.addVpls(vplsConfig);
+ ((TestConfigService) vplsConfigManager.configService).setConfig(vplsAppConfig);
+ NetworkConfigEvent event = new NetworkConfigEvent(NetworkConfigEvent.Type.CONFIG_ADDED,
+ null,
+ VplsAppConfig.class);
+ ((TestConfigService) vplsConfigManager.configService).sendEvent(event);
+
+ Collection<VplsData> vplss = vplsConfigManager.vpls.getAllVpls();
+ assertEquals(1, vplss.size());
+
+ VplsData expect = VplsData.of(VPLS1, EncapsulationType.MPLS);
+ expect.addInterfaces(ImmutableSet.of(V100H1));
+ expect.state(VplsData.VplsState.ADDED);
+ assertTrue(vplss.contains(expect));
+ }
+
+ /**
+ * Remvoes all VPLS by sending CONFIG_REMOVED event.
+ */
+ @Test
+ public void testRemoveConfig() {
+ NetworkConfigEvent event = new NetworkConfigEvent(NetworkConfigEvent.Type.CONFIG_REMOVED,
+ null,
+ VplsAppConfig.class);
+ ((TestConfigService) vplsConfigManager.configService).sendEvent(event);
+
+ Collection<VplsData> vplss = vplsConfigManager.vpls.getAllVpls();
+ assertEquals(0, vplss.size());
+ }
+}
diff --git a/apps/vpls/src/test/java/org/onosproject/vpls/store/VplsStoreAdapter.java b/apps/vpls/src/test/java/org/onosproject/vpls/store/VplsStoreAdapter.java
new file mode 100644
index 0000000..bcc70af
--- /dev/null
+++ b/apps/vpls/src/test/java/org/onosproject/vpls/store/VplsStoreAdapter.java
@@ -0,0 +1,76 @@
+/*
+ * Copyright 2017-present 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.vpls.store;
+
+import com.google.common.collect.Maps;
+import org.onosproject.store.StoreDelegate;
+import org.onosproject.vpls.api.VplsData;
+import org.onosproject.vpls.api.VplsStore;
+
+import java.util.Collection;
+import java.util.Map;
+
+/**
+ * Test adapter for VPLS store.
+ */
+public class VplsStoreAdapter implements VplsStore {
+ protected Map<String, VplsData> vplsDataMap;
+ protected StoreDelegate<VplsStoreEvent> delegate;
+
+ public VplsStoreAdapter() {
+ vplsDataMap = Maps.newHashMap();
+ }
+
+ @Override
+ public void setDelegate(StoreDelegate<VplsStoreEvent> delegate) {
+ this.delegate = delegate;
+ }
+
+ @Override
+ public void unsetDelegate(StoreDelegate<VplsStoreEvent> delegate) {
+ this.delegate = null;
+ }
+
+ @Override
+ public boolean hasDelegate() {
+ return this.delegate != null;
+ }
+
+ @Override
+ public void addVpls(VplsData vplsData) {
+ vplsDataMap.put(vplsData.name(), vplsData);
+ }
+
+ @Override
+ public void removeVpls(VplsData vplsData) {
+ vplsDataMap.remove(vplsData.name());
+ }
+
+ @Override
+ public void updateVpls(VplsData vplsData) {
+ vplsDataMap.put(vplsData.name(), vplsData);
+ }
+
+ @Override
+ public VplsData getVpls(String vplsName) {
+ return vplsDataMap.get(vplsName);
+ }
+
+ @Override
+ public Collection<VplsData> getAllVpls() {
+ return vplsDataMap.values();
+ }
+}
diff --git a/apps/vpls/src/test/java/org/onosproject/vpls/store/VplsStoreTest.java b/apps/vpls/src/test/java/org/onosproject/vpls/store/VplsStoreTest.java
new file mode 100644
index 0000000..31a2176
--- /dev/null
+++ b/apps/vpls/src/test/java/org/onosproject/vpls/store/VplsStoreTest.java
@@ -0,0 +1,129 @@
+/*
+ * Copyright 2017-present 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.vpls.store;
+
+import org.junit.After;
+import org.junit.Before;
+import org.junit.Test;
+import org.onosproject.store.service.TestStorageService;
+import org.onosproject.vpls.VplsTest;
+import org.onosproject.vpls.api.VplsData;
+import org.onosproject.vpls.config.VplsAppConfig;
+import org.onosproject.vpls.config.VplsConfig;
+
+import java.util.Collection;
+
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertNotEquals;
+import static org.junit.Assert.assertTrue;
+import static org.onosproject.net.EncapsulationType.VLAN;
+
+public class VplsStoreTest extends VplsTest {
+ private DistributedVplsStore vplsStore;
+
+ @Before
+ public void setup() {
+ vplsStore = new DistributedVplsStore();
+ vplsStore.coreService = new TestCoreService();
+ vplsStore.storageService = new TestStorageService();
+ vplsStore.networkConfigService = new TestConfigService();
+ vplsStore.active();
+ }
+
+ @After
+ public void tearDown() {
+ vplsStore.deactive();
+ }
+
+ /**
+ * Adds a VPLS to the store; checks if config store is also updated.
+ */
+ @Test
+ public void testAddVpls() {
+ VplsData vplsData = VplsData.of(VPLS1, VLAN);
+ vplsStore.addVpls(vplsData);
+ Collection<VplsData> vplsDataCollection = vplsStore.getAllVpls();
+
+ assertEquals(1, vplsDataCollection.size());
+ assertTrue(vplsDataCollection.contains(vplsData));
+
+ VplsAppConfig storedConfig = vplsStore.networkConfigService
+ .getConfig(null, VplsAppConfig.class);
+ assertNotEquals(-1L, storedConfig.updateTime());
+
+ assertEquals(1, storedConfig.vplss().size());
+
+ VplsConfig vplsConfig = storedConfig.vplss().iterator().next();
+
+ assertEquals(VPLS1, vplsConfig.name());
+ assertEquals(0, vplsConfig.ifaces().size());
+ assertEquals(VLAN, vplsConfig.encap());
+ }
+
+ /**
+ * Removes a VPLS from store; checks if config store is also updated.
+ */
+ @Test
+ public void testRemoveVpls() {
+ VplsData vplsData = VplsData.of(VPLS1, VLAN);
+ vplsStore.addVpls(vplsData);
+ vplsStore.removeVpls(vplsData);
+
+ Collection<VplsData> vplsDataCollection = vplsStore.getAllVpls();
+ assertEquals(0, vplsDataCollection.size());
+
+ VplsAppConfig storedConfig = vplsStore.networkConfigService
+ .getConfig(null, VplsAppConfig.class);
+
+ assertNotEquals(-1L, storedConfig.updateTime());
+
+ assertEquals(0, storedConfig.vplss().size());
+ }
+
+ /**
+ * Updates a VPLS from store; checks if config store is also updated.
+ */
+ @Test
+ public void testUpdateVpls() {
+ VplsData vplsData = VplsData.of(VPLS1, VLAN);
+ vplsStore.addVpls(vplsData);
+ vplsData.addInterface(V100H1);
+ vplsData.addInterface(V100H2);
+ vplsStore.updateVpls(vplsData);
+
+ Collection<VplsData> vplsDataCollection = vplsStore.getAllVpls();
+ assertEquals(1, vplsDataCollection.size());
+ VplsData newVplsData = vplsDataCollection.iterator().next();
+
+ assertEquals(vplsData, newVplsData);
+
+ VplsAppConfig storedConfig = vplsStore.networkConfigService
+ .getConfig(null, VplsAppConfig.class);
+
+ assertNotEquals(-1L, storedConfig.updateTime());
+
+ assertEquals(1, storedConfig.vplss().size());
+
+ VplsConfig vplsConfig = storedConfig.vplss().iterator().next();
+
+ assertEquals(VPLS1, vplsConfig.name());
+ assertEquals(2, vplsConfig.ifaces().size());
+ assertTrue(vplsConfig.ifaces().contains(V100H1.name()));
+ assertTrue(vplsConfig.ifaces().contains(V100H2.name()));
+ assertEquals(VLAN, vplsConfig.encap());
+ }
+}