private static final Logger LOG = LoggerFactory.getLogger(DefaultStartExi.class);
private NetconfServerSession netconfSession;
- public DefaultStartExi(String netconfSessionIdForReporting) {
+ public DefaultStartExi(final String netconfSessionIdForReporting) {
super(netconfSessionIdForReporting);
}
@Override
- public Document handle(Document message,
- NetconfOperationChainedExecution subsequentOperation) throws NetconfDocumentedException {
- LOG.debug("Received start-exi message {} ", XmlUtil.toString(message));
+ public Document handle(final Document message,
+ final NetconfOperationChainedExecution subsequentOperation) throws NetconfDocumentedException {
+ if (LOG.isDebugEnabled()) {
+ LOG.debug("Received start-exi message {} ", XmlUtil.toString(message));
+ }
try {
netconfSession.startExiCommunication(new NetconfMessage(message));
}
@Override
- protected Element handleWithNoSubsequentOperations(Document document, XmlElement operationElement) throws NetconfDocumentedException {
+ protected Element handleWithNoSubsequentOperations(final Document document, final XmlElement operationElement) throws NetconfDocumentedException {
Element getSchemaResult = document.createElementNS( XmlNetconfConstants.URN_IETF_PARAMS_XML_NS_NETCONF_BASE_1_0, XmlNetconfConstants.OK);
LOG.trace("{} operation successful", START_EXI);
return getSchemaResult;
}
@Override
- public void setNetconfSession(NetconfServerSession s) {
+ public void setNetconfSession(final NetconfServerSession s) {
netconfSession = s;
}
}
private final NetconfOperationServiceSnapshot netconfOperationServiceSnapshot;
private Set<NetconfOperation> allNetconfOperations;
- private NetconfOperationRouterImpl(NetconfOperationServiceSnapshot netconfOperationServiceSnapshot) {
+ private NetconfOperationRouterImpl(final NetconfOperationServiceSnapshot netconfOperationServiceSnapshot) {
this.netconfOperationServiceSnapshot = netconfOperationServiceSnapshot;
}
- private synchronized void initNetconfOperations(Set<NetconfOperation> allOperations) {
+ private synchronized void initNetconfOperations(final Set<NetconfOperation> allOperations) {
allNetconfOperations = allOperations;
}
/**
* Factory method to produce instance of NetconfOperationRouter
*/
- public static NetconfOperationRouter createOperationRouter(NetconfOperationServiceSnapshot netconfOperationServiceSnapshot,
- CapabilityProvider capabilityProvider, DefaultCommitNotificationProducer commitNotifier) {
+ public static NetconfOperationRouter createOperationRouter(final NetconfOperationServiceSnapshot netconfOperationServiceSnapshot,
+ final CapabilityProvider capabilityProvider, final DefaultCommitNotificationProducer commitNotifier) {
NetconfOperationRouterImpl router = new NetconfOperationRouterImpl(netconfOperationServiceSnapshot);
Preconditions.checkNotNull(netconfOperationServiceSnapshot);
return router;
}
- private static Set<NetconfOperation> getAllNetconfOperations(Set<NetconfOperation> defaultNetconfOperations,
- NetconfOperationServiceSnapshot netconfOperationServiceSnapshot) {
+ private static Set<NetconfOperation> getAllNetconfOperations(final Set<NetconfOperation> defaultNetconfOperations,
+ final NetconfOperationServiceSnapshot netconfOperationServiceSnapshot) {
Set<NetconfOperation> result = new HashSet<>();
result.addAll(defaultNetconfOperations);
}
@Override
- public synchronized Document onNetconfMessage(Document message,
- NetconfServerSession session) throws NetconfDocumentedException {
+ public synchronized Document onNetconfMessage(final Document message,
+ final NetconfServerSession session) throws NetconfDocumentedException {
Preconditions.checkNotNull(allNetconfOperations, "Operation router was not initialized properly");
NetconfOperationExecution netconfOperationExecution;
netconfOperationServiceSnapshot.close();
}
- private NetconfDocumentedException handleUnexpectedEx(String s, Exception e) throws NetconfDocumentedException {
+ private NetconfDocumentedException handleUnexpectedEx(final String s, final Exception e) throws NetconfDocumentedException {
LOG.error(s, e);
Map<String, String> info = Maps.newHashMap();
NetconfDocumentedException.ErrorSeverity.error, info);
}
- private Document executeOperationWithHighestPriority(Document message,
- NetconfOperationExecution netconfOperationExecution, String messageAsString)
+ private Document executeOperationWithHighestPriority(final Document message,
+ final NetconfOperationExecution netconfOperationExecution, final String messageAsString)
throws NetconfDocumentedException {
LOG.debug("Forwarding netconf message {} to {}", messageAsString, netconfOperationExecution.netconfOperation);
return netconfOperationExecution.execute(message);
}
private NetconfOperationExecution getNetconfOperationWithHighestPriority(
- Document message, NetconfServerSession session) throws NetconfDocumentedException {
+ final Document message, final NetconfServerSession session) throws NetconfDocumentedException {
NavigableMap<HandlingPriority, NetconfOperation> sortedByPriority = getSortedNetconfOperationsWithCanHandle(
message, session);
- Preconditions.checkArgument(sortedByPriority.isEmpty() == false,
- "No %s available to handle message %s", NetconfOperation.class.getName(),
- XmlUtil.toString(message));
+ if (sortedByPriority.isEmpty()) {
+ throw new IllegalArgumentException(String.format("No %s available to handle message %s",
+ NetconfOperation.class.getName(), XmlUtil.toString(message)));
+ }
return NetconfOperationExecution.createExecutionChain(sortedByPriority, sortedByPriority.lastKey());
}
- private TreeMap<HandlingPriority, NetconfOperation> getSortedNetconfOperationsWithCanHandle(Document message,
- NetconfServerSession session) throws NetconfDocumentedException {
+ private TreeMap<HandlingPriority, NetconfOperation> getSortedNetconfOperationsWithCanHandle(final Document message,
+ final NetconfServerSession session) throws NetconfDocumentedException {
TreeMap<HandlingPriority, NetconfOperation> sortedPriority = Maps.newTreeMap();
for (NetconfOperation netconfOperation : allNetconfOperations) {
}
@Override
- public Document execute(Document requestMessage) throws NetconfDocumentedException {
+ public Document execute(final 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,
private static class NetconfOperationExecution implements NetconfOperationChainedExecution {
private final NetconfOperation netconfOperation;
- private NetconfOperationChainedExecution subsequentExecution;
+ private final NetconfOperationChainedExecution subsequentExecution;
- private NetconfOperationExecution(NetconfOperation netconfOperation, NetconfOperationChainedExecution subsequentExecution) {
+ private NetconfOperationExecution(final NetconfOperation netconfOperation, final NetconfOperationChainedExecution subsequentExecution) {
this.netconfOperation = netconfOperation;
this.subsequentExecution = subsequentExecution;
}
}
@Override
- public Document execute(Document message) throws NetconfDocumentedException {
+ public Document execute(final Document message) throws NetconfDocumentedException {
return netconfOperation.handle(message, subsequentExecution);
}
public static NetconfOperationExecution createExecutionChain(
- NavigableMap<HandlingPriority, NetconfOperation> sortedByPriority, HandlingPriority handlingPriority) {
+ final NavigableMap<HandlingPriority, NetconfOperation> sortedByPriority, final HandlingPriority handlingPriority) {
NetconfOperation netconfOperation = sortedByPriority.get(handlingPriority);
HandlingPriority subsequentHandlingPriority = sortedByPriority.lowerKey(handlingPriority);
import io.netty.buffer.ByteBufUtil;
import io.netty.channel.ChannelHandlerContext;
import io.netty.handler.codec.ByteToMessageDecoder;
+import java.io.IOException;
import java.io.InputStream;
import java.util.List;
+import javax.xml.transform.TransformerConfigurationException;
import javax.xml.transform.TransformerFactory;
import javax.xml.transform.dom.DOMResult;
import javax.xml.transform.sax.SAXTransformerFactory;
import javax.xml.transform.sax.TransformerHandler;
import org.opendaylight.controller.netconf.api.NetconfMessage;
+import org.openexi.proc.common.EXIOptionsException;
import org.openexi.sax.EXIReader;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.w3c.dom.Document;
import org.xml.sax.InputSource;
+import org.xml.sax.SAXException;
public final class NetconfEXIToMessageDecoder extends ByteToMessageDecoder {
}
@Override
- protected void decode(final ChannelHandlerContext ctx, final ByteBuf in, final List<Object> out) throws Exception {
+ protected void decode(final ChannelHandlerContext ctx, final ByteBuf in, final List<Object> out) throws EXIOptionsException, IOException, SAXException, TransformerConfigurationException {
/*
* Note that we could loop here and process all the messages, but we can't do that.
* The reason is <stop-exi> operation, which has the contract of immediately stopping
*/
// If empty Byte buffer is passed to r.parse, EOFException is thrown
- if (in.isReadable() == false) {
+ if (!in.isReadable()) {
LOG.debug("No more content in incoming buffer.");
return;
}
- LOG.trace("Received to decode: {}", ByteBufUtil.hexDump(in));
+ if (LOG.isTraceEnabled()) {
+ LOG.trace("Received to decode: {}", ByteBufUtil.hexDump(in));
+ }
final EXIReader r = codec.getReader();
import io.netty.buffer.ByteBufOutputStream;
import io.netty.channel.ChannelHandlerContext;
import io.netty.handler.codec.MessageToByteEncoder;
+import java.io.IOException;
import java.io.OutputStream;
import javax.xml.transform.Transformer;
+import javax.xml.transform.TransformerException;
import javax.xml.transform.dom.DOMSource;
import javax.xml.transform.sax.SAXResult;
import javax.xml.transform.sax.SAXTransformerFactory;
import org.opendaylight.controller.netconf.api.NetconfMessage;
import org.opendaylight.controller.netconf.util.xml.XmlUtil;
+import org.openexi.proc.common.EXIOptionsException;
import org.openexi.sax.Transmogrifier;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
}
@Override
- protected void encode(final ChannelHandlerContext ctx, final NetconfMessage msg, final ByteBuf out) throws Exception {
- LOG.trace("Sent to encode : {}", XmlUtil.toString(msg.getDocument()));
+ protected void encode(final ChannelHandlerContext ctx, final NetconfMessage msg, final ByteBuf out) throws EXIOptionsException, IOException, TransformerException {
+ if (LOG.isTraceEnabled()) {
+ LOG.trace("Sent to encode : {}", XmlUtil.toString(msg.getDocument()));
+ }
try (final OutputStream os = new ByteBufOutputStream(out)) {
final Transmogrifier transmogrifier = codec.getTransmogrifier();
@Override
@VisibleForTesting
public void encode(ChannelHandlerContext ctx, NetconfMessage msg, ByteBuf out) throws IOException, TransformerException {
- LOG.trace("Sent to encode : {}", XmlUtil.toString(msg.getDocument()));
+ if (LOG.isTraceEnabled()) {
+ LOG.trace("Sent to encode : {}", XmlUtil.toString(msg.getDocument()));
+ }
if (clientId.isPresent()) {
Comment comment = msg.getDocument().createComment("clientId:" + clientId.get());
in.markReaderIndex();
try {
- LOG.trace("Received to decode: {}", ByteBufUtil.hexDump(in));
+ if (LOG.isTraceEnabled()) {
+ LOG.trace("Received to decode: {}", ByteBufUtil.hexDump(in));
+ }
+
byte[] bytes = new byte[in.readableBytes()];
in.readBytes(bytes);
import io.netty.buffer.ByteBufUtil;
import io.netty.channel.ChannelHandlerContext;
import io.netty.handler.codec.ByteToMessageDecoder;
+import java.io.IOException;
import java.util.List;
import org.opendaylight.controller.netconf.api.NetconfMessage;
import org.opendaylight.controller.netconf.util.xml.XmlUtil;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
+import org.xml.sax.SAXException;
public final class NetconfXMLToMessageDecoder extends ByteToMessageDecoder {
private static final Logger LOG = LoggerFactory.getLogger(NetconfXMLToMessageDecoder.class);
@Override
- public void decode(ChannelHandlerContext ctx, ByteBuf in, List<Object> out) throws Exception {
+ public void decode(final ChannelHandlerContext ctx, final ByteBuf in, final List<Object> out) throws IOException, SAXException {
+ if (in.isReadable()) {
+ if (LOG.isTraceEnabled()) {
+ LOG.trace("Received to decode: {}", ByteBufUtil.hexDump(in));
+ }
- if (in.readableBytes() != 0) {
- LOG.trace("Received to decode: {}", ByteBufUtil.hexDump(in));
out.add(new NetconfMessage(XmlUtil.readXmlToDocument(new ByteBufInputStream(in))));
} else {
LOG.debug("No more content in incoming buffer.");
f.addListener(new SendErrorVerifyingListener(sendErrorException));
}
- public static void sendErrorMessage(Channel channel, NetconfDocumentedException sendErrorException) {
+ public static void sendErrorMessage(final Channel channel, final NetconfDocumentedException sendErrorException) {
LOG.trace("Sending error {}", sendErrorException.getMessage(), sendErrorException);
final Document errorDocument = createDocument(sendErrorException);
ChannelFuture f = channel.writeAndFlush(new NetconfMessage(errorDocument));
f.addListener(new SendErrorVerifyingListener(sendErrorException));
}
- public static void sendErrorMessage(NetconfSession session, NetconfDocumentedException sendErrorException,
- NetconfMessage incommingMessage) {
+ public static void sendErrorMessage(final NetconfSession session, final NetconfDocumentedException sendErrorException,
+ final NetconfMessage incommingMessage) {
final Document errorDocument = createDocument(sendErrorException);
- LOG.trace("Sending error {}", XmlUtil.toString(errorDocument));
+ if (LOG.isTraceEnabled()) {
+ LOG.trace("Sending error {}", XmlUtil.toString(errorDocument));
+ }
+
tryToCopyAttributes(incommingMessage.getDocument(), errorDocument, sendErrorException);
ChannelFuture f = session.sendMessage(new NetconfMessage(errorDocument));
f.addListener(new SendErrorVerifyingListener(sendErrorException));