import static org.mockito.Matchers.eq;
import static org.mockito.Mockito.mock;
import static org.mockito.Mockito.when;
-
+import com.google.common.util.concurrent.Futures;
+import com.google.common.util.concurrent.ListenableFuture;
import java.net.URI;
import java.util.ArrayList;
import java.util.Collection;
import java.util.Date;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.Future;
-
import org.junit.Before;
import org.junit.Test;
import org.mockito.Mock;
import org.opendaylight.yangtools.yang.data.api.CompositeNode;
import org.opendaylight.yangtools.yang.data.impl.codec.BindingIndependentMappingService;
-import com.google.common.util.concurrent.Futures;
-import com.google.common.util.concurrent.ListenableFuture;
-
public class RpcInvocationStrategyTest {
@Mock
public class MockRpcService implements RpcService {
- public Future<?> rpcnameWithInputNoOutput(DataObject input) {
+ public Future<?> rpcnameWithInputNoOutput(final DataObject input) {
return futureDataObj;
}
- public Future<RpcResult<DataObject>> rpcnameWithInputWithOutput(DataObject input) {
+ public Future<RpcResult<DataObject>> rpcnameWithInputWithOutput(final DataObject input) {
return futureDataObj;
}
urn = new URI(new String("urn:a:valid:urn"));
}
- private void setupForForwardToDom(boolean hasOutput, boolean hasInput, int expectedErrorSize) {
+ private void setupForForwardToDom(final boolean hasOutput, final boolean hasInput, final int expectedErrorSize) {
if (expectedErrorSize > 0) {
errors.add(rpcError);
}
- private void validateForwardToDomBroker(ListenableFuture<RpcResult<?>> forwardToDomBroker,
- boolean expectedSuccess, DataObject expectedResult, int expectedErrorSize)
+ private void validateForwardToDomBroker(final ListenableFuture<RpcResult<?>> forwardToDomBroker,
+ final boolean expectedSuccess, final DataObject expectedResult, final int expectedErrorSize)
throws InterruptedException, ExecutionException {
assertNotNull(forwardToDomBroker);
assertEquals(expectedSuccess, forwardToDomBroker.get().isSuccessful());
assertEquals(expectedErrorSize, forwardToDomBroker.get().getErrors().size());
}
- private void setupTestMethod(String rpcName, String testMethodName, boolean hasInput)
+ private void setupTestMethod(final String rpcName, final String testMethodName, final boolean hasInput)
throws NoSuchMethodException {
- mockQName = new QName(urn, new Date(0L), new String("prefix"), new String(rpcName));
+ mockQName = QName.create(urn, new Date(0L), new String(rpcName));
java.lang.reflect.Method rpcMethod = hasInput ? MockRpcService.class.getMethod(rpcName,
DataObject.class) : MockRpcService.class.getMethod(rpcName);
rpcInvocationStrategy = new RpcInvocationStrategy(mockQName, rpcMethod, mockMappingService,
/*
* invokeOn Tests
*/
- private void setupRpcResultsWithOutput(int expectedErrorSize) {
+ private void setupRpcResultsWithOutput(final int expectedErrorSize) {
if (expectedErrorSize > 0) {
errors.add(rpcError);
}
when(mockMappingService.toDataDom(toDataDomInput)).thenReturn(outputInvokeOn);
}
- private void setupRpcResultsNoOutput(int expectedErrorSize) {
+ private void setupRpcResultsNoOutput(final int expectedErrorSize) {
if (expectedErrorSize > 0) {
errors.add(rpcError);
}
}
private void validateReturnedImmediateFuture(
- ListenableFuture<RpcResult<CompositeNode>> immediateFuture, boolean expectedSuccess,
- CompositeNode expectedReturn, int expectedErrorSize) throws InterruptedException,
+ final ListenableFuture<RpcResult<CompositeNode>> immediateFuture, final boolean expectedSuccess,
+ final CompositeNode expectedReturn, final int expectedErrorSize) throws InterruptedException,
ExecutionException {
assertNotNull(immediateFuture);
assertEquals(expectedSuccess, immediateFuture.get().isSuccessful());
String encodeQName(final QName qname) {
String prefix = prefixes.get(qname.getNamespace());
if (prefix == null) {
- prefix = qname.getPrefix();
- if (prefix == null || prefix.isEmpty() || prefixes.containsValue(prefix)) {
- final ThreadLocalRandom random = ThreadLocalRandom.current();
- do {
- final StringBuilder sb = new StringBuilder();
- for (int i = 0; i < 4; i++) {
- sb.append((char)('a' + random.nextInt(25)));
- }
-
- prefix = sb.toString();
- } while (prefixes.containsValue(prefix));
- }
-
+ final ThreadLocalRandom random = ThreadLocalRandom.current();
+ do {
+ final StringBuilder sb = new StringBuilder();
+ for (int i = 0; i < 4; i++) {
+ sb.append((char)('a' + random.nextInt(25)));
+ }
+
+ prefix = sb.toString();
+ } while (prefixes.containsValue(prefix));
prefixes.put(qname.getNamespace(), prefix);
}
import com.google.common.annotations.Beta;
import com.google.common.base.Preconditions;
+import java.net.URI;
+import java.util.Map.Entry;
+import javax.annotation.Nonnull;
+import javax.annotation.Nullable;
+import javax.xml.stream.XMLStreamException;
+import javax.xml.stream.XMLStreamWriter;
import org.opendaylight.yangtools.yang.common.QName;
import org.opendaylight.yangtools.yang.data.api.AttributesContainer;
import org.opendaylight.yangtools.yang.data.api.CompositeNode;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
-import javax.annotation.Nonnull;
-import javax.annotation.Nullable;
-import javax.xml.stream.XMLStreamException;
-import javax.xml.stream.XMLStreamWriter;
-import java.net.URI;
-import java.util.Map.Entry;
-
/**
* Utility class for bridging JAXP Stream and YANG Data APIs. Note that the definition of this class
* by no means final and subject to change as more functionality is centralized here.
*/
public void writeElement(final XMLStreamWriter writer, final @Nonnull Node<?> data, final SchemaNode schema) throws XMLStreamException {
final QName qname = data.getNodeType();
- final String pfx = qname.getPrefix() != null ? qname.getPrefix() : "";
final String ns = qname.getNamespace() != null ? qname.getNamespace().toString() : "";
if (isEmptyElement(data)) {
- writer.writeEmptyElement(pfx, qname.getLocalName(), ns);
+ writer.writeEmptyElement("", qname.getLocalName(), ns);
return;
}
- writer.writeStartElement(pfx, qname.getLocalName(), ns);
+ writer.writeStartElement("", qname.getLocalName(), ns);
if (data instanceof AttributesContainer && ((AttributesContainer) data).getAttributes() != null) {
for (Entry<QName, String> attribute : ((AttributesContainer) data).getAttributes().entrySet()) {
writer.writeAttribute(attribute.getKey().getNamespace().toString(), attribute.getKey().getLocalName(), attribute.getValue());
private static void write(final @Nonnull XMLStreamWriter writer, final @Nonnull IdentityrefTypeDefinition type, final @Nonnull Object value) throws XMLStreamException {
if (value instanceof QName) {
final QName qname = (QName) value;
- final String prefix;
- if (qname.getPrefix() != null && !qname.getPrefix().isEmpty()) {
- prefix = qname.getPrefix();
- } else {
- prefix = "x";
- }
- writer.writeNamespace(prefix, qname.getNamespace().toString());
- writer.writeCharacters(prefix + ':' + qname.getLocalName());
+ writer.writeNamespace("x", qname.getNamespace().toString());
+ writer.writeCharacters("x:" + qname.getLocalName());
} else {
if(LOG.isDebugEnabled()) {
LOG.debug("Value of {}:{} is not a QName but {}", type.getQName().getNamespace(), type.getQName().getLocalName(), value.getClass());
}
public static IdentityValuesDTO asInstanceIdentifier(final String value, final PrefixesMaping prefixMap) {
- String valueTrimmed = value.trim();
+ final String valueTrimmed = value.trim();
if (!valueTrimmed.startsWith("/")) {
return null;
}
- String[] xPathParts = valueTrimmed.split("/");
+ final String[] xPathParts = valueTrimmed.split("/");
if (xPathParts.length < 2) { // must be at least "/pr:node"
return null;
}
- IdentityValuesDTO identityValuesDTO = new IdentityValuesDTO(value);
+ final IdentityValuesDTO identityValuesDTO = new IdentityValuesDTO(value);
for (int i = 1; i < xPathParts.length; i++) {
- String xPathPartTrimmed = xPathParts[i].trim();
+ final String xPathPartTrimmed = xPathParts[i].trim();
- String xPathPartStr = getIdAndPrefixAsStr(xPathPartTrimmed);
- IdentityValue identityValue = toIdentity(xPathPartStr, prefixMap);
+ final String xPathPartStr = getIdAndPrefixAsStr(xPathPartTrimmed);
+ final IdentityValue identityValue = toIdentity(xPathPartStr, prefixMap);
if (identityValue == null) {
return null;
}
- List<Predicate> predicates = toPredicates(xPathPartTrimmed, prefixMap);
+
final List<Predicate> predicates = toPredicates(xPathPartTrimmed, prefixMap);
if (predicates == null) {
return null;
}
}
private static String getIdAndPrefixAsStr(final String pathPart) {
- int predicateStartIndex = pathPart.indexOf("[");
+ final int predicateStartIndex = pathPart.indexOf("[");
return predicateStartIndex == -1 ? pathPart : pathPart.substring(0, predicateStartIndex);
}
private static IdentityValue toIdentity(final String xPathPart, final PrefixesMaping prefixMap) {
- String xPathPartTrimmed = xPathPart.trim();
+ final String xPathPartTrimmed = xPathPart.trim();
if (xPathPartTrimmed.isEmpty()) {
return null;
}
- String[] prefixAndIdentifier = xPathPartTrimmed.split(":");
+ final String[] prefixAndIdentifier = xPathPartTrimmed.split(":");
// it is not "prefix:value"
if (prefixAndIdentifier.length != 2) {
return null;
}
- String prefix = prefixAndIdentifier[0].trim();
- String identifier = prefixAndIdentifier[1].trim();
+ final String prefix = prefixAndIdentifier[0].trim();
+ final String identifier = prefixAndIdentifier[1].trim();
if (prefix.isEmpty() || identifier.isEmpty()) {
return null;
}
- String namespace = prefixMap.getNamespace(prefix);
- return new IdentityValue(namespace, identifier, namespace.equals(prefix) ? null : prefix);
+ final String namespace = prefixMap.getNamespace(prefix);
+ return new IdentityValue(namespace, identifier);
}
private static List<Predicate> toPredicates(final String predicatesStr, final PrefixesMaping prefixMap) {
- List<Predicate> result = new ArrayList<>();
- List<String> predicates = new ArrayList<>();
- Matcher matcher = PREDICATE_PATTERN.matcher(predicatesStr);
+
final List<Predicate> result = new ArrayList<>();
+ final List<String> predicates = new ArrayList<>();
+ final Matcher matcher = PREDICATE_PATTERN.matcher(predicatesStr);
while (matcher.find()) {
predicates.add(matcher.group(1).trim());
}
- for (String predicate : predicates) {
- int indexOfEqualityMark = predicate.indexOf("=");
+ for (final String predicate : predicates) {
+ final int indexOfEqualityMark = predicate.indexOf("=");
if (indexOfEqualityMark != -1) {
- String predicateValue = toPredicateValue(predicate.substring(indexOfEqualityMark + 1));
+ final String predicateValue = toPredicateValue(predicate.substring(indexOfEqualityMark + 1));
if (predicate.startsWith(".")) { // it is leaf-list
if (predicateValue == null) {
return null;
}
result.add(new Predicate(null, predicateValue));
} else {
- IdentityValue identityValue = toIdentity(predicate.substring(0, indexOfEqualityMark), prefixMap);
+ final IdentityValue identityValue = toIdentity(predicate.substring(0, indexOfEqualityMark), prefixMap);
if (identityValue == null || predicateValue == null) {
return null;
}
}
private static String toPredicateValue(final String predicatedValue) {
- String predicatedValueTrimmed = predicatedValue.trim();
+ final String predicatedValueTrimmed = predicatedValue.trim();
if ((predicatedValueTrimmed.startsWith(DQUOTE) || predicatedValueTrimmed.startsWith(SQUOTE))
&& (predicatedValueTrimmed.endsWith(DQUOTE) || predicatedValueTrimmed.endsWith(SQUOTE))) {
return predicatedValueTrimmed.substring(1, predicatedValueTrimmed.length() - 1);
private final List<IdentityValue> elementData = new ArrayList<>();
private final String originValue;
- public IdentityValuesDTO(String namespace, String value, String prefix, String originValue) {
- elementData.add(new IdentityValue(namespace, value, prefix));
+ public IdentityValuesDTO(final String namespace, final String value, final String prefix, final String originValue) {
+ elementData.add(new IdentityValue(namespace, value));
this.originValue = originValue;
}
- public IdentityValuesDTO(String originValue) {
+ public IdentityValuesDTO(final String originValue) {
this.originValue = originValue;
}
originValue = null;
}
- public void add(String namespace, String value, String prefix) {
- elementData.add(new IdentityValue(namespace, value, prefix));
+ public void add(final String namespace, final String value, final String prefix) {
+ elementData.add(new IdentityValue(namespace, value));
}
- public void add(IdentityValue identityValue) {
+ public void add(final IdentityValue identityValue) {
elementData.add(identityValue);
}
private final String namespace;
private final String value;
- private final String prefix;
private List<Predicate> predicates;
- public IdentityValue(String namespace, String value, String prefix) {
+ public IdentityValue(final String namespace, final String value) {
this.namespace = namespace;
this.value = value;
- this.prefix = prefix;
}
public String getNamespace() {
return value;
}
- public String getPrefix() {
- return prefix;
- }
public List<Predicate> getPredicates() {
if (predicates == null) {
return Collections.unmodifiableList(predicates);
}
- public void setPredicates(List<Predicate> predicates) {
+ public void setPredicates(
final List<Predicate> predicates) {
this.predicates = predicates;
}
@Override
public String toString() {
- StringBuilder sb = new StringBuilder();
+ final StringBuilder sb = new StringBuilder();
if (namespace != null) {
sb.append(namespace);
}
- if (prefix != null) {
- sb.append("(").append(prefix).append(")");
- }
if (value != null) {
sb.append(" - ").append(value);
}
if (predicates != null && !predicates.isEmpty()) {
- for (Predicate predicate : predicates) {
+ for (final Predicate predicate : predicates) {
sb.append("[");
predicate.toString();
sb.append("]");
private final IdentityValue name;
private final String value;
- public Predicate(IdentityValue name, String value) {
+ public Predicate(final IdentityValue name, final String value) {
super();
this.name = name;
this.value = value;
@Override
public String toString() {
- StringBuilder sb = new StringBuilder();
+ final StringBuilder sb = new StringBuilder();
if (name != null) {
sb.append(name.toString());
}
input == null ? "null" : input.getClass(), String.valueOf(input));
return null;
} else {
- TypeDefinitionAwareCodec<Object, ? extends TypeDefinition<?>> typeAwarecodec = TypeDefinitionAwareCodec
+ final TypeDefinitionAwareCodec<Object, ? extends TypeDefinition<?>> typeAwarecodec = TypeDefinitionAwareCodec
.from(type);
if (typeAwarecodec != null) {
if (input instanceof IdentityValuesDTO) {
return null;
}
}
- } catch (ClassCastException e) { // TODO remove this catch when everyone use codecs
+ } catch (final ClassCastException e) { // TODO remove this catch when everyone use codecs
logger.error(
"ClassCastException was thrown when codec is invoked with parameter " + String.valueOf(input),
e);
} else if (type instanceof InstanceIdentifierTypeDefinition) {
return instanceIdentifier.serialize(input);
} else {
- TypeDefinitionAwareCodec<Object, ? extends TypeDefinition<?>> typeAwarecodec = TypeDefinitionAwareCodec
+ final TypeDefinitionAwareCodec<Object, ? extends TypeDefinition<?>> typeAwarecodec = TypeDefinitionAwareCodec
.from(type);
if (typeAwarecodec != null) {
return typeAwarecodec.serialize(input);
return null;
}
}
- } catch (ClassCastException e) { // TODO remove this catch when everyone use codecs
+ } catch (final ClassCastException e) { // TODO remove this catch when everyone use codecs
logger.error(
"ClassCastException was thrown when codec is invoked with parameter " + String.valueOf(input),
e);
@Override
public IdentityValuesDTO serialize(final QName data) {
- return new IdentityValuesDTO(data.getNamespace().toString(), data.getLocalName(), data.getPrefix(), null);
+ return new IdentityValuesDTO(data.getNamespace().toString(), data.getLocalName(), null, null);
}
@Override
public QName deserialize(final IdentityValuesDTO data) {
- IdentityValue valueWithNamespace = data.getValuesWithNamespaces().get(0);
- Module module = getModuleByNamespace(valueWithNamespace.getNamespace(), mountPoint);
+ final IdentityValue valueWithNamespace = data.getValuesWithNamespaces().get(0);
+ final Module module = getModuleByNamespace(valueWithNamespace.getNamespace(), mountPoint);
if (module == null) {
logger.info("Module was not found for namespace {}", valueWithNamespace.getNamespace());
logger.info("Idenetityref will be translated as NULL for data - {}", String.valueOf(valueWithNamespace));
@Override
public IdentityValuesDTO serialize(final YangInstanceIdentifier data) {
- IdentityValuesDTO identityValuesDTO = new IdentityValuesDTO();
- for (PathArgument pathArgument : data.getPathArguments()) {
- IdentityValue identityValue = qNameToIdentityValue(pathArgument.getNodeType());
+ final IdentityValuesDTO identityValuesDTO = new IdentityValuesDTO();
+ for (final PathArgument pathArgument : data.getPathArguments()) {
+ final IdentityValue identityValue = qNameToIdentityValue(pathArgument.getNodeType());
if (pathArgument instanceof NodeIdentifierWithPredicates && identityValue != null) {
- List<Predicate> predicates = keyValuesToPredicateList(((NodeIdentifierWithPredicates) pathArgument)
+
final List<Predicate> predicates = keyValuesToPredicateList(((NodeIdentifierWithPredicates) pathArgument)
.getKeyValues());
identityValue.setPredicates(predicates);
} else if (pathArgument instanceof NodeWithValue && identityValue != null) {
- List<Predicate> predicates = new ArrayList<>();
- String value = String.valueOf(((NodeWithValue) pathArgument).getValue());
+
final List<Predicate> predicates = new ArrayList<>();
+ final String value = String.valueOf(((NodeWithValue) pathArgument).getValue());
predicates.add(new Predicate(null, value));
identityValue.setPredicates(predicates);
}
@Override
public YangInstanceIdentifier deserialize(final IdentityValuesDTO data) {
- List<PathArgument> result = new ArrayList<PathArgument>();
- IdentityValue valueWithNamespace = data.getValuesWithNamespaces().get(0);
- Module module = getModuleByNamespace(valueWithNamespace.getNamespace(), mountPoint);
+
final List<PathArgument> result = new ArrayList<PathArgument>();
+ final IdentityValue valueWithNamespace = data.getValuesWithNamespaces().get(0);
+ final Module module = getModuleByNamespace(valueWithNamespace.getNamespace(), mountPoint);
if (module == null) {
logger.info("Module by namespace '{}' of first node in instance-identifier was not found.",
valueWithNamespace.getNamespace());
}
DataNodeContainer parentContainer = module;
- List<IdentityValue> identities = data.getValuesWithNamespaces();
+ final List<IdentityValue> identities = data.getValuesWithNamespaces();
for (int i = 0; i < identities.size(); i++) {
- IdentityValue identityValue = identities.get(i);
+ final IdentityValue identityValue = identities.get(i);
URI validNamespace = resolveValidNamespace(identityValue.getNamespace(), mountPoint);
- DataSchemaNode node = ControllerContext.findInstanceDataChildByNameAndNamespace(
+ final DataSchemaNode node = ControllerContext.findInstanceDataChildByNameAndNamespace(
parentContainer, identityValue.getValue(), validNamespace);
if (node == null) {
logger.info("'{}' node was not found in {}", identityValue, parentContainer.getChildNodes());
String.valueOf(identityValue.getValue()));
return null;
}
- QName qName = node.getQName();
+ final QName qName = node.getQName();
PathArgument pathArgument = null;
if (identityValue.getPredicates().isEmpty()) {
pathArgument = new NodeIdentifier(qName);
} else {
if (node instanceof LeafListSchemaNode) { // predicate is value of leaf-list entry
- Predicate leafListPredicate = identityValue.getPredicates().get(0);
+ final Predicate leafListPredicate = identityValue.getPredicates().get(0);
if (!leafListPredicate.isLeafList()) {
logger.info("Predicate's data is not type of leaf-list. It should be in format \".='value'\"");
logger.info("Instance-identifier will be translated as NULL for data - {}",
}
pathArgument = new NodeWithValue(qName, leafListPredicate.getValue());
} else if (node instanceof ListSchemaNode) { // predicates are keys of list
- DataNodeContainer listNode = (DataNodeContainer) node;
- Map<QName, Object> predicatesMap = new HashMap<>();
- for (Predicate predicate : identityValue.getPredicates()) {
+ final DataNodeContainer listNode = (DataNodeContainer) node;
+ final Map<QName, Object> predicatesMap = new HashMap<>();
+ for (final Predicate predicate : identityValue.getPredicates()) {
validNamespace = resolveValidNamespace(predicate.getName().getNamespace(), mountPoint);
- DataSchemaNode listKey = ControllerContext
+ final DataSchemaNode listKey = ControllerContext
.findInstanceDataChildByNameAndNamespace(listNode, predicate.getName().getValue(),
validNamespace);
predicatesMap.put(listKey.getQName(), predicate.getValue());
}
private List<Predicate> keyValuesToPredicateList(final Map<QName, Object> keyValues) {
- List<Predicate> result = new ArrayList<>();
- for (QName qName : keyValues.keySet()) {
- Object value = keyValues.get(qName);
+
final List<Predicate> result = new ArrayList<>();
+ for (final QName qName : keyValues.keySet()) {
+ final Object value = keyValues.get(qName);
result.add(new Predicate(qNameToIdentityValue(qName), String.valueOf(value)));
}
return result;
private IdentityValue qNameToIdentityValue(final QName qName) {
if (qName != null) {
- return new IdentityValue(qName.getNamespace().toString(), qName.getLocalName(), qName.getPrefix());
+ return new IdentityValue(qName.getNamespace().toString(), qName.getLocalName());
}
return null;
}
}
private static Module getModuleByNamespace(final String namespace, final DOMMountPoint mountPoint) {
- URI validNamespace = resolveValidNamespace(namespace, mountPoint);
+ final URI validNamespace = resolveValidNamespace(namespace, mountPoint);
Module module = null;
if (mountPoint != null) {
}
@Override
- public void onDataChanged(AsyncDataChangeEvent<YangInstanceIdentifier, NormalizedNode<?, ?>> change) {
+ public void onDataChanged(final AsyncDataChangeEvent<YangInstanceIdentifier, NormalizedNode<?, ?>> change) {
// TODO Auto-generated method stub
if (!change.getCreatedData().isEmpty() || !change.getUpdatedData().isEmpty()
|| !change.getRemovedPaths().isEmpty()) {
- String xml = prepareXmlFrom(change);
- Event event = new Event(EventType.NOTIFY);
+ final String xml = prepareXmlFrom(change);
+ final Event event = new Event(EventType.NOTIFY);
event.setData(xml);
eventBus.post(event);
}
@Subscribe
public void recordCustomerChange(final Event event) {
if (event.getType() == EventType.REGISTER) {
- Channel subscriber = event.getSubscriber();
+ final Channel subscriber = event.getSubscriber();
if (!subscribers.contains(subscriber)) {
subscribers.add(subscriber);
}
subscribers.remove(event.getSubscriber());
Notificator.removeListenerIfNoSubscriberExists(ListenerAdapter.this);
} else if (event.getType() == EventType.NOTIFY) {
- for (Channel subscriber : subscribers) {
+ for (final Channel subscriber : subscribers) {
if (subscriber.isActive()) {
LOG.debug("Data are sent to subscriber {}:", subscriber.remoteAddress());
subscriber.writeAndFlush(new TextWebSocketFrame(event.getData()));
* DataChangeEvent
* @return Data in printable form.
*/
- private String prepareXmlFrom(AsyncDataChangeEvent<YangInstanceIdentifier, NormalizedNode<?, ?>> change) {
- Document doc = createDocument();
- Element notificationElement = doc.createElementNS("urn:ietf:params:xml:ns:netconf:notification:1.0",
+ private String prepareXmlFrom(final AsyncDataChangeEvent<YangInstanceIdentifier, NormalizedNode<?, ?>> change) {
+ final Document doc = createDocument();
+ final Element notificationElement = doc.createElementNS("urn:ietf:params:xml:ns:netconf:notification:1.0",
"notification");
doc.appendChild(notificationElement);
- Element eventTimeElement = doc.createElement("eventTime");
+ final Element eventTimeElement = doc.createElement("eventTime");
eventTimeElement.setTextContent(toRFC3339(new Date()));
notificationElement.appendChild(eventTimeElement);
- Element dataChangedNotificationEventElement = doc.createElementNS(
+ final Element dataChangedNotificationEventElement = doc.createElementNS(
"urn:opendaylight:params:xml:ns:yang:controller:md:sal:remote", "data-changed-notification");
addValuesToDataChangedNotificationEventElement(doc, dataChangedNotificationEventElement, change);
notificationElement.appendChild(dataChangedNotificationEventElement);
try {
- ByteArrayOutputStream out = new ByteArrayOutputStream();
- Transformer transformer = FACTORY.newTransformer();
+ final ByteArrayOutputStream out = new ByteArrayOutputStream();
+ final Transformer transformer = FACTORY.newTransformer();
transformer.setOutputProperty(OutputKeys.OMIT_XML_DECLARATION, "no");
transformer.setOutputProperty(OutputKeys.METHOD, "xml");
transformer.setOutputProperty(OutputKeys.INDENT, "yes");
transformer.setOutputProperty(OutputKeys.ENCODING, "UTF-8");
transformer.setOutputProperty("{http://xml.apache.org/xslt}indent-amount", "4");
transformer.transform(new DOMSource(doc), new StreamResult(new OutputStreamWriter(out, Charsets.UTF_8)));
- byte[] charData = out.toByteArray();
+ final byte[] charData = out.toByteArray();
return new String(charData, "UTF-8");
} catch (TransformerException | UnsupportedEncodingException e) {
- String msg = "Error during transformation of Document into String";
+ final String msg = "Error during transformation of Document into String";
LOG.error(msg, e);
return msg;
}
final DocumentBuilder bob;
try {
bob = DBF.newDocumentBuilder();
- } catch (ParserConfigurationException e) {
+ } catch (final ParserConfigurationException e) {
return null;
}
return bob.newDocument();
*/
private void addValuesToDataChangedNotificationEventElement(final Document doc,
final Element dataChangedNotificationEventElement,
- AsyncDataChangeEvent<YangInstanceIdentifier, NormalizedNode<?, ?>> change) {
+ final AsyncDataChangeEvent<YangInstanceIdentifier, NormalizedNode<?, ?>> change) {
addValuesFromDataToElement(doc, change.getCreatedData().keySet(), dataChangedNotificationEventElement,
Operation.CREATED);
if (change.getCreatedData().isEmpty()) {
* @param operation
* {@link Operation}
*/
- private void addValuesFromDataToElement(Document doc, Set<YangInstanceIdentifier> data, Element element,
- Operation operation) {
+ private void addValuesFromDataToElement(final Document doc, final Set<YangInstanceIdentifier> data, final Element element,
+ final Operation operation) {
if (data == null || data.isEmpty()) {
return;
}
- for (YangInstanceIdentifier path : data) {
- Node node = createDataChangeEventElement(doc, path, null, operation);
+ for (final YangInstanceIdentifier path : data) {
+ final Node node = createDataChangeEventElement(doc, path, null, operation);
element.appendChild(node);
}
}
* @param operation
* {@link Operation}
*/
- private void addValuesFromDataToElement(Document doc, Map<YangInstanceIdentifier, CompositeNode> data, Element element,
- Operation operation) {
+ private void addValuesFromDataToElement(final Document doc, final Map<YangInstanceIdentifier, CompositeNode> data, final Element element,
+ final Operation operation) {
if (data == null || data.isEmpty()) {
return;
}
- for (Entry<YangInstanceIdentifier, CompositeNode> entry : data.entrySet()) {
- Node node = createDataChangeEventElement(doc, entry.getKey(), entry.getValue(), operation);
+ for (final Entry<YangInstanceIdentifier, CompositeNode> entry : data.entrySet()) {
+ final Node node = createDataChangeEventElement(doc, entry.getKey(), entry.getValue(), operation);
element.appendChild(node);
}
}
* {@link Operation}
* @return {@link Node} node represented by changed event element.
*/
- private Node createDataChangeEventElement(Document doc, YangInstanceIdentifier path, CompositeNode data,
- Operation operation) {
- Element dataChangeEventElement = doc.createElement("data-change-event");
-
- Element pathElement = doc.createElement("path");
+ private Node createDataChangeEventElement(final Document doc, final YangInstanceIdentifier path, final CompositeNode data,
+ final Operation operation) {
+ final Element dataChangeEventElement = doc.createElement("data-change-event");
+ final Element pathElement = doc.createElement("path");
addPathAsValueToElement(path, pathElement);
dataChangeEventElement.appendChild(pathElement);
// storeElement.setTextContent(store.value);
// dataChangeEventElement.appendChild(storeElement);
- Element operationElement = doc.createElement("operation");
+ final Element operationElement = doc.createElement("operation");
operationElement.setTextContent(operation.value);
dataChangeEventElement.appendChild(operationElement);
if (data != null) {
- Element dataElement = doc.createElement("data");
- Node dataAnyXml = translateToXml(path, data);
- Node adoptedNode = doc.adoptNode(dataAnyXml);
+ final Element dataElement = doc.createElement("data");
+ final Node dataAnyXml = translateToXml(path, data);
+ final Node adoptedNode = doc.adoptNode(dataAnyXml);
dataElement.appendChild(adoptedNode);
dataChangeEventElement.appendChild(dataElement);
}
* @return Data in XML format.
*/
private Node translateToXml(final YangInstanceIdentifier path, final CompositeNode data) {
- DataNodeContainer schemaNode = ControllerContext.getInstance().getDataNodeContainerFor(path);
+ final DataNodeContainer schemaNode = ControllerContext.getInstance().getDataNodeContainerFor(path);
if (schemaNode == null) {
LOG.info(
"Path '{}' contains node with unsupported type (supported type is Container or List) or some node was not found.",
return null;
}
try {
- Document xml = xmlMapper.write(data, schemaNode);
+ final Document xml = xmlMapper.write(data, schemaNode);
return xml.getFirstChild();
- } catch (UnsupportedDataTypeException e) {
+ } catch (final UnsupportedDataTypeException e) {
LOG.error("Error occured during translation of notification to XML.", e);
return null;
}
*/
private void addPathAsValueToElement(final YangInstanceIdentifier path, final Element element) {
// Map< key = namespace, value = prefix>
- Map<String, String> prefixes = new HashMap<>();
- YangInstanceIdentifier instanceIdentifier = path;
- StringBuilder textContent = new StringBuilder();
+ final Map<String, String> prefixes = new HashMap<>();
+ final YangInstanceIdentifier instanceIdentifier = path;
+ final StringBuilder textContent = new StringBuilder();
// FIXME: BUG-1281: this is duplicated code from yangtools (BUG-1275)
- for (PathArgument pathArgument : instanceIdentifier.getPathArguments()) {
+ for (final PathArgument pathArgument : instanceIdentifier.getPathArguments()) {
textContent.append("/");
writeIdentifierWithNamespacePrefix(element, textContent, pathArgument.getNodeType(), prefixes);
if (pathArgument instanceof NodeIdentifierWithPredicates) {
- Map<QName, Object> predicates = ((NodeIdentifierWithPredicates) pathArgument).getKeyValues();
- for (QName keyValue : predicates.keySet()) {
- String predicateValue = String.valueOf(predicates.get(keyValue));
+ final Map<QName, Object> predicates = ((NodeIdentifierWithPredicates) pathArgument).getKeyValues();
+ for (final QName keyValue : predicates.keySet()) {
+ final String predicateValue = String.valueOf(predicates.get(keyValue));
textContent.append("[");
writeIdentifierWithNamespacePrefix(element, textContent, keyValue, prefixes);
textContent.append("='");
*/
private static void writeIdentifierWithNamespacePrefix(final Element element, final StringBuilder textContent,
final QName qName, final Map<String, String> prefixes) {
- String namespace = qName.getNamespace().toString();
+ final String namespace = qName.getNamespace().toString();
String prefix = prefixes.get(namespace);
if (prefix == null) {
- prefix = qName.getPrefix();
- if (prefix == null || prefix.isEmpty() || prefixes.containsValue(prefix)) {
- prefix = generateNewPrefix(prefixes.values());
- }
+ prefix = generateNewPrefix(prefixes.values());
}
element.setAttribute("xmlns:" + prefix, namespace);
*/
private static String generateNewPrefix(final Collection<String> prefixes) {
StringBuilder result = null;
- Random random = new Random();
+ final Random random = new Random();
do {
result = new StringBuilder();
for (int i = 0; i < 4; i++) {
- int randomNumber = 0x61 + (Math.abs(random.nextInt()) % 26);
+ final int randomNumber = 0x61 + (Math.abs(random.nextInt()) % 26);
result.append(Character.toChars(randomNumber));
}
} while (prefixes.contains(result.toString()));
if (!subscriber.isActive()) {
LOG.debug("Channel is not active between websocket server and subscriber {}" + subscriber.remoteAddress());
}
- Event event = new Event(EventType.REGISTER);
+ final Event event = new Event(EventType.REGISTER);
event.setSubscriber(subscriber);
eventBus.post(event);
}
*/
public void removeSubscriber(final Channel subscriber) {
LOG.debug("Subscriber {} is removed.", subscriber.remoteAddress());
- Event event = new Event(EventType.DEREGISTER);
+ final Event event = new Event(EventType.DEREGISTER);
event.setSubscriber(subscriber);
eventBus.post(event);
}
@Test
public void snAsYangIdentityrefWithQNamePrefixToXMLTest() {
serializeToXml(prepareIdentityrefData("prefix", true),
- "<lf11 xmlns:prefix=\"referenced:module\">prefix:iden</lf11>");
+ "<lf11 xmlns","=\"referenced:module\">",":iden</lf11>");
}
@Test
@Test
public void snAsYangInt8ToXmlTest() {
- String elName = "lfInt8";
+ final String elName = "lfInt8";
serializeToXml(
prepareCnStructForYangData(TypeDefinitionAwareCodec.from(Int8.getInstance()).deserialize("14"), elName),
"<" + elName + ">14</" + elName + ">");
@Test
public void snAsYangInt16ToXmlTest() {
- String elName = "lfInt16";
+ final String elName = "lfInt16";
serializeToXml(
prepareCnStructForYangData(TypeDefinitionAwareCodec.from(Int16.getInstance()).deserialize("3000"),
elName), "<" + elName + ">3000</" + elName + ">");
@Test
public void snAsYangInt32ToXmlTest() {
- String elName = "lfInt32";
+ final String elName = "lfInt32";
serializeToXml(
prepareCnStructForYangData(TypeDefinitionAwareCodec.from(Int32.getInstance()).deserialize("201234"),
elName), "<" + elName + ">201234</" + elName + ">");
@Test
public void snAsYangInt64ToXmlTest() {
- String elName = "lfInt64";
+ final String elName = "lfInt64";
serializeToXml(
prepareCnStructForYangData(
TypeDefinitionAwareCodec.from(Int64.getInstance()).deserialize("5123456789"), elName), "<"
@Test
public void snAsYangUint8ToXmlTest() {
- String elName = "lfUint8";
+ final String elName = "lfUint8";
serializeToXml(
prepareCnStructForYangData(TypeDefinitionAwareCodec.from(Uint8.getInstance()).deserialize("200"),
elName), "<" + elName + ">200</" + elName + ">");
@Test
public void snAsYangUint16ToXmlTest() {
- String elName = "lfUint16";
+ final String elName = "lfUint16";
serializeToXml(
prepareCnStructForYangData(TypeDefinitionAwareCodec.from(Uint16.getInstance()).deserialize("4000"),
elName), "<" + elName + ">4000</" + elName + ">");
@Test
public void snAsYangUint32ToXmlTest() {
- String elName = "lfUint32";
+ final String elName = "lfUint32";
serializeToXml(
prepareCnStructForYangData(TypeDefinitionAwareCodec.from(Uint32.getInstance())
.deserialize("4123456789"), elName), "<" + elName + ">4123456789</" + elName + ">");
@Test
public void snAsYangUint64ToXmlTest() {
- String elName = "lfUint64";
+ final String elName = "lfUint64";
serializeToXml(
prepareCnStructForYangData(TypeDefinitionAwareCodec.from(Uint64.getInstance())
.deserialize("5123456789"), elName), "<" + elName + ">5123456789</" + elName + ">");
@Test
public void snAsYangBinaryToXmlTest() {
- String elName = "lfBinary";
+ final String elName = "lfBinary";
serializeToXml(
prepareCnStructForYangData(
TypeDefinitionAwareCodec.from(BinaryType.getInstance()).deserialize(
@Test
public void snAsYangBitsToXmlTest() {
- BitsTypeDefinition.Bit mockBit1 = mock(BitsTypeDefinition.Bit.class);
+ final BitsTypeDefinition.Bit mockBit1 = mock(BitsTypeDefinition.Bit.class);
when(mockBit1.getName()).thenReturn("one");
- BitsTypeDefinition.Bit mockBit2 = mock(BitsTypeDefinition.Bit.class);
+ final BitsTypeDefinition.Bit mockBit2 = mock(BitsTypeDefinition.Bit.class);
when(mockBit2.getName()).thenReturn("two");
- List<BitsTypeDefinition.Bit> bitList = Lists.newArrayList(mockBit1, mockBit2);
+ final List<BitsTypeDefinition.Bit> bitList = Lists.newArrayList(mockBit1, mockBit2);
- String elName = "lfBits";
+ final String elName = "lfBits";
serializeToXml(
prepareCnStructForYangData(
TypeDefinitionAwareCodec.from(BitsType.create(mock(SchemaPath.class), bitList)).deserialize(
@Test
public void snAsYangEnumerationToXmlTest() {
- EnumTypeDefinition.EnumPair mockEnum = mock(EnumTypeDefinition.EnumPair.class);
+ final EnumTypeDefinition.EnumPair mockEnum = mock(EnumTypeDefinition.EnumPair.class);
when(mockEnum.getName()).thenReturn("enum2");
- List<EnumPair> enumList = Lists.newArrayList(mockEnum);
+ final List<EnumPair> enumList = Lists.newArrayList(mockEnum);
- String elName = "lfEnumeration";
+ final String elName = "lfEnumeration";
serializeToXml(
prepareCnStructForYangData(
TypeDefinitionAwareCodec.from(
@Test
public void snAsYangEmptyToXmlTest() {
- String elName = "lfEmpty";
+ final String elName = "lfEmpty";
serializeToXml(
prepareCnStructForYangData(TypeDefinitionAwareCodec.from(EmptyType.getInstance()).deserialize(null),
elName), "<" + elName + "/>");
@Test
public void snAsYangBooleanToXmlTest() {
- String elName = "lfBoolean";
+ final String elName = "lfBoolean";
serializeToXml(
prepareCnStructForYangData(TypeDefinitionAwareCodec.from(BooleanType.getInstance()).deserialize("str"),
elName), "<" + elName + ">false</" + elName + ">");
@Test
public void snAsYangUnionToXmlTest() {
- BitsTypeDefinition.Bit mockBit1 = mock(BitsTypeDefinition.Bit.class);
+ final BitsTypeDefinition.Bit mockBit1 = mock(BitsTypeDefinition.Bit.class);
when(mockBit1.getName()).thenReturn("first");
- BitsTypeDefinition.Bit mockBit2 = mock(BitsTypeDefinition.Bit.class);
+ final BitsTypeDefinition.Bit mockBit2 = mock(BitsTypeDefinition.Bit.class);
when(mockBit2.getName()).thenReturn("second");
- List<BitsTypeDefinition.Bit> bitList = Lists.newArrayList(mockBit1, mockBit2);
+ final List<BitsTypeDefinition.Bit> bitList = Lists.newArrayList(mockBit1, mockBit2);
- List<TypeDefinition<?>> types = Lists.<TypeDefinition<?>> newArrayList(Int8.getInstance(),
+ final List<TypeDefinition<?>> types = Lists.<TypeDefinition<?>> newArrayList(Int8.getInstance(),
BitsType.create(mock(SchemaPath.class), bitList), BooleanType.getInstance());
- UnionType unionType = UnionType.create(types);
+ final UnionType unionType = UnionType.create(types);
- String elName = "lfUnion";
- String int8 = "15";
+ final String elName = "lfUnion";
+ final String int8 = "15";
serializeToXml(prepareCnStructForYangData(TypeDefinitionAwareCodec.from(unionType).deserialize(int8), elName),
"<" + elName + ">15</" + elName + ">");
- String bits = "first second";
+ final String bits = "first second";
serializeToXml(prepareCnStructForYangData(TypeDefinitionAwareCodec.from(unionType).deserialize(bits), elName),
"<" + elName + ">first second</" + elName + ">");
- String bool = "str";
+ final String bool = "str";
serializeToXml(prepareCnStructForYangData(TypeDefinitionAwareCodec.from(unionType).deserialize(bool), elName),
"<" + elName + ">str</" + elName + ">");
}
assertNotNull(xmlString);
boolean containSearchedStr = false;
String strRepresentation = "";
- for (String searchedStr : xmlRepresentation) {
+ for (final String searchedStr : xmlRepresentation) {
if (xmlString.contains(searchedStr)) {
containSearchedStr = true;
break;
}
private CompositeNode prepareIdentityrefData(final String prefix, final boolean valueAsQName) {
- MutableCompositeNode cont = NodeFactory.createMutableCompositeNode(
+ final MutableCompositeNode cont = NodeFactory.createMutableCompositeNode(
TestUtils.buildQName("cont", "basic:module", "2013-12-2"), null, null, ModifyAction.CREATE, null);
- MutableCompositeNode cont1 = NodeFactory.createMutableCompositeNode(
+ final MutableCompositeNode cont1 = NodeFactory.createMutableCompositeNode(
TestUtils.buildQName("cont1", "basic:module", "2013-12-2"), cont, null, ModifyAction.CREATE, null);
cont.getValue().add(cont1);
} else {
value = "no qname value";
}
- MutableSimpleNode<Object> lf11 = NodeFactory.createMutableSimpleNode(
+ final MutableSimpleNode<Object> lf11 = NodeFactory.createMutableSimpleNode(
TestUtils.buildQName("lf11", "basic:module", "2013-12-2"), cont1, value, ModifyAction.CREATE, null);
cont1.getValue().add(lf11);
cont1.init();
}
private CompositeNode prepareCnStructForYangData(final Object data, final String leafName) {
- MutableCompositeNode cont = NodeFactory.createMutableCompositeNode(
+ final MutableCompositeNode cont = NodeFactory.createMutableCompositeNode(
TestUtils.buildQName("cont", "basic:module", "2013-12-2"), null, null, ModifyAction.CREATE, null);
- MutableSimpleNode<Object> lf1 = NodeFactory.createMutableSimpleNode(
+ final MutableSimpleNode<Object> lf1 = NodeFactory.createMutableSimpleNode(
TestUtils.buildQName(leafName, "basic:module", "2013-12-2"), cont, data, ModifyAction.CREATE, null);
cont.getValue().add(lf1);
cont.init();
}
private CompositeNode prepareLeafrefData() {
- MutableCompositeNode cont = NodeFactory.createMutableCompositeNode(TestUtils.buildQName("cont"), null, null,
+ final MutableCompositeNode cont = NodeFactory.createMutableCompositeNode(TestUtils.buildQName("cont"), null, null,
ModifyAction.CREATE, null);
- MutableSimpleNode<Object> lfBoolean = NodeFactory.createMutableSimpleNode(TestUtils.buildQName("lfBoolean"),
+ final MutableSimpleNode<Object> lfBoolean = NodeFactory.createMutableSimpleNode(TestUtils.buildQName("lfBoolean"),
cont, Boolean.TRUE, ModifyAction.CREATE, null);
- MutableSimpleNode<Object> lfLfref = NodeFactory.createMutableSimpleNode(TestUtils.buildQName("lfLfref"), cont,
+ final MutableSimpleNode<Object> lfLfref = NodeFactory.createMutableSimpleNode(TestUtils.buildQName("lfLfref"), cont,
"true", ModifyAction.CREATE, null);
cont.getValue().add(lfBoolean);
cont.getValue().add(lfLfref);
private final static YangContextParser parser = new YangParserImpl();
- private static Set<Module> loadModules(String resourceDirectory) throws FileNotFoundException {
+ private static Set<Module> loadModules(final String resourceDirectory) throws FileNotFoundException {
final File testDir = new File(resourceDirectory);
final String[] fileList = testDir.list();
final List<File> testFiles = new ArrayList<File>();
throw new FileNotFoundException(resourceDirectory);
}
for (int i = 0; i < fileList.length; i++) {
- String fileName = fileList[i];
+ final String fileName = fileList[i];
if (new File(testDir, fileName).isDirectory() == false) {
testFiles.add(new File(testDir, fileName));
}
return parser.parseYangModels(testFiles);
}
- public static Set<Module> loadModulesFrom(String yangPath) {
+ public static Set<Module> loadModulesFrom(final String yangPath) {
try {
return TestUtils.loadModules(TestUtils.class.getResource(yangPath).getPath());
- } catch (FileNotFoundException e) {
+ } catch (final FileNotFoundException e) {
LOG.error("Yang files at path: " + yangPath + " weren't loaded.");
}
return null;
}
- public static SchemaContext loadSchemaContext(Set<Module> modules) {
+ public static SchemaContext loadSchemaContext(final Set<Module> modules) {
return parser.resolveSchemaContext(modules);
}
- public static SchemaContext loadSchemaContext(String resourceDirectory) throws FileNotFoundException {
+ public static SchemaContext loadSchemaContext(final String resourceDirectory) throws FileNotFoundException {
return parser.resolveSchemaContext(loadModulesFrom(resourceDirectory));
}
- public static Module findModule(Set<Module> modules, String moduleName) {
- for (Module module : modules) {
+ public static Module findModule(final Set<Module> modules, final String moduleName) {
+ for (final Module module : modules) {
if (module.getName().equals(moduleName)) {
return module;
}
return null;
}
- public static Document loadDocumentFrom(InputStream inputStream) {
+ public static Document loadDocumentFrom(final InputStream inputStream) {
try {
- DocumentBuilderFactory dbfac = DocumentBuilderFactory.newInstance();
- DocumentBuilder docBuilder = dbfac.newDocumentBuilder();
+ final DocumentBuilderFactory dbfac = DocumentBuilderFactory.newInstance();
+ final DocumentBuilder docBuilder = dbfac.newDocumentBuilder();
return docBuilder.parse(inputStream);
} catch (SAXException | IOException | ParserConfigurationException e) {
LOG.error("Error during loading Document from XML", e);
}
}
- public static String getDocumentInPrintableForm(Document doc) {
+ public static String getDocumentInPrintableForm(final Document doc) {
Preconditions.checkNotNull(doc);
try {
- ByteArrayOutputStream out = new ByteArrayOutputStream();
- TransformerFactory tf = TransformerFactory.newInstance();
- Transformer transformer = tf.newTransformer();
+ final ByteArrayOutputStream out = new ByteArrayOutputStream();
+ final TransformerFactory tf = TransformerFactory.newInstance();
+ final Transformer transformer = tf.newTransformer();
transformer.setOutputProperty(OutputKeys.OMIT_XML_DECLARATION, "no");
transformer.setOutputProperty(OutputKeys.METHOD, "xml");
transformer.setOutputProperty(OutputKeys.INDENT, "yes");
transformer.setOutputProperty("{http://xml.apache.org/xslt}indent-amount", "4");
transformer.transform(new DOMSource(doc), new StreamResult(new OutputStreamWriter(out, "UTF-8")));
- byte[] charData = out.toByteArray();
+ final byte[] charData = out.toByteArray();
return new String(charData, "UTF-8");
} catch (IOException | TransformerException e) {
- String msg = "Error during transformation of Document into String";
+ final String msg = "Error during transformation of Document into String";
LOG.error(msg, e);
return msg;
}
* {@code dataSchemaNode}. The method {@link RestconfImpl#createConfigurationData createConfigurationData} is used
* because it contains calling of method {code normalizeNode}
*/
- public static void normalizeCompositeNode(Node<?> node, Set<Module> modules, String schemaNodePath) {
- RestconfImpl restconf = RestconfImpl.getInstance();
+ public static void normalizeCompositeNode(final Node<?> node, final Set<Module> modules, final String schemaNodePath) {
+ final RestconfImpl restconf = RestconfImpl.getInstance();
ControllerContext.getInstance().setSchemas(TestUtils.loadSchemaContext(modules));
prepareMocksForRestconf(modules, restconf);
* module set has only one element then this element is returned.
*
*/
- public static Module resolveModule(String searchedModuleName, Set<Module> modules) {
+ public static Module resolveModule(final String searchedModuleName, final Set<Module> modules) {
assertNotNull("Modules can't be null.", modules);
if (searchedModuleName != null) {
- for (Module m : modules) {
+ for (final Module m : modules) {
if (m.getName().equals(searchedModuleName)) {
return m;
}
return null;
}
- public static DataSchemaNode resolveDataSchemaNode(String searchedDataSchemaName, Module module) {
+ public static DataSchemaNode resolveDataSchemaNode(final String searchedDataSchemaName, final Module module) {
assertNotNull("Module can't be null", module);
if (searchedDataSchemaName != null) {
- for (DataSchemaNode dsn : module.getChildNodes()) {
+ for (final DataSchemaNode dsn : module.getChildNodes()) {
if (dsn.getQName().getLocalName().equals(searchedDataSchemaName)) {
return dsn;
}
return null;
}
- public static QName buildQName(String name, String uri, String date, String prefix) {
+ public static QName buildQName(final String name, final String uri, final String date, final String prefix) {
try {
- URI u = new URI(uri);
+ final URI u = new URI(uri);
Date dt = null;
if (date != null) {
dt = Date.valueOf(date);
}
- return new QName(u, dt, prefix, name);
- } catch (URISyntaxException e) {
+ return QName.create(u, dt, name);
+ } catch (final URISyntaxException e) {
return null;
}
}
- public static QName buildQName(String name, String uri, String date) {
+ public static QName buildQName(final String name, final String uri, final String date) {
return buildQName(name, uri, date, null);
}
- public static QName buildQName(String name) {
+ public static QName buildQName(final String name) {
return buildQName(name, "", null);
}
- private static void addDummyNamespaceToAllNodes(NodeWrapper<?> wrappedNode) throws URISyntaxException {
+ private static void addDummyNamespaceToAllNodes(final NodeWrapper<?> wrappedNode) throws URISyntaxException {
wrappedNode.setNamespace(new URI(""));
if (wrappedNode instanceof CompositeNodeWrapper) {
- for (NodeWrapper<?> childNodeWrapper : ((CompositeNodeWrapper) wrappedNode).getValues()) {
+ for (final NodeWrapper<?> childNodeWrapper : ((CompositeNodeWrapper) wrappedNode).getValues()) {
addDummyNamespaceToAllNodes(childNodeWrapper);
}
}
}
- private static void prepareMocksForRestconf(Set<Module> modules, RestconfImpl restconf) {
- ControllerContext controllerContext = ControllerContext.getInstance();
- BrokerFacade mockedBrokerFacade = mock(BrokerFacade.class);
+ private static void prepareMocksForRestconf(final Set<Module> modules, final RestconfImpl restconf) {
+ final ControllerContext controllerContext = ControllerContext.getInstance();
+ final BrokerFacade mockedBrokerFacade = mock(BrokerFacade.class);
controllerContext.setSchemas(TestUtils.loadSchemaContext(modules));
restconf.setBroker(mockedBrokerFacade);
}
- public static Node<?> readInputToCnSn(String path, boolean dummyNamespaces,
- MessageBodyReader<Node<?>> reader) throws WebApplicationException {
+ public static Node<?> readInputToCnSn(final String path, final boolean dummyNamespaces,
+ final MessageBodyReader<Node<?>> reader) throws WebApplicationException {
- InputStream inputStream = TestUtils.class.getResourceAsStream(path);
+ final InputStream inputStream = TestUtils.class.getResourceAsStream(path);
try {
final Node<?> node = reader.readFrom(null, null, null, null, null, inputStream);
assertTrue(node instanceof CompositeNodeWrapper);
try {
TestUtils.addDummyNamespaceToAllNodes((CompositeNodeWrapper) node);
return ((CompositeNodeWrapper) node).unwrap();
- } catch (URISyntaxException e) {
+ } catch (final URISyntaxException e) {
LOG.error(e.getMessage());
assertTrue(e.getMessage(), false);
}
}
return node;
- } catch (IOException e) {
+ } catch (final IOException e) {
LOG.error(e.getMessage());
assertTrue(e.getMessage(), false);
}
// return null;
// }
- public static Node<?> readInputToCnSn(String path, MessageBodyReader<Node<?>> reader) {
+ public static Node<?> readInputToCnSn(final String path, final MessageBodyReader<Node<?>> reader) {
return readInputToCnSn(path, false, reader);
}
- public static String writeCompNodeWithSchemaContextToOutput(Node<?> node, Set<Module> modules,
- DataSchemaNode dataSchemaNode, MessageBodyWriter<StructuredData> messageBodyWriter) throws IOException,
+ public static String writeCompNodeWithSchemaContextToOutput(final Node<?> node, final Set<Module> modules,
+ final DataSchemaNode dataSchemaNode, final MessageBodyWriter<StructuredData> messageBodyWriter) throws IOException,
WebApplicationException {
assertNotNull(dataSchemaNode);
assertNotNull("Composite node can't be null", node);
- ByteArrayOutputStream byteArrayOS = new ByteArrayOutputStream();
+ final ByteArrayOutputStream byteArrayOS = new ByteArrayOutputStream();
ControllerContext.getInstance().setSchemas(loadSchemaContext(modules));
return byteArrayOS.toString();
}
- public static String loadTextFile(String filePath) throws IOException {
- FileReader fileReader = new FileReader(filePath);
- BufferedReader bufReader = new BufferedReader(fileReader);
+ public static String loadTextFile(final String filePath) throws IOException {
+ final FileReader fileReader = new FileReader(filePath);
+ final BufferedReader bufReader = new BufferedReader(fileReader);
String line = null;
- StringBuilder result = new StringBuilder();
+ final StringBuilder result = new StringBuilder();
while ((line = bufReader.readLine()) != null) {
result.append(line);
}
return result.toString();
}
- private static Pattern patternForStringsSeparatedByWhiteChars(String... substrings) {
- StringBuilder pattern = new StringBuilder();
+ private static Pattern patternForStringsSeparatedByWhiteChars(final String... substrings) {
+ final StringBuilder pattern = new StringBuilder();
pattern.append(".*");
- for (String substring : substrings) {
+ for (final String substring : substrings) {
pattern.append(substring);
pattern.append("\\s*");
}
return Pattern.compile(pattern.toString(), Pattern.DOTALL);
}
- public static boolean containsStringData(String jsonOutput, String... substrings) {
- Pattern pattern = patternForStringsSeparatedByWhiteChars(substrings);
- Matcher matcher = pattern.matcher(jsonOutput);
+ public static boolean containsStringData(final String jsonOutput, final String... substrings) {
+ final Pattern pattern = patternForStringsSeparatedByWhiteChars(substrings);
+ final Matcher matcher = pattern.matcher(jsonOutput);
return matcher.matches();
}
public static NormalizedNode compositeNodeToDatastoreNormalizedNode(final CompositeNode compositeNode,
final DataSchemaNode schema) {
- List<Node<?>> lst = new ArrayList<Node<?>>();
+ final List<Node<?>> lst = new ArrayList<Node<?>>();
lst.add(compositeNode);
if (schema instanceof ContainerSchemaNode) {
return CnSnToNormalizedNodeParserFactory.getInstance().getContainerNodeParser()
"It wasn't possible to translate specified data to datastore readable form."));
}
- public static YangInstanceIdentifier.NodeIdentifier getNodeIdentifier(String localName, String namespace,
- String revision) throws ParseException {
+ public static YangInstanceIdentifier.NodeIdentifier getNodeIdentifier(final String localName, final String namespace,
+ final String revision) throws ParseException {
return new YangInstanceIdentifier.NodeIdentifier(QName.create(namespace, revision, localName));
}
- public static YangInstanceIdentifier.NodeIdentifierWithPredicates getNodeIdentifierPredicate(String localName,
- String namespace, String revision, Map<String, Object> keys) throws ParseException {
- Map<QName, Object> predicate = new HashMap<>();
- for (String key : keys.keySet()) {
+ public static YangInstanceIdentifier.NodeIdentifierWithPredicates getNodeIdentifierPredicate(final String localName,
+ final String namespace, final String revision, final Map<String, Object> keys) throws ParseException {
+ final Map<QName, Object> predicate = new HashMap<>();
+ for (final String key : keys.keySet()) {
predicate.put(QName.create(namespace, revision, key), keys.get(key));
}
QName.create(namespace, revision, localName), predicate);
}
- public static YangInstanceIdentifier.NodeIdentifierWithPredicates getNodeIdentifierPredicate(String localName,
- String namespace, String revision, String... keysAndValues) throws ParseException {
- java.util.Date date = new SimpleDateFormat("yyyy-MM-dd").parse(revision);
+ public static YangInstanceIdentifier.NodeIdentifierWithPredicates getNodeIdentifierPredicate(final String localName,
+ final String namespace, final String revision, final String... keysAndValues) throws ParseException {
+ final java.util.Date date = new SimpleDateFormat("yyyy-MM-dd").parse(revision);
if (keysAndValues.length % 2 != 0) {
new IllegalArgumentException("number of keys argument have to be divisible by 2 (map)");
}
- Map<QName, Object> predicate = new HashMap<>();
+ final Map<QName, Object> predicate = new HashMap<>();
int i = 0;
while (i < keysAndValues.length) {
}
public static CompositeNode prepareCompositeNodeWithIetfInterfacesInterfacesData() {
- CompositeNodeBuilder<ImmutableCompositeNode> interfaceBuilder = ImmutableCompositeNode.builder();
+ final CompositeNodeBuilder<ImmutableCompositeNode> interfaceBuilder = ImmutableCompositeNode.builder();
interfaceBuilder.addLeaf(buildQName("name", "dummy", "2014-07-29"), "eth0");
interfaceBuilder.addLeaf(buildQName("type", "dummy", "2014-07-29"), "ethernetCsmacd");
interfaceBuilder.addLeaf(buildQName("enabled", "dummy", "2014-07-29"), "false");
}
static NormalizedNode<?,?> prepareNormalizedNodeWithIetfInterfacesInterfacesData() throws ParseException {
- String ietfInterfacesDate = "2013-07-04";
- String namespace = "urn:ietf:params:xml:ns:yang:ietf-interfaces";
- DataContainerNodeAttrBuilder<YangInstanceIdentifier.NodeIdentifierWithPredicates, MapEntryNode> mapEntryNode = ImmutableMapEntryNodeBuilder.create();
+ final String ietfInterfacesDate = "2013-07-04";
+ final String namespace = "urn:ietf:params:xml:ns:yang:ietf-interfaces";
+ final DataContainerNodeAttrBuilder<YangInstanceIdentifier.NodeIdentifierWithPredicates, MapEntryNode> mapEntryNode = ImmutableMapEntryNodeBuilder.create();
- Map<String, Object> predicates = new HashMap<>();
+ final Map<String, Object> predicates = new HashMap<>();
predicates.put("name", "eth0");
mapEntryNode.withNodeIdentifier(getNodeIdentifierPredicate("interface", namespace, ietfInterfacesDate,
Code Review / controller.git / commitdiff