package org.opendaylight.openflowplugin.applications.frm;
import org.opendaylight.controller.md.sal.binding.api.DataTreeChangeListener;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.flow.inventory.rev130819.FlowCapableNode;
import org.opendaylight.yang.gen.v1.urn.opendaylight.flow.inventory.rev130819.FlowCapableNodeConnector;
import org.opendaylight.yangtools.yang.binding.DataObject;
import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
package org.opendaylight.openflowplugin.applications.frm;
+import java.util.concurrent.Future;
import org.opendaylight.controller.md.sal.binding.api.ClusteredDataTreeChangeListener;
import org.opendaylight.yang.gen.v1.urn.opendaylight.flow.inventory.rev130819.FlowCapableNode;
import org.opendaylight.yangtools.yang.binding.DataObject;
import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
import org.opendaylight.yangtools.yang.common.RpcResult;
-import java.util.concurrent.Future;
-
/**
* forwardingrules-manager
* org.opendaylight.openflowplugin.applications.frm
* SalRpcService for device. Every implementation has to be registered for
* Configurational/DS tree path.
*
- * @author <a href="mailto:vdemcak@cisco.com">Vaclav Demcak</a>
- *
- * Created: Aug 25, 2014
*/
public interface ForwardingRulesCommiter <D extends DataObject> extends AutoCloseable, ClusteredDataTreeChangeListener<D> {
package org.opendaylight.openflowplugin.applications.frm.impl;
import com.google.common.base.Preconditions;
+import java.util.Collection;
import org.opendaylight.controller.md.sal.binding.api.DataObjectModification;
import org.opendaylight.controller.md.sal.binding.api.DataTreeModification;
import org.opendaylight.controller.md.sal.common.api.data.AsyncDataChangeEvent;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
-import java.util.Collection;
-
/**
* AbstractChangeListner implemented basic {@link AsyncDataChangeEvent} processing for
* flow node subDataObject (flows, groups and meters).
private static final Logger LOG = LoggerFactory.getLogger(AbstractListeningCommiter.class);
- protected ForwardingRulesManager provider;
+ ForwardingRulesManager provider;
- protected final Class<T> clazz;
+ private final Class<T> clazz;
public AbstractListeningCommiter (ForwardingRulesManager provider, Class<T> clazz) {
this.provider = Preconditions.checkNotNull(provider, "ForwardingRulesManager can not be null!");
package org.opendaylight.openflowplugin.applications.frm.impl;
import com.google.common.base.Preconditions;
+import java.util.Collection;
import org.opendaylight.controller.md.sal.binding.api.DataObjectModification;
import org.opendaylight.controller.md.sal.binding.api.DataTreeModification;
import org.opendaylight.openflowplugin.applications.frm.FlowCapableNodeConnectorCommitter;
-import org.opendaylight.openflowplugin.applications.frm.ForwardingRulesCommiter;
import org.opendaylight.openflowplugin.applications.frm.ForwardingRulesManager;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.flow.inventory.rev130819.FlowCapableNode;
import org.opendaylight.yang.gen.v1.urn.opendaylight.flow.inventory.rev130819.FlowCapableNodeConnector;
import org.opendaylight.yangtools.yang.binding.DataObject;
import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
-import java.util.Collection;
-
public abstract class AbstractNodeConnectorCommitter <T extends DataObject> implements FlowCapableNodeConnectorCommitter<T> {
- protected ForwardingRulesManager provider;
+ private ForwardingRulesManager provider;
- protected final Class<T> clazz;
+ private final Class<T> clazz;
public AbstractNodeConnectorCommitter (ForwardingRulesManager provider, Class<T> clazz) {
this.provider = Preconditions.checkNotNull(provider, "ForwardingRulesManager can not be null!");
import com.google.common.util.concurrent.FutureCallback;
import com.google.common.util.concurrent.Futures;
import com.google.common.util.concurrent.SettableFuture;
+import java.util.concurrent.Callable;
+import java.util.concurrent.Future;
import org.opendaylight.controller.md.sal.binding.api.DataBroker;
import org.opendaylight.controller.md.sal.binding.api.DataTreeIdentifier;
import org.opendaylight.controller.md.sal.binding.api.WriteTransaction;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
-import java.util.concurrent.Callable;
-import java.util.concurrent.Future;
-
/**
* FlowForwarder
* It implements {@link org.opendaylight.controller.md.sal.binding.api.DataTreeChangeListener}}
* for WildCardedPath to {@link Flow} and ForwardingRulesCommiter interface for methods:
* add, update and remove {@link Flow} processing for
* {@link org.opendaylight.controller.md.sal.common.api.data.AsyncDataChangeEvent}.
- *
- * @author <a href="mailto:vdemcak@cisco.com">Vaclav Demcak</a>
- *
*/
public class FlowForwarder extends AbstractListeningCommiter<Flow> {
package org.opendaylight.openflowplugin.applications.frm.impl;
import com.google.common.base.Preconditions;
-import com.google.common.collect.*;
-import org.opendaylight.controller.md.sal.binding.api.*;
+import com.google.common.collect.ArrayListMultimap;
+import com.google.common.collect.Iterables;
+import com.google.common.collect.Multimap;
+import com.google.common.collect.Multimaps;
+import java.math.BigInteger;
+import java.util.concurrent.Callable;
+import org.opendaylight.controller.md.sal.binding.api.DataBroker;
+import org.opendaylight.controller.md.sal.binding.api.DataTreeIdentifier;
import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType;
import org.opendaylight.openflowplugin.applications.frm.FlowNodeConnectorInventoryTranslator;
import org.opendaylight.openflowplugin.applications.frm.ForwardingRulesManager;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
-import java.math.BigInteger;
-import java.util.concurrent.Callable;
-
public class FlowNodeConnectorInventoryTranslatorImpl extends AbstractNodeConnectorCommitter<FlowCapableNodeConnector> implements FlowNodeConnectorInventoryTranslator {
private static final Logger LOG = LoggerFactory.getLogger(FlowNodeConnectorInventoryTranslatorImpl.class);
private ListenerRegistration<FlowNodeConnectorInventoryTranslatorImpl> dataTreeChangeListenerRegistration;
- public static final String SEPARATOR = ":";
+ private static final String SEPARATOR = ":";
private static final InstanceIdentifier<FlowCapableNodeConnector> II_TO_FLOW_CAPABLE_NODE_CONNECTOR
= InstanceIdentifier.builder(Nodes.class)
@Override
public void remove(InstanceIdentifier<FlowCapableNodeConnector> identifier, FlowCapableNodeConnector del, InstanceIdentifier<FlowCapableNodeConnector> nodeConnIdent) {
if(compareInstanceIdentifierTail(identifier,II_TO_FLOW_CAPABLE_NODE_CONNECTOR)){
- LOG.info("Node Connector removed");
+ LOG.debug("Node Connector removed");
String sNodeConnectorIdentifier = nodeConnIdent
.firstKeyOf(NodeConnector.class, NodeConnectorKey.class).getId().getValue();
BigInteger nDpId = getDpIdFromPortName(sNodeConnectorIdentifier);
@Override
public void update(InstanceIdentifier<FlowCapableNodeConnector> identifier, FlowCapableNodeConnector original, FlowCapableNodeConnector update, InstanceIdentifier<FlowCapableNodeConnector> nodeConnIdent) {
if(compareInstanceIdentifierTail(identifier,II_TO_FLOW_CAPABLE_NODE_CONNECTOR)){
- LOG.info("Node Connector updated");
+ LOG.debug("Node Connector updated");
//donot need to do anything as we are not considering updates here
}
}
@Override
public void add(InstanceIdentifier<FlowCapableNodeConnector> identifier, FlowCapableNodeConnector add, InstanceIdentifier<FlowCapableNodeConnector> nodeConnIdent) {
if(compareInstanceIdentifierTail(identifier,II_TO_FLOW_CAPABLE_NODE_CONNECTOR)){
- LOG.info("Node Connector added");
+ LOG.debug("Node Connector added");
String sNodeConnectorIdentifier = nodeConnIdent
.firstKeyOf(NodeConnector.class, NodeConnectorKey.class).getId().getValue();
BigInteger nDpId = getDpIdFromPortName(sNodeConnectorIdentifier);
package org.opendaylight.openflowplugin.applications.frm.impl;
-import java.math.BigInteger;
-import java.util.*;
-import java.util.concurrent.ExecutorService;
-import java.util.concurrent.Executors;
-import java.util.concurrent.atomic.AtomicInteger;
import com.google.common.base.Optional;
import com.google.common.base.Preconditions;
import com.google.common.collect.ImmutableList;
import com.google.common.util.concurrent.CheckedFuture;
import com.google.common.util.concurrent.FutureCallback;
import com.google.common.util.concurrent.Futures;
-
+import java.math.BigInteger;
+import java.util.ArrayList;
+import java.util.Collection;
+import java.util.Collections;
+import java.util.List;
+import java.util.ListIterator;
import java.util.concurrent.Callable;
-
-import org.opendaylight.controller.md.sal.binding.api.*;
+import java.util.concurrent.ExecutorService;
+import java.util.concurrent.Executors;
+import java.util.concurrent.atomic.AtomicInteger;
+import javax.annotation.Nonnull;
+import org.opendaylight.controller.md.sal.binding.api.DataBroker;
+import org.opendaylight.controller.md.sal.binding.api.DataObjectModification;
+import org.opendaylight.controller.md.sal.binding.api.DataTreeIdentifier;
+import org.opendaylight.controller.md.sal.binding.api.DataTreeModification;
+import org.opendaylight.controller.md.sal.binding.api.ReadOnlyTransaction;
+import org.opendaylight.controller.md.sal.binding.api.WriteTransaction;
import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType;
import org.opendaylight.controller.md.sal.common.api.data.TransactionCommitFailedException;
import org.opendaylight.openflowplugin.applications.frm.FlowNodeReconciliation;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
-import javax.annotation.Nonnull;
-
/**
* forwardingrules-manager
private final DataBroker dataBroker;
private final ForwardingRulesManager provider;
- public static final String SEPARATOR = ":";
+ private static final String SEPARATOR = ":";
private ListenerRegistration<FlowNodeReconciliationImpl> listenerRegistration;
* Manager and middle point for whole module.
* It contains ActiveNodeHolder and provide all RPC services.
*
- * @author <a href="mailto:vdemcak@cisco.com">Vaclav Demcak</a>
- *
- * Created: Aug 25, 2014
*/
public class ForwardingRulesManagerImpl implements ForwardingRulesManager {
private static final Logger LOG = LoggerFactory.getLogger(ForwardingRulesManagerImpl.class);
- public static final int STARTUP_LOOP_TICK = 500;
- public static final int STARTUP_LOOP_MAX_RETRIES = 8;
+ static final int STARTUP_LOOP_TICK = 500;
+ static final int STARTUP_LOOP_MAX_RETRIES = 8;
private final AtomicLong txNum = new AtomicLong();
private final Object lockObj = new Object();
import com.google.common.util.concurrent.CheckedFuture;
import com.google.common.util.concurrent.FutureCallback;
import com.google.common.util.concurrent.Futures;
+import java.util.concurrent.Callable;
+import java.util.concurrent.Future;
import org.opendaylight.controller.md.sal.binding.api.DataBroker;
import org.opendaylight.controller.md.sal.binding.api.DataTreeIdentifier;
import org.opendaylight.controller.md.sal.binding.api.WriteTransaction;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
-import java.util.concurrent.Callable;
-import java.util.concurrent.Future;
-
/**
* GroupForwarder
* It implements {@link org.opendaylight.controller.md.sal.binding.api.DataTreeChangeListener}}
* add, update and remove {@link Group} processing for
* {@link org.opendaylight.controller.md.sal.common.api.data.AsyncDataChangeEvent}.
*
- * @author <a href="mailto:vdemcak@cisco.com">Vaclav Demcak</a>
- *
*/
public class GroupForwarder extends AbstractListeningCommiter<Group> {
import com.google.common.util.concurrent.CheckedFuture;
import com.google.common.util.concurrent.FutureCallback;
import com.google.common.util.concurrent.Futures;
+import java.util.concurrent.Callable;
+import java.util.concurrent.Future;
import org.opendaylight.controller.md.sal.binding.api.DataBroker;
import org.opendaylight.controller.md.sal.binding.api.DataTreeIdentifier;
import org.opendaylight.controller.md.sal.binding.api.WriteTransaction;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
-import java.util.concurrent.Callable;
-import java.util.concurrent.Future;
-
/**
* MeterForwarder
* It implements {@link org.opendaylight.controller.md.sal.binding.api.DataTreeChangeListener}}
* add, update and remove {@link Meter} processing for
* {@link org.opendaylight.controller.md.sal.common.api.data.AsyncDataChangeEvent}.
*
- * @author <a href="mailto:vdemcak@cisco.com">Vaclav Demcak</a>
- *
*/
public class MeterForwarder extends AbstractListeningCommiter<Meter> {
private final boolean switchFeaturesMandatory;
private boolean isNotificationFlowRemovedOff;
- private static final int spyRate = 10;
+ private static final int SPY_RATE = 10;
private final DataBroker dataBroker;
private TranslatorLibrary translatorLibrary;
@Override
public void initialize() {
- spyPool.scheduleAtFixedRate(conductor.getMessageIntelligenceAgency(), spyRate, spyRate, TimeUnit.SECONDS);
+ spyPool.scheduleAtFixedRate(conductor.getMessageIntelligenceAgency(), SPY_RATE, SPY_RATE, TimeUnit.SECONDS);
}
@Override
return getPriority() == that.getPriority() &&
getTableId() == that.getTableId() &&
- getCookie().equals(that.getCookie()) &&
getMatch().equals(that.getMatch());
}
public int hashCode() {
int result = tableId;
result = 31 * result + priority;
- result = 31 * result + cookie.hashCode();
result = 31 * result + match.hashCode();
return result;
}