X-Git-Url: https://git.opendaylight.org/gerrit/gitweb?p=controller.git;a=blobdiff_plain;f=opendaylight%2Fnetconf%2Fnetconf-impl%2Fsrc%2Fmain%2Fjava%2Forg%2Fopendaylight%2Fcontroller%2Fnetconf%2Fimpl%2Fosgi%2FNetconfOperationRouterImpl.java;h=6915ee4bfe373fa2ac402cedb5edd5f7540f643f;hp=ece9d47ee9fcfe3a0e485347d450d6a7e7fd83e2;hb=589bf833089d2aef2113bb5e493ee8c6816df19f;hpb=950be361f30f0dc9df109c1c649deb92d9cebb05 diff --git a/opendaylight/netconf/netconf-impl/src/main/java/org/opendaylight/controller/netconf/impl/osgi/NetconfOperationRouterImpl.java b/opendaylight/netconf/netconf-impl/src/main/java/org/opendaylight/controller/netconf/impl/osgi/NetconfOperationRouterImpl.java index ece9d47ee9..6915ee4bfe 100644 --- a/opendaylight/netconf/netconf-impl/src/main/java/org/opendaylight/controller/netconf/impl/osgi/NetconfOperationRouterImpl.java +++ b/opendaylight/netconf/netconf-impl/src/main/java/org/opendaylight/controller/netconf/impl/osgi/NetconfOperationRouterImpl.java @@ -7,70 +7,72 @@ */ package org.opendaylight.controller.netconf.impl.osgi; +import com.google.common.base.Preconditions; +import com.google.common.collect.Maps; +import com.google.common.collect.Sets; import java.util.Collections; import java.util.HashSet; -import java.util.Iterator; -import java.util.LinkedList; import java.util.Map; +import java.util.NavigableMap; import java.util.Set; import java.util.TreeMap; -import java.util.TreeSet; - import org.opendaylight.controller.netconf.api.NetconfDocumentedException; -import org.opendaylight.controller.netconf.api.NetconfOperationRouter; -import org.opendaylight.controller.netconf.api.NetconfSession; import org.opendaylight.controller.netconf.impl.DefaultCommitNotificationProducer; +import org.opendaylight.controller.netconf.impl.NetconfServerSession; import org.opendaylight.controller.netconf.impl.mapping.CapabilityProvider; import org.opendaylight.controller.netconf.impl.mapping.operations.DefaultCloseSession; import org.opendaylight.controller.netconf.impl.mapping.operations.DefaultCommit; import org.opendaylight.controller.netconf.impl.mapping.operations.DefaultGetSchema; +import org.opendaylight.controller.netconf.impl.mapping.operations.DefaultNetconfOperation; import org.opendaylight.controller.netconf.impl.mapping.operations.DefaultStartExi; import org.opendaylight.controller.netconf.impl.mapping.operations.DefaultStopExi; -import org.opendaylight.controller.netconf.mapping.api.DefaultNetconfOperation; import org.opendaylight.controller.netconf.mapping.api.HandlingPriority; import org.opendaylight.controller.netconf.mapping.api.NetconfOperation; -import org.opendaylight.controller.netconf.mapping.api.NetconfOperationFilter; -import org.opendaylight.controller.netconf.mapping.api.NetconfOperationFilterChain; +import org.opendaylight.controller.netconf.mapping.api.NetconfOperationChainedExecution; import org.opendaylight.controller.netconf.mapping.api.NetconfOperationService; +import org.opendaylight.controller.netconf.mapping.api.NetconfOperationServiceSnapshot; import org.opendaylight.controller.netconf.util.xml.XmlUtil; import org.slf4j.Logger; import org.slf4j.LoggerFactory; import org.w3c.dom.Document; -import com.google.common.base.Preconditions; -import com.google.common.collect.Maps; -import com.google.common.collect.Sets; - public class NetconfOperationRouterImpl implements NetconfOperationRouter { - private static final Logger logger = LoggerFactory.getLogger(NetconfOperationRouterImpl.class); + private static final Logger LOG = LoggerFactory.getLogger(NetconfOperationRouterImpl.class); private final NetconfOperationServiceSnapshot netconfOperationServiceSnapshot; + private Set allNetconfOperations; - private final Set allNetconfOperations; - private final TreeSet allSortedFilters; - - private final CapabilityProvider capabilityProvider; + private NetconfOperationRouterImpl(NetconfOperationServiceSnapshot netconfOperationServiceSnapshot) { + this.netconfOperationServiceSnapshot = netconfOperationServiceSnapshot; + } + private synchronized void initNetconfOperations(Set allOperations) { + allNetconfOperations = allOperations; + } - public NetconfOperationRouterImpl(NetconfOperationServiceSnapshot netconfOperationServiceSnapshot, - CapabilityProvider capabilityProvider, DefaultCommitNotificationProducer commitNotifier) { + /** + * Factory method to produce instance of NetconfOperationRouter + */ + public static NetconfOperationRouter createOperationRouter(NetconfOperationServiceSnapshot netconfOperationServiceSnapshot, + CapabilityProvider capabilityProvider, DefaultCommitNotificationProducer commitNotifier) { + NetconfOperationRouterImpl router = new NetconfOperationRouterImpl(netconfOperationServiceSnapshot); - this.netconfOperationServiceSnapshot = Preconditions.checkNotNull(netconfOperationServiceSnapshot); - this.capabilityProvider = Preconditions.checkNotNull(capabilityProvider); + Preconditions.checkNotNull(netconfOperationServiceSnapshot); + Preconditions.checkNotNull(capabilityProvider); final String sessionId = netconfOperationServiceSnapshot.getNetconfSessionIdForReporting(); + final Set defaultNetconfOperations = Sets.newHashSet(); defaultNetconfOperations.add(new DefaultGetSchema(capabilityProvider, sessionId)); - defaultNetconfOperations.add(new DefaultCloseSession(sessionId)); + defaultNetconfOperations.add(new DefaultCloseSession(sessionId, router)); defaultNetconfOperations.add(new DefaultStartExi(sessionId)); defaultNetconfOperations.add(new DefaultStopExi(sessionId)); + defaultNetconfOperations.add(new DefaultCommit(commitNotifier, capabilityProvider, sessionId, router)); - allNetconfOperations = getAllNetconfOperations(defaultNetconfOperations, netconfOperationServiceSnapshot); + router.initNetconfOperations(getAllNetconfOperations(defaultNetconfOperations, netconfOperationServiceSnapshot)); - DefaultCommit defaultCommit = new DefaultCommit(commitNotifier, capabilityProvider, sessionId); - Set defaultFilters = Sets. newHashSet(defaultCommit); - allSortedFilters = getAllNetconfFilters(defaultFilters, netconfOperationServiceSnapshot); + return router; } private static Set getAllNetconfOperations(Set defaultNetconfOperations, @@ -81,7 +83,7 @@ public class NetconfOperationRouterImpl implements NetconfOperationRouter { for (NetconfOperationService netconfOperationService : netconfOperationServiceSnapshot.getServices()) { final Set netOpsFromService = netconfOperationService.getNetconfOperations(); for (NetconfOperation netconfOperation : netOpsFromService) { - Preconditions.checkState(result.contains(netconfOperation) == false, + Preconditions.checkState(!result.contains(netconfOperation), "Netconf operation %s already present", netconfOperation); result.add(netconfOperation); } @@ -89,44 +91,28 @@ public class NetconfOperationRouterImpl implements NetconfOperationRouter { return Collections.unmodifiableSet(result); } - private static TreeSet getAllNetconfFilters(Set defaultFilters, - NetconfOperationServiceSnapshot netconfOperationServiceSnapshot) { - TreeSet result = new TreeSet<>(defaultFilters); - for (NetconfOperationService netconfOperationService : netconfOperationServiceSnapshot.getServices()) { - final Set filtersFromService = netconfOperationService.getFilters(); - for (NetconfOperationFilter filter : filtersFromService) { - Preconditions.checkState(result.contains(filter) == false, - "Filter %s already present, all filters so far: %s", filter, result); - result.add(filter); - } - } - return result; - } - - public CapabilityProvider getCapabilityProvider() { - return capabilityProvider; - } - @Override public synchronized Document onNetconfMessage(Document message, - NetconfSession session) throws NetconfDocumentedException { - NetconfOperationExecution netconfOperationExecution; + NetconfServerSession session) throws NetconfDocumentedException { + Preconditions.checkNotNull(allNetconfOperations, "Operation router was not initialized properly"); - String messageAsString = XmlUtil.toString(message); + NetconfOperationExecution netconfOperationExecution; + String messageAsString = ""; try { + messageAsString = XmlUtil.toString(message); netconfOperationExecution = getNetconfOperationWithHighestPriority(message, session); } catch (IllegalArgumentException | IllegalStateException e) { - logger.warn("Unable to handle rpc {} on session {}", messageAsString, session, e); + LOG.warn("Unable to handle rpc {} on session {}", messageAsString, session, e); String errorMessage = String.format("Unable to handle rpc %s on session %s", messageAsString, session); Map errorInfo = Maps.newHashMap(); - NetconfDocumentedException.ErrorTag tag = null; + NetconfDocumentedException.ErrorTag tag; if (e instanceof IllegalArgumentException) { errorInfo.put(NetconfDocumentedException.ErrorTag.operation_not_supported.toString(), e.getMessage()); tag = NetconfDocumentedException.ErrorTag.operation_not_supported; - } else if (e instanceof IllegalStateException) { + } else { errorInfo.put(NetconfDocumentedException.ErrorTag.operation_failed.toString(), e.getMessage()); tag = NetconfDocumentedException.ErrorTag.operation_failed; } @@ -144,8 +130,13 @@ public class NetconfOperationRouterImpl implements NetconfOperationRouter { } } + @Override + public void close() throws Exception { + netconfOperationServiceSnapshot.close(); + } + private NetconfDocumentedException handleUnexpectedEx(String s, Exception e) throws NetconfDocumentedException { - logger.error(s, e); + LOG.error(s, e); Map info = Maps.newHashMap(); info.put(NetconfDocumentedException.ErrorSeverity.error.toString(), e.toString()); @@ -155,94 +146,94 @@ public class NetconfOperationRouterImpl implements NetconfOperationRouter { NetconfDocumentedException.ErrorSeverity.error, info); } - private Document executeOperationWithHighestPriority(Document message, NetconfOperationExecution netconfOperationExecution, String messageAsString) throws NetconfDocumentedException { - logger.debug("Forwarding netconf message {} to {}", messageAsString, - netconfOperationExecution.operationWithHighestPriority); - - final LinkedList chain = new LinkedList<>(); - chain.push(netconfOperationExecution); - - for (Iterator it = allSortedFilters.descendingIterator(); it.hasNext();) { - final NetconfOperationFilter filter = it.next(); - final NetconfOperationFilterChain prevItem = chain.getFirst(); - NetconfOperationFilterChain currentItem = new NetconfOperationFilterChain() { - @Override - public Document execute(Document message, NetconfOperationRouter operationRouter) - throws NetconfDocumentedException { - logger.trace("Entering {}", filter); - return filter.doFilter(message, operationRouter, prevItem); - } - }; - chain.push(currentItem); - } - return chain.getFirst().execute(message, this); + private Document executeOperationWithHighestPriority(Document message, + NetconfOperationExecution netconfOperationExecution, String messageAsString) + throws NetconfDocumentedException { + LOG.debug("Forwarding netconf message {} to {}", messageAsString, netconfOperationExecution.netconfOperation); + return netconfOperationExecution.execute(message); } private NetconfOperationExecution getNetconfOperationWithHighestPriority( - Document message, NetconfSession session) { + Document message, NetconfServerSession session) throws NetconfDocumentedException { - TreeMap> sortedPriority = getSortedNetconfOperationsWithCanHandle( + NavigableMap sortedByPriority = getSortedNetconfOperationsWithCanHandle( message, session); - Preconditions.checkArgument(sortedPriority.isEmpty() == false, "No %s available to handle message %s", - NetconfOperation.class.getName(), XmlUtil.toString(message)); - - HandlingPriority highestFoundPriority = sortedPriority.lastKey(); - - int netconfOperationsWithHighestPriority = sortedPriority.get(highestFoundPriority).size(); + Preconditions.checkArgument(sortedByPriority.isEmpty() == false, + "No %s available to handle message %s", NetconfOperation.class.getName(), + XmlUtil.toString(message)); - Preconditions.checkState(netconfOperationsWithHighestPriority == 1, - "Multiple %s available to handle message %s", NetconfOperation.class.getName(), message); - - return new NetconfOperationExecution(sortedPriority, highestFoundPriority); + return NetconfOperationExecution.createExecutionChain(sortedByPriority, sortedByPriority.lastKey()); } - private TreeMap> getSortedNetconfOperationsWithCanHandle( - Document message, NetconfSession session) { - TreeMap> sortedPriority = Maps.newTreeMap(); + private TreeMap getSortedNetconfOperationsWithCanHandle(Document message, + NetconfServerSession session) throws NetconfDocumentedException { + TreeMap sortedPriority = Maps.newTreeMap(); for (NetconfOperation netconfOperation : allNetconfOperations) { final HandlingPriority handlingPriority = netconfOperation.canHandle(message); if (netconfOperation instanceof DefaultNetconfOperation) { - ((DefaultNetconfOperation) netconfOperation) - .setNetconfSession(session); + ((DefaultNetconfOperation) netconfOperation).setNetconfSession(session); } - if (handlingPriority.equals(HandlingPriority.CANNOT_HANDLE) == false) { - Set netconfOperations = sortedPriority.get(handlingPriority); - netconfOperations = checkIfNoOperationsOnPriority(sortedPriority, handlingPriority, netconfOperations); - netconfOperations.add(netconfOperation); + if (!handlingPriority.equals(HandlingPriority.CANNOT_HANDLE)) { + + Preconditions.checkState(!sortedPriority.containsKey(handlingPriority), + "Multiple %s available to handle message %s with priority %s", + NetconfOperation.class.getName(), message, handlingPriority); + sortedPriority.put(handlingPriority, netconfOperation); } } return sortedPriority; } - private Set checkIfNoOperationsOnPriority( - TreeMap> sortedPriority, HandlingPriority handlingPriority, - Set netconfOperations) { - if (netconfOperations == null) { - netconfOperations = Sets.newHashSet(); - sortedPriority.put(handlingPriority, netconfOperations); + public static final NetconfOperationChainedExecution EXECUTION_TERMINATION_POINT = new NetconfOperationChainedExecution() { + @Override + public boolean isExecutionTermination() { + return true; } - return netconfOperations; - } - @Override - public void close() { - netconfOperationServiceSnapshot.close(); - } + @Override + public Document execute(Document requestMessage) throws NetconfDocumentedException { + throw new NetconfDocumentedException("This execution represents the termination point in operation execution and cannot be executed itself", + NetconfDocumentedException.ErrorType.application, + NetconfDocumentedException.ErrorTag.operation_failed, + NetconfDocumentedException.ErrorSeverity.error); + } + }; - private class NetconfOperationExecution implements NetconfOperationFilterChain { - private final NetconfOperation operationWithHighestPriority; + private static class NetconfOperationExecution implements NetconfOperationChainedExecution { + private final NetconfOperation netconfOperation; + private NetconfOperationChainedExecution subsequentExecution; - public NetconfOperationExecution(TreeMap> sortedPriority, - HandlingPriority highestFoundPriority) { - operationWithHighestPriority = sortedPriority.get(highestFoundPriority).iterator().next(); - sortedPriority.remove(highestFoundPriority); + private NetconfOperationExecution(NetconfOperation netconfOperation, NetconfOperationChainedExecution subsequentExecution) { + this.netconfOperation = netconfOperation; + this.subsequentExecution = subsequentExecution; } @Override - public Document execute(Document message, NetconfOperationRouter router) throws NetconfDocumentedException { - return operationWithHighestPriority.handle(message, router); + public boolean isExecutionTermination() { + return false; + } + + @Override + public Document execute(Document message) throws NetconfDocumentedException { + return netconfOperation.handle(message, subsequentExecution); + } + + public static NetconfOperationExecution createExecutionChain( + NavigableMap sortedByPriority, HandlingPriority handlingPriority) { + NetconfOperation netconfOperation = sortedByPriority.get(handlingPriority); + HandlingPriority subsequentHandlingPriority = sortedByPriority.lowerKey(handlingPriority); + + NetconfOperationChainedExecution subsequentExecution = null; + + if (subsequentHandlingPriority != null) { + subsequentExecution = createExecutionChain(sortedByPriority, subsequentHandlingPriority); + } else { + subsequentExecution = EXECUTION_TERMINATION_POINT; + } + + return new NetconfOperationExecution(netconfOperation, subsequentExecution); } } @@ -251,7 +242,4 @@ public class NetconfOperationRouterImpl implements NetconfOperationRouter { return "NetconfOperationRouterImpl{" + "netconfOperationServiceSnapshot=" + netconfOperationServiceSnapshot + '}'; } - - - }