import com.google.common.base.Optional;
import com.google.common.base.Preconditions;
+import com.google.common.util.concurrent.CheckedFuture;
+import com.google.common.util.concurrent.FutureCallback;
+import com.google.common.util.concurrent.Futures;
import org.opendaylight.controller.md.sal.binding.api.DataBroker;
import org.opendaylight.controller.md.sal.binding.api.DataChangeListener;
import org.opendaylight.controller.md.sal.binding.api.ReadOnlyTransaction;
public class TopologyLinkDataChangeHandler implements DataChangeListener {
private static final Logger _logger = LoggerFactory.getLogger(TopologyLinkDataChangeHandler.class);
private static final String DEFAULT_TOPOLOGY_ID = "flow:1";
+ private static final long DEFAULT_GRAPH_REFRESH_DELAY = 1000;
private final ScheduledExecutorService topologyDataChangeEventProcessor = Executors.newScheduledThreadPool(1);
private boolean networkGraphRefreshScheduled = false;
private boolean threadReschedule = false;
private long graphRefreshDelay;
+ private String topologyId;
private final DataBroker dataBroker;
}
public void setGraphRefreshDelay(long graphRefreshDelay) {
- this.graphRefreshDelay = graphRefreshDelay;
+ if (graphRefreshDelay < 0) {
+ this.graphRefreshDelay = DEFAULT_GRAPH_REFRESH_DELAY;
+ }
+ else this.graphRefreshDelay = graphRefreshDelay;
+ }
+
+ public void setTopologyId(String topologyId) {
+ if (topologyId == null || topologyId.isEmpty()) {
+ this.topologyId = DEFAULT_TOPOLOGY_ID;
+ }
+ else this.topologyId = topologyId;
}
/**
*/
public ListenerRegistration<DataChangeListener> registerAsDataChangeListener() {
InstanceIdentifier<Link> linkInstance = InstanceIdentifier.builder(NetworkTopology.class)
- .child(Topology.class, new TopologyKey(new TopologyId(DEFAULT_TOPOLOGY_ID))).child(Link.class).toInstance();
+ .child(Topology.class, new TopologyKey(new TopologyId(topologyId))).child(Link.class).toInstance();
return dataBroker.registerDataChangeListener(LogicalDatastoreType.OPERATIONAL, linkInstance, this, AsyncDataBroker.DataChangeScope.BASE);
}
if(!networkGraphRefreshScheduled) {
synchronized(this) {
if(!networkGraphRefreshScheduled) {
- topologyDataChangeEventProcessor.schedule(new TopologyDataChangeEventProcessor(), graphRefreshDelay, TimeUnit.SECONDS);
+ topologyDataChangeEventProcessor.schedule(new TopologyDataChangeEventProcessor(), graphRefreshDelay, TimeUnit.MILLISECONDS);
networkGraphRefreshScheduled = true;
_logger.debug("Scheduled Graph for refresh.");
}
@Override
public void run() {
if (threadReschedule) {
- topologyDataChangeEventProcessor.schedule(this, graphRefreshDelay, TimeUnit.SECONDS);
+ topologyDataChangeEventProcessor.schedule(this, graphRefreshDelay, TimeUnit.MILLISECONDS);
threadReschedule = false;
return;
}
return;
}
networkGraphService.addLinks(links);
- ReadWriteTransaction readWriteTransaction = dataBroker.newReadWriteTransaction();
+ final ReadWriteTransaction readWriteTransaction = dataBroker.newReadWriteTransaction();
updateNodeConnectorStatus(readWriteTransaction);
- readWriteTransaction.submit();
+ final CheckedFuture writeTxResultFuture = readWriteTransaction.submit();
+ Futures.addCallback(writeTxResultFuture, new FutureCallback() {
+ @Override
+ public void onSuccess(Object o) {
+ _logger.debug("TopologyLinkDataChangeHandler write successful for tx :{}", readWriteTransaction.getIdentifier());
+ }
+
+ @Override
+ public void onFailure(Throwable throwable) {
+ _logger.error("TopologyLinkDataChangeHandler write transaction {} failed", readWriteTransaction.getIdentifier(), throwable.getCause());
+ }
+ });
_logger.debug("Done with network graph refresh thread.");
}
private List<Link> getLinksFromTopology() {
- InstanceIdentifier<Topology> topologyInstanceIdentifier = InstanceIdentifierUtils.generateTopologyInstanceIdentifier(DEFAULT_TOPOLOGY_ID);
+ InstanceIdentifier<Topology> topologyInstanceIdentifier = InstanceIdentifierUtils.generateTopologyInstanceIdentifier(topologyId);
Topology topology = null;
ReadOnlyTransaction readOnlyTransaction = dataBroker.newReadOnlyTransaction();
try {