xtend-gen
classes
out/
+.externalToolBuilders
+maven-eclipse.xml
byte[] targetIP = tIP.getAddress();
ARP arp = createARP(ARP.REPLY, sMAC, senderIP, tMAC, targetIP);
+ if(log.isTraceEnabled()) {
+ log.trace("Sending Arp Reply with srcMac {} - srcIp {} - dstMac {} - dstIp {} - outport {}",
+ HexEncode.bytesToHexString(sMAC),
+ sIP, HexEncode.bytesToHexString(tMAC), tIP, p);
+ }
+
Ethernet ethernet = createEthernet(sMAC, tMAC, arp);
RawPacket destPkt = this.dataPacketService.encodeDataPacket(ethernet);
this.dataPacketService.transmitDataPacket(destPkt);
}
+ private void logArpPacket(ARP pkt, NodeConnector p) {
+ try {
+ if (pkt.getOpCode() == ARP.REQUEST) {
+ log.trace("Received Arp Request with srcMac {} - srcIp {} - dstMac {} - dstIp {} - inport {}", HexEncode.bytesToHexString(pkt.getSenderHardwareAddress()),
+ InetAddress.getByAddress(pkt.getSenderProtocolAddress()), HexEncode.bytesToHexString(pkt.getTargetHardwareAddress()),
+ InetAddress.getByAddress(pkt.getTargetProtocolAddress()), p);
+ } else if(pkt.getOpCode() == ARP.REPLY) {
+ log.trace("Received Arp Reply with srcMac {} - srcIp {} - dstMac {} - dstIp {} - inport {}", HexEncode.bytesToHexString(pkt.getSenderHardwareAddress()),
+ InetAddress.getByAddress(pkt.getSenderProtocolAddress()), HexEncode.bytesToHexString(pkt.getTargetHardwareAddress()),
+ InetAddress.getByAddress(pkt.getTargetProtocolAddress()), p);
+ }
+ } catch(UnknownHostException e) {
+ log.warn("Illegal Ip Address in the ARP packet", e);
+ }
+ }
+
protected void handleARPPacket(Ethernet eHeader, ARP pkt, NodeConnector p) {
+ if(log.isTraceEnabled()) {
+ logArpPacket(pkt, p);
+ }
+
byte[] sourceMAC = eHeader.getSourceMACAddress();
byte[] targetMAC = eHeader.getDestinationMACAddress();
/*
byte[] targetIPByte = targetIP.getAddress();
ARP arp = createARP(ARP.REQUEST, getControllerMAC(), senderIP, targetHardwareAddress, targetIPByte);
+ if(log.isTraceEnabled()) {
+ log.trace("Sending Broadcast Arp Request with srcMac {} - srcIp {} - dstMac {} - dstIp {} - outport {}", HexEncode.bytesToHexString(getControllerMAC()),
+ subnet.getNetworkAddress(), HexEncode.bytesToHexString(targetHardwareAddress), targetIP, p);
+ }
+
byte[] destMACAddress = NetUtils.getBroadcastMACAddr();
Ethernet ethernet = createEthernet(getControllerMAC(), destMACAddress, arp);
byte[] targetMAC = host.getDataLayerAddressBytes();
ARP arp = createARP(ARP.REQUEST, getControllerMAC(), senderIP, targetMAC, targetIP);
+ if(log.isTraceEnabled()) {
+ log.trace("Sending Unicast Arp Request with srcMac {} - srcIp {} - dstMac {} - dstIp {} - outport {}",
+ HexEncode.bytesToHexString(getControllerMAC()),
+ subnet.getNetworkAddress(), HexEncode.bytesToHexString(targetMAC), host.getNetworkAddress(),
+ outPort);
+ }
+
Ethernet ethernet = createEthernet(getControllerMAC(), targetMAC, arp);
RawPacket destPkt = this.dataPacketService.encodeDataPacket(ethernet);
package org.opendaylight.controller.clustering.services_implementation.internal;
import java.util.Map;
+
import org.opendaylight.controller.clustering.services.ICacheUpdateAware;
import org.opendaylight.controller.clustering.services.IClusterGlobalServices;
import org.slf4j.Logger;
@Override
void setCacheUpdateAware(Map props, ICacheUpdateAware s) {
- logger.trace("setCacheUpdateAware");
+ logger.trace("setCacheUpdateAware: {}",s);
if (props.get("containerName") != null) {
// If we got a reference with the containerName property
// that is not what we are looking for, so filter it out.
@Override
void unsetCacheUpdateAware(Map props, ICacheUpdateAware s) {
- logger.trace("unsetCacheUpdateAware");
+ logger.trace("unsetCacheUpdateAware: {}",s);
if (props.get("containerName") != null) {
// If we got a reference with the containerName property
// that is not what we are looking for, so filter it out.
* export the interface ICoordinatorChangeAware
*/
class ListenCoordinatorChange implements IListenRoleChange {
+ @Override
public void newActiveAvailable() {
if (coordinatorChangeAware != null) {
// Make sure to look the set while walking it
logger.trace("cachenames provided below:");
for (String cache : caches) {
if (this.cacheUpdateAware.get(cache) != null) {
- logger.error("cachename:{} on container:{} has " +
- "already a listener", cache,
- this.containerName);
+ logger.error("cachename:{} on container:{} has already a listener", cache, this.containerName);
} else {
- GetUpdatesContainer<?, ?> up =
- new GetUpdatesContainer(s, this.containerName,
- cache);
+ GetUpdatesContainer<?, ?> up = new GetUpdatesContainer(s, this.containerName, cache);
if (up != null) {
try {
this.clusterService.addListener(this.containerName,
"been registered", cache,
this.containerName);
} catch (CacheListenerAddException exc) {
+ logger.debug("Cache {} didn't exist when {} tried to register to its updates", cache, s);
// Do nothing, the important is that
// we don't register the listener in
// the shadow, and we are not doing
import org.opendaylight.controller.config.manager.impl.osgi.mapping.ModuleInfoBundleTracker;
import org.opendaylight.controller.config.manager.impl.osgi.mapping.RuntimeGeneratedMappingServiceActivator;
import org.opendaylight.controller.config.spi.ModuleFactory;
-import org.opendaylight.yangtools.concepts.Registration;
+import org.opendaylight.yangtools.concepts.ObjectRegistration;
import org.opendaylight.yangtools.yang.binding.YangModuleInfo;
import org.opendaylight.yangtools.yang.data.impl.codec.CodecRegistry;
import org.osgi.framework.BundleActivator;
public class ConfigManagerActivator implements BundleActivator {
private static final Logger logger = LoggerFactory.getLogger(ConfigManagerActivator.class);
- private ExtensibleBundleTracker<Collection<Registration<YangModuleInfo>>> bundleTracker;
+ private final MBeanServer configMBeanServer = ManagementFactory.getPlatformMBeanServer();
+ private ExtensibleBundleTracker<Collection<ObjectRegistration<YangModuleInfo>>> bundleTracker;
private ConfigRegistryImpl configRegistry;
private ConfigRegistryJMXRegistrator configRegistryJMXRegistrator;
private ServiceRegistration<?> configRegistryServiceRegistration;
-
- private final MBeanServer configMBeanServer = ManagementFactory.getPlatformMBeanServer();
-
private RuntimeGeneratedMappingServiceActivator mappingServiceActivator;
@Override
*/
package org.opendaylight.controller.config.manager.impl.osgi.mapping;
+import static java.lang.String.format;
+
+import java.io.InputStream;
+import java.net.URL;
+import java.util.Collection;
+import java.util.LinkedList;
+import java.util.List;
+
import org.apache.commons.io.IOUtils;
-import org.opendaylight.yangtools.concepts.Registration;
+import org.opendaylight.yangtools.concepts.ObjectRegistration;
import org.opendaylight.yangtools.sal.binding.generator.impl.GeneratedClassLoadingStrategy;
import org.opendaylight.yangtools.sal.binding.generator.impl.ModuleInfoBackedContext;
import org.opendaylight.yangtools.yang.binding.YangModelBindingProvider;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
-import java.io.InputStream;
-import java.net.URL;
-import java.util.Collection;
-import java.util.LinkedList;
-import java.util.List;
-
-import static java.lang.String.format;
-
/**
* Tracks bundles and attempts to retrieve YangModuleInfo.
*/
-public final class ModuleInfoBundleTracker implements BundleTrackerCustomizer<Collection<Registration<YangModuleInfo>>> {
+public final class ModuleInfoBundleTracker implements BundleTrackerCustomizer<Collection<ObjectRegistration<YangModuleInfo>>> {
private static final Logger logger = LoggerFactory.getLogger(ModuleInfoBundleTracker.class);
public static final String GET_MODULE_INFO_METHOD = "getModuleInfo";
public static final String MODULE_INFO_PROVIDER_PATH_PREFIX = "META-INF/services/";
- private ModuleInfoBackedContext moduleInfoLoadingStrategy = ModuleInfoBackedContext.create();
+ private final ModuleInfoBackedContext moduleInfoLoadingStrategy = ModuleInfoBackedContext.create();
public GeneratedClassLoadingStrategy getModuleInfoLoadingStrategy() {
return moduleInfoLoadingStrategy;
}
@Override
- public Collection<Registration<YangModuleInfo>> addingBundle(Bundle bundle, BundleEvent event) {
+ public Collection<ObjectRegistration<YangModuleInfo>> addingBundle(Bundle bundle, BundleEvent event) {
URL resource = bundle.getEntry(MODULE_INFO_PROVIDER_PATH_PREFIX + YangModelBindingProvider.class.getName());
if(resource==null) {
return null;
}
- List<Registration<YangModuleInfo>> registrations = new LinkedList<>();
+ List<ObjectRegistration<YangModuleInfo>> registrations = new LinkedList<>();
try (InputStream inputStream = resource.openStream()) {
List<String> lines = IOUtils.readLines(inputStream);
}
@Override
- public void modifiedBundle(Bundle bundle, BundleEvent event, Collection<Registration<YangModuleInfo>> object) {
+ public void modifiedBundle(Bundle bundle, BundleEvent event, Collection<ObjectRegistration<YangModuleInfo>> object) {
// NOOP
}
@Override
- public void removedBundle(Bundle bundle, BundleEvent event, Collection<Registration<YangModuleInfo>> regs) {
+ public void removedBundle(Bundle bundle, BundleEvent event, Collection<ObjectRegistration<YangModuleInfo>> regs) {
if(regs == null) {
return;
}
- for (Registration<YangModuleInfo> reg : regs) {
+ for (ObjectRegistration<YangModuleInfo> reg : regs) {
try {
reg.close();
} catch (Exception e) {
private void assertSnapshot(ConfigSnapshotHolder result, String directory) throws Exception {
SortedSet<String> expectedCapabilities = new TreeSet<>(IOUtils.readLines(getClass().getResourceAsStream("/" + directory + "/expectedCapabilities.txt")));
String expectedSnapshot = IOUtils.toString(getClass().getResourceAsStream("/" + directory + "/expectedSnapshot.xml"));
+ expectedSnapshot = expectedSnapshot.replaceAll("\r","");
+ String _snapshot = result.getConfigSnapshot();
+ _snapshot = _snapshot.replaceAll("\r","");
assertEquals(expectedCapabilities, result.getCapabilities());
- assertEquals(expectedSnapshot, result.getConfigSnapshot());
+ assertEquals(expectedSnapshot, _snapshot);
}
}
}
public void started() {
- String schemeStr = System.getProperty("connection.scheme");
- for (ConnectionMgmtScheme scheme : ConnectionMgmtScheme.values()) {
- AbstractScheme schemeImpl = SchemeFactory.getScheme(scheme,
- clusterServices);
- if (schemeImpl != null) {
- schemes.put(scheme, schemeImpl);
- if (scheme.name().equalsIgnoreCase(schemeStr)) {
- activeScheme = scheme;
- }
- }
- }
connectionEventThread.start();
"ConnectionEvent Thread");
this.connectionEvents = new LinkedBlockingQueue<ConnectionMgmtEvent>();
schemes = new ConcurrentHashMap<ConnectionMgmtScheme, AbstractScheme>();
+
+ String schemeStr = System.getProperty("connection.scheme");
+ for (ConnectionMgmtScheme scheme : ConnectionMgmtScheme.values()) {
+ AbstractScheme schemeImpl = SchemeFactory.getScheme(scheme, clusterServices);
+ if (schemeImpl != null) {
+ schemes.put(scheme, schemeImpl);
+ if (scheme.name().equalsIgnoreCase(schemeStr)) {
+ activeScheme = scheme;
+ }
+ }
+ }
}
public void stopping() {
}
/*
- * Clustering Services' doesnt provide the existing states in the cache
+ * Clustering Services doesn't provide the existing states in the cache
* update callbacks. Hence, using a scratch local cache to maintain the
* existing state.
*/
return;
Set<InetAddress> existingControllers = existingConnections.get(node);
if (existingControllers != null) {
- logger.debug(
- "Processing Update for : {} NewControllers : {} existingControllers : {}",
- node, newControllers.toString(),
- existingControllers.toString());
+ logger.debug("Processing Update for : {} NewControllers : {} existingControllers : {}", node,
+ newControllers.toString(), existingControllers.toString());
if (newControllers.size() < existingControllers.size()) {
- Set<InetAddress> removed = new HashSet<InetAddress>(
- existingControllers);
+ Set<InetAddress> removed = new HashSet<InetAddress>(existingControllers);
if (removed.removeAll(newControllers)) {
logger.debug("notifyNodeDisconnectFromMaster({})", node);
notifyNodeDisconnectedEvent(node);
}
}
} else {
- logger.debug("Ignoring the Update for : {} NewControllers : {}",
- node, newControllers.toString());
+ logger.debug("Ignoring the Update for : {} NewControllers : {}", node, newControllers.toString());
}
existingConnections.put(node, newControllers);
}
public void entryDeleted(Node key, String cacheName, boolean originLocal) {
if (originLocal)
return;
- logger.debug("Deleted : {} cache : {}", key, cacheName);
+ logger.debug("Deleted entry {} from cache : {}", key, cacheName);
notifyNodeDisconnectedEvent(key);
}
allocateCaches();
retrieveCaches();
} else {
- log.error("Couldn't retrieve caches for scheme %s. Clustering service unavailable", name);
+ log.error("Couldn't retrieve caches for scheme {}. Clustering service unavailable", name);
}
}
log.error("An error occured",e);
}
}
+
+ /* (non-Javadoc)
+ * @see java.lang.Object#hashCode()
+ */
+ @Override
+ public int hashCode() {
+ final int prime = 31;
+ int result = 1;
+ result = prime * result + ((name == null) ? 0 : name.hashCode());
+ result = prime * result + ((nodeConnections == null) ? 0 : nodeConnections.hashCode());
+ result = prime * result + ((nodeConnectionsCacheName == null) ? 0 : nodeConnectionsCacheName.hashCode());
+ return result;
+ }
+
+ /* (non-Javadoc)
+ * @see java.lang.Object#equals(java.lang.Object)
+ */
+ @Override
+ public boolean equals(Object obj) {
+ if (this == obj) {
+ return true;
+ }
+ if (obj == null) {
+ return false;
+ }
+ if (!(obj instanceof AbstractScheme)) {
+ return false;
+ }
+ AbstractScheme other = (AbstractScheme) obj;
+ if (name == null) {
+ if (other.name != null) {
+ return false;
+ }
+ } else if (!name.equals(other.name)) {
+ return false;
+ }
+ if (nodeConnections == null) {
+ if (other.nodeConnections != null) {
+ return false;
+ }
+ } else if (!nodeConnections.equals(other.nodeConnections)) {
+ return false;
+ }
+ if (nodeConnectionsCacheName == null) {
+ if (other.nodeConnectionsCacheName != null) {
+ return false;
+ }
+ } else if (!nodeConnectionsCacheName.equals(other.nodeConnectionsCacheName)) {
+ return false;
+ }
+ return true;
+ }
}
reference\:file\:../lib/slf4j-api-1.7.2.jar@1:start,\
reference\:file\:../lib/logback-classic-1.0.9.jar@1:start,\
reference\:file\:../lib/logback-core-1.0.9.jar@1:start,\
- reference\:file\:../lib/logging.bridge-0.4.1-SNAPSHOT@1:start,\
+ reference\:file\:../lib/logging.bridge-0.4.2-SNAPSHOT@1:start,\
reference\:file\:../lib/jersey-core-1.17.jar@2:start,\
reference\:file\:../lib/jersey-server-1.17.jar@2:start
<parent>
<groupId>org.opendaylight.controller</groupId>
<artifactId>sal-parent</artifactId>
- <version>1.0-SNAPSHOT</version>
+ <version>1.1-SNAPSHOT</version>
<relativePath>../..</relativePath>
</parent>
<scm>
<plugin>
<groupId>org.apache.felix</groupId>
<artifactId>maven-bundle-plugin</artifactId>
- <version>${bundle.plugin.version}</version>
<extensions>true</extensions>
<configuration>
<instructions>
<plugin>
<groupId>org.opendaylight.yangtools</groupId>
<artifactId>yang-maven-plugin</artifactId>
- <version>${yangtools.version}</version>
<executions>
<execution>
<goals>
<dependency>
<groupId>org.opendaylight.controller</groupId>
<artifactId>sal-core-api</artifactId>
- <version>1.0-SNAPSHOT</version>
</dependency>
<dependency>
<groupId>org.opendaylight.controller</groupId>
<artifactId>sal-common-util</artifactId>
- <version>1.0-SNAPSHOT</version>
</dependency>
<dependency>
<groupId>org.opendaylight.controller</groupId>
<artifactId>config-api</artifactId>
- <version>0.2.3-SNAPSHOT</version>
</dependency>
<dependency>
<groupId>org.opendaylight.controller</groupId>
<artifactId>sal</artifactId>
- <version>0.7.0-SNAPSHOT</version>
</dependency>
<dependency>
<groupId>org.opendaylight.controller</groupId>
<artifactId>clustering.services</artifactId>
- <version>0.5.0-SNAPSHOT</version>
</dependency>
<dependency>
<groupId>junit</groupId>
* removes direct dependencies between providers and consumers.
*
* The Binding-aware broker is also responsible for translation from Java
- * classes modeling the functionality and data to binding-indpenedent form which
+ * classes modeling the functionality and data to binding-independent form which
* is used in SAL Core.
*
*
public interface RpcConsumerRegistry extends BindingAwareService {
/**
* Returns a session specific instance (implementation) of requested
- * YANG module implentation / service provided by consumer.
+ * YANG module implementation / service provided by consumer.
*
* @return Session specific implementation of service
*/
RpcConsumerRegistry, //
RouteChangePublisher<RpcContextIdentifier, InstanceIdentifier<?>> {
/**
- * Registers an global RpcService implementation.
+ * Registers a global RpcService implementation.
*
* @param type
* @param implementation
/**
*
- * Register an Routed RpcService where routing is determined on annotated
+ * Register a Routed RpcService where routing is determined on annotated
* (in YANG model) context-reference and value of annotated leaf.
*
* @param type
* Type of RpcService, use generated interface class, not your
- * implementation clas
+ * implementation class
* @param implementation
* Implementation of RpcService
- * @return Registration object for routed Rpc which could be used to close
- * an
+ * @return Registration object for routed Rpc which could be used to unregister
*
* @throws IllegalStateException
*/
/**
* RpcRouter is responsible for selecting RpcService based on provided routing
* context identifier {@link RpcRoutingTable#getContextIdentifier()} and path in
- * overal data tree (@link {@link InstanceIdentifier}.
+ * overall data tree (@link {@link InstanceIdentifier}.
*
*
* @author Tony Tkacik <ttkacik@cisco.com>
*/
package org.opendaylight.controller.sal.binding.impl;
-import static com.google.common.base.Preconditions.checkState;
-
-import java.util.EventListener;
-import java.util.HashMap;
-import java.util.Map;
-import java.util.Map.Entry;
-import java.util.Set;
-import java.util.WeakHashMap;
-
import org.opendaylight.controller.md.sal.common.api.routing.RouteChange;
import org.opendaylight.controller.md.sal.common.api.routing.RouteChangeListener;
import org.opendaylight.controller.md.sal.common.api.routing.RouteChangePublisher;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
+import java.util.EventListener;
+import java.util.HashMap;
+import java.util.Map;
+import java.util.Map.Entry;
+import java.util.Set;
+import java.util.WeakHashMap;
+
+import static com.google.common.base.Preconditions.checkState;
+
public class RpcProviderRegistryImpl implements //
RpcProviderRegistry, //
RouteChangePublisher<RpcContextIdentifier, InstanceIdentifier<?>> {
private RuntimeCodeGenerator rpcFactory = SingletonHolder.RPC_GENERATOR_IMPL;
+ // publicProxies is a cache of proxy objects where each value in the map corresponds to a specific RpcService
private final Map<Class<? extends RpcService>, RpcService> publicProxies = new WeakHashMap<>();
private final Map<Class<? extends RpcService>, RpcRouter<?>> rpcRouters = new WeakHashMap<>();
private final ListenerRegistry<RouteChangeListener<RpcContextIdentifier, InstanceIdentifier<?>>> routeChangeListeners = ListenerRegistry
<dependency>
<groupId> ch.qos.logback</groupId>
<artifactId>logback-classic</artifactId>
- <version>1.0.9</version>
<scope>test</scope>
</dependency>
<dependency>
<groupId>com.fasterxml.jackson.core</groupId>
<artifactId>jackson-annotations</artifactId>
- <version>${jackson.version}</version>
</dependency>
<dependency>
<groupId>com.fasterxml.jackson.core</groupId>
<artifactId>jackson-core</artifactId>
- <version>${jackson.version}</version>
</dependency>
<dependency>
<groupId>com.fasterxml.jackson.core</groupId>
<artifactId>jackson-databind</artifactId>
- <version>${jackson.version}</version>
</dependency>
<dependency>
<plugin>
<groupId>org.apache.felix</groupId>
<artifactId>maven-bundle-plugin</artifactId>
- <version>${bundle.plugin.version}</version>
<extensions>true</extensions>
<configuration>
<instructions>
<plugin>
<groupId>org.opendaylight.yangtools</groupId>
<artifactId>yang-maven-plugin</artifactId>
- <version>${yangtools.version}</version>
<executions>
<execution>
<goals>
moveToReadyListHi(dst);
}
+ //checking only OF map, since production edge discovery always overwrites any existing edge
+ UpdateType ut = edgeMap.containsKey(dst) ? UpdateType.CHANGED : UpdateType.ADDED;
// notify
- updateEdge(edge, UpdateType.ADDED, props);
+ updateEdge(edge, ut, props);
logger.trace("Add edge {}", edge);
}
return;
}
+
this.discoveryListener.notifyEdge(edge, type, props);
NodeConnector src = edge.getTailNodeConnector(), dst = edge.getHeadNodeConnector();
/**
* The class represents an Edge, the Edge's Property Set and its UpdateType.
+ * If update is on new properties added to an existing edge, appropriate type is CHANGED.
*/
public class TopoEdgeUpdate {
private Edge edge;
*/
public static boolean isMulticastMACAddr(byte[] MACAddress) {
if (MACAddress.length == MACAddrLengthInBytes && !isBroadcastMACAddr(MACAddress)) {
- if (MACAddress[0] % 2 == 1) {
- return true;
- }
+ return (MACAddress[0] & 1) != 0;
}
return false;
}
Assert.assertEquals(32768, NetUtils.getUnsignedShort((short) 0x8000));
Assert.assertEquals(65535, NetUtils.getUnsignedShort((short) 0xffff));
}
+
+ @Test
+ public void testMulticastMACAddr() {
+ byte[] empty = new byte[0];
+ Assert.assertFalse(NetUtils.isUnicastMACAddr(empty));
+ Assert.assertFalse(NetUtils.isMulticastMACAddr(empty));
+
+ byte[] bcast = {
+ (byte)0xff, (byte)0xff, (byte)0xff,
+ (byte)0xff, (byte)0xff, (byte)0xff,
+ };
+ Assert.assertFalse(NetUtils.isUnicastMACAddr(bcast));
+ Assert.assertFalse(NetUtils.isMulticastMACAddr(bcast));
+
+ byte[] firstOctet = {
+ (byte)0x00, (byte)0x20, (byte)0x80, (byte)0xfe,
+ };
+ for (int len = 1; len <= 10; len++) {
+ byte[] ba = new byte[len];
+ boolean valid = (len == 6);
+ for (byte first: firstOctet) {
+ ba[0] = first;
+ Assert.assertFalse(NetUtils.isMulticastMACAddr(ba));
+ Assert.assertEquals(valid, NetUtils.isUnicastMACAddr(ba));
+
+ ba[0] |= (byte)0x01;
+ Assert.assertEquals(valid, NetUtils.isMulticastMACAddr(ba));
+ Assert.assertFalse(NetUtils.isUnicastMACAddr(ba));
+ }
+ }
+ }
}
switch (type) {
case ADDED:
+
+ if (this.edgesDB.containsKey(e)) {
+ // Avoid redundant updates (e.g. cluster switch-over) as notifications trigger expensive tasks
+ log.trace("Skipping redundant edge addition: {}", e);
+ return null;
+ }
+
// Make sure the props are non-null or create a copy
if (props == null) {
props = new HashSet<Property>();
props = new HashSet<Property>(props);
}
- Set<Property> currentProps = this.edgesDB.get(e);
- if (currentProps != null) {
-
- if (currentProps.equals(props)) {
- // Avoid redundant updates as notifications trigger expensive tasks
- log.trace("Skipping redundant edge addition: {}", e);
- return null;
- }
-
- // In case of node switch-over to a different cluster controller,
- // let's retain edge props (e.g. creation time)
- props.addAll(currentProps);
- }
// Ensure that head node connector exists
if (!headNodeConnectorExist(e)) {
case CHANGED:
Set<Property> oldProps = this.edgesDB.get(e);
- // When property changes lets make sure we can change it
+ // When property(s) changes lets make sure we can change it
// all except the creation time stamp because that should
- // be changed only when the edge is destroyed and created
- // again
+ // be set only when the edge is created
TimeStamp timeStamp = null;
for (Property prop : oldProps) {
if (prop instanceof TimeStamp) {
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
-import com.fasterxml.jackson.databind.ObjectMapper;
import org.opendaylight.controller.connectionmanager.IConnectionManager;
import org.opendaylight.controller.forwarding.staticrouting.IForwardingStaticRouting;
import org.opendaylight.controller.forwarding.staticrouting.StaticRouteConfig;
import org.springframework.web.bind.annotation.RequestParam;
import org.springframework.web.bind.annotation.ResponseBody;
+import com.fasterxml.jackson.databind.ObjectMapper;
import com.google.gson.Gson;
import com.google.gson.reflect.TypeToken;
for (NodeConnector nodeConnector : nodeConnectorSet) {
String nodeConnectorNumberToStr = nodeConnector.getID().toString();
Name ncName = ((Name) switchManager.getNodeConnectorProp(nodeConnector, Name.NamePropName));
- Config portStatus = ((Config) switchManager.getNodeConnectorProp(nodeConnector,
+ Config portConfig = ((Config) switchManager.getNodeConnectorProp(nodeConnector,
Config.ConfigPropName));
State portState = ((State) switchManager.getNodeConnectorProp(nodeConnector,
State.StatePropName));
String nodeConnectorName = (ncName != null) ? ncName.getValue() : "";
nodeConnectorName += " (" + nodeConnector.getID() + ")";
- if (portStatus != null) {
- if (portStatus.getValue() == Config.ADMIN_UP) {
- if (portState.getValue() == State.EDGE_UP) {
+ if (portConfig != null) {
+ if (portConfig.getValue() == Config.ADMIN_UP) {
+ if (portState != null && portState.getValue() == State.EDGE_UP) {
nodeConnectorName = "<span class='admin-up'>" + nodeConnectorName + "</span>";
- } else if (portState.getValue() == State.EDGE_DOWN) {
+ } else if (portState == null || portState.getValue() == State.EDGE_DOWN) {
nodeConnectorName = "<span class='edge-down'>" + nodeConnectorName + "</span>";
}
- } else if (portStatus.getValue() == Config.ADMIN_DOWN) {
+ } else if (portConfig.getValue() == Config.ADMIN_DOWN) {
nodeConnectorName = "<span class='admin-down'>" + nodeConnectorName + "</span>";
}
}
Code Review / controller.git / commitdiff