import java.util.Collections;
import java.util.Map;
-
import org.opendaylight.controller.netconf.api.NetconfDocumentedException;
public class NetconfConfigHandlingException extends NetconfDocumentedException {
import java.util.Collections;
import java.util.Map;
-
import org.opendaylight.controller.netconf.api.NetconfDocumentedException;
public class NoTransactionFoundException extends NetconfDocumentedException {
import java.util.Collections;
import java.util.Map;
-
import org.opendaylight.controller.netconf.api.NetconfDocumentedException;
public class OperationNotPermittedException extends NetconfDocumentedException {
import javax.management.openmbean.CompositeType;
import javax.management.openmbean.OpenType;
import javax.management.openmbean.SimpleType;
-
import org.opendaylight.controller.config.yangjmxgenerator.attribute.AttributeIfc;
import org.opendaylight.controller.config.yangjmxgenerator.attribute.DependencyAttribute;
import org.opendaylight.controller.config.yangjmxgenerator.attribute.JavaAttribute;
package org.opendaylight.controller.netconf.confignetconfconnector.mapping.attributes.fromxml;
+import java.util.List;
import org.opendaylight.controller.netconf.api.NetconfDocumentedException;
import org.opendaylight.controller.netconf.util.xml.XmlElement;
-import java.util.List;
-
public abstract class AbstractAttributeReadingStrategy implements AttributeReadingStrategy {
private final String nullableDefault;
package org.opendaylight.controller.netconf.confignetconfconnector.mapping.attributes.fromxml;
import com.google.common.collect.Lists;
+import java.util.List;
import org.opendaylight.controller.netconf.api.NetconfDocumentedException;
import org.opendaylight.controller.netconf.util.xml.XmlElement;
-import java.util.List;
-
public class ArrayAttributeReadingStrategy extends AbstractAttributeReadingStrategy {
private final AttributeReadingStrategy innerStrategy;
package org.opendaylight.controller.netconf.confignetconfconnector.mapping.attributes.fromxml;
import com.google.common.base.Optional;
+import javax.management.openmbean.OpenType;
import org.opendaylight.controller.netconf.api.NetconfDocumentedException;
import org.opendaylight.controller.netconf.confignetconfconnector.mapping.attributes.resolving.AttributeResolvingStrategy;
-import javax.management.openmbean.OpenType;
-
/**
* Parsed xml element containing configuration for one attribute of an instance
* of some module. Contains default value extracted from yang file.
package org.opendaylight.controller.netconf.confignetconfconnector.mapping.attributes.fromxml;
import java.util.List;
-
import org.opendaylight.controller.netconf.api.NetconfDocumentedException;
import org.opendaylight.controller.netconf.util.xml.XmlElement;
import com.google.common.base.Preconditions;
import com.google.common.collect.Lists;
import com.google.common.collect.Maps;
-
-import org.opendaylight.controller.netconf.api.NetconfDocumentedException;
-import org.opendaylight.controller.netconf.util.xml.XmlElement;
-
import java.util.List;
import java.util.Map;
import java.util.Map.Entry;
+import org.opendaylight.controller.netconf.api.NetconfDocumentedException;
+import org.opendaylight.controller.netconf.util.xml.XmlElement;
public class CompositeAttributeReadingStrategy extends AbstractAttributeReadingStrategy {
package org.opendaylight.controller.netconf.confignetconfconnector.mapping.attributes.fromxml;
import com.google.common.base.Preconditions;
-
import com.google.common.base.Strings;
import java.util.List;
import java.util.Map;
-
import org.opendaylight.controller.netconf.api.NetconfDocumentedException;
import org.opendaylight.controller.netconf.api.xml.XmlNetconfConstants;
import org.opendaylight.controller.netconf.confignetconfconnector.mapping.attributes.mapping.ObjectNameAttributeMappingStrategy;
import com.google.common.base.Preconditions;
import com.google.common.collect.Maps;
+import java.util.Date;
+import java.util.Map;
+import java.util.Map.Entry;
+import java.util.Set;
+import javax.management.openmbean.ArrayType;
+import javax.management.openmbean.CompositeType;
+import javax.management.openmbean.OpenType;
+import javax.management.openmbean.SimpleType;
import org.opendaylight.controller.config.yangjmxgenerator.attribute.AttributeIfc;
import org.opendaylight.controller.config.yangjmxgenerator.attribute.JavaAttribute;
import org.opendaylight.controller.config.yangjmxgenerator.attribute.ListAttribute;
import org.opendaylight.controller.netconf.confignetconfconnector.mapping.attributes.AttributeIfcSwitchStatement;
import org.opendaylight.controller.netconf.confignetconfconnector.operations.editconfig.EditConfig;
-import javax.management.openmbean.ArrayType;
-import javax.management.openmbean.CompositeType;
-import javax.management.openmbean.OpenType;
-import javax.management.openmbean.SimpleType;
-import java.util.Date;
-import java.util.Map;
-import java.util.Map.Entry;
-import java.util.Set;
-
public class ObjectXmlReader extends AttributeIfcSwitchStatement<AttributeReadingStrategy> {
private String key;
import com.google.common.collect.Lists;
import com.google.common.io.BaseEncoding;
-
import java.util.List;
public class SimpleBinaryAttributeReadingStrategy extends SimpleAttributeReadingStrategy {
package org.opendaylight.controller.netconf.confignetconfconnector.mapping.attributes.fromxml;
import com.google.common.collect.Maps;
-
import java.util.HashMap;
public class SimpleCompositeAttributeReadingStrategy extends SimpleAttributeReadingStrategy {
package org.opendaylight.controller.netconf.confignetconfconnector.mapping.attributes.fromxml;
+import com.google.common.base.Preconditions;
+import com.google.common.collect.Maps;
import java.net.URI;
import java.util.Date;
import java.util.HashMap;
import java.util.Map;
-
-import com.google.common.base.Preconditions;
-import com.google.common.collect.Maps;
import org.opendaylight.controller.netconf.api.NetconfDocumentedException;
import org.opendaylight.controller.netconf.confignetconfconnector.operations.editconfig.EditConfig;
import org.opendaylight.controller.netconf.util.xml.XmlElement;
import com.google.common.collect.Lists;
import com.google.common.collect.Maps;
-
import java.util.List;
import java.util.Map;
package org.opendaylight.controller.netconf.confignetconfconnector.mapping.attributes.mapping;
+import com.google.common.base.Optional;
+import com.google.common.base.Preconditions;
+import com.google.common.collect.Lists;
import java.lang.reflect.Array;
import java.util.List;
-
import javax.management.openmbean.ArrayType;
import javax.management.openmbean.OpenType;
-import com.google.common.base.Optional;
-import com.google.common.base.Preconditions;
-import com.google.common.collect.Lists;
-
public class ArrayAttributeMappingStrategy extends AbstractAttributeMappingStrategy<List<Object>, ArrayType<?>> {
private final AttributeMappingStrategy<?, ? extends OpenType<?>> innerElementStrategy;
package org.opendaylight.controller.netconf.confignetconfconnector.mapping.attributes.mapping;
import com.google.common.base.Optional;
-
import javax.management.openmbean.OpenType;
public interface AttributeMappingStrategy<T, O extends OpenType<?>> {
import com.google.common.base.Optional;
import com.google.common.base.Preconditions;
import com.google.common.collect.Maps;
-import org.opendaylight.controller.netconf.confignetconfconnector.util.Util;
-
+import java.util.Map;
+import java.util.Set;
import javax.management.openmbean.CompositeDataSupport;
import javax.management.openmbean.CompositeType;
import javax.management.openmbean.OpenType;
-import java.util.Map;
-import java.util.Set;
+import org.opendaylight.controller.netconf.confignetconfconnector.util.Util;
public class CompositeAttributeMappingStrategy extends
AbstractAttributeMappingStrategy<Map<String, Object>, CompositeType> {
import com.google.common.base.Optional;
import com.google.common.base.Preconditions;
import com.google.common.collect.Maps;
-import org.opendaylight.controller.netconf.confignetconfconnector.util.Util;
-
-import javax.management.openmbean.SimpleType;
import java.util.Date;
import java.util.Map;
+import javax.management.openmbean.SimpleType;
+import org.opendaylight.controller.netconf.confignetconfconnector.util.Util;
public class SimpleAttributeMappingStrategy extends AbstractAttributeMappingStrategy<String, SimpleType<?>> {
package org.opendaylight.controller.netconf.confignetconfconnector.mapping.attributes.mapping;
import com.google.common.base.Optional;
-import org.opendaylight.controller.config.yangjmxgenerator.attribute.JavaAttribute;
-
+import java.util.Map;
import javax.management.openmbean.CompositeDataSupport;
import javax.management.openmbean.CompositeType;
import javax.management.openmbean.OpenType;
-import java.util.Map;
+import org.opendaylight.controller.config.yangjmxgenerator.attribute.JavaAttribute;
public class UnionCompositeAttributeMappingStrategy extends
CompositeAttributeMappingStrategy {
package org.opendaylight.controller.netconf.confignetconfconnector.mapping.attributes.resolving;
import com.google.common.base.Optional;
-import org.opendaylight.controller.netconf.api.NetconfDocumentedException;
-import org.opendaylight.controller.netconf.confignetconfconnector.util.Util;
-import org.slf4j.Logger;
-import org.slf4j.LoggerFactory;
-
+import java.lang.reflect.Array;
+import java.util.List;
import javax.management.openmbean.ArrayType;
import javax.management.openmbean.CompositeDataSupport;
import javax.management.openmbean.CompositeType;
import javax.management.openmbean.OpenType;
-import java.lang.reflect.Array;
-import java.util.List;
+import org.opendaylight.controller.netconf.api.NetconfDocumentedException;
+import org.opendaylight.controller.netconf.confignetconfconnector.util.Util;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
final class ArrayAttributeResolvingStrategy extends AbstractAttributeResolvingStrategy<Object, ArrayType<?>> {
private final AttributeResolvingStrategy<?, ? extends OpenType<?>> innerTypeResolvingStrategy;
- private static final Logger logger = LoggerFactory.getLogger(ArrayAttributeResolvingStrategy.class);
+ private static final Logger LOG = LoggerFactory.getLogger(ArrayAttributeResolvingStrategy.class);
public ArrayAttributeResolvingStrategy(AttributeResolvingStrategy<?, ? extends OpenType<?>> innerTypeResolved,
ArrayType<?> openType) {
i++;
}
- logger.debug("Attribute {} : {} parsed to type {} as {}", attrName, value, getOpenType(),
+ LOG.debug("Attribute {} : {} parsed to type {} as {}", attrName, value, getOpenType(),
toStringArray(parsedArray));
return Optional.of(parsedArray);
package org.opendaylight.controller.netconf.confignetconfconnector.mapping.attributes.resolving;
import com.google.common.base.Optional;
-
import javax.management.openmbean.OpenType;
import org.opendaylight.controller.netconf.api.NetconfDocumentedException;
import com.google.common.base.Optional;
import com.google.common.base.Preconditions;
import com.google.common.collect.Maps;
-import org.opendaylight.controller.netconf.api.NetconfDocumentedException;
-import org.opendaylight.controller.netconf.confignetconfconnector.util.Util;
-import org.slf4j.Logger;
-import org.slf4j.LoggerFactory;
-
+import java.util.Map;
import javax.management.openmbean.CompositeDataSupport;
import javax.management.openmbean.CompositeType;
import javax.management.openmbean.OpenDataException;
import javax.management.openmbean.OpenType;
-import java.util.Map;
+import org.opendaylight.controller.netconf.api.NetconfDocumentedException;
+import org.opendaylight.controller.netconf.confignetconfconnector.util.Util;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
class CompositeAttributeResolvingStrategy extends
AbstractAttributeResolvingStrategy<CompositeDataSupport, CompositeType> {
private final Map<String, AttributeResolvingStrategy<?, ? extends OpenType<?>>> innerTypes;
private final Map<String, String> yangToJavaAttrMapping;
- private static final Logger logger = LoggerFactory.getLogger(CompositeAttributeResolvingStrategy.class);
+ private static final Logger LOG = LoggerFactory.getLogger(CompositeAttributeResolvingStrategy.class);
CompositeAttributeResolvingStrategy(Map<String, AttributeResolvingStrategy<?, ? extends OpenType<?>>> innerTypes,
CompositeType openType, Map<String, String> yangToJavaAttrMapping) {
+ " for attribute " + attrName + " from value " + value, e);
}
- logger.debug("Attribute {} : {} parsed to type {} as {}", attrName, value, getOpenType(), parsedValue);
+ LOG.debug("Attribute {} : {} parsed to type {} as {}", attrName, value, getOpenType(), parsedValue);
return Optional.of(parsedValue);
}
package org.opendaylight.controller.netconf.confignetconfconnector.mapping.attributes.resolving;
import com.google.common.base.Optional;
+import javax.management.ObjectName;
+import javax.management.openmbean.SimpleType;
import org.opendaylight.controller.netconf.confignetconfconnector.mapping.attributes.mapping.ObjectNameAttributeMappingStrategy;
import org.opendaylight.controller.netconf.confignetconfconnector.mapping.config.ServiceRegistryWrapper;
import org.opendaylight.controller.netconf.confignetconfconnector.util.Util;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
-import javax.management.ObjectName;
-import javax.management.openmbean.SimpleType;
-
public class ObjectNameAttributeResolvingStrategy extends AbstractAttributeResolvingStrategy<ObjectName, SimpleType<?>> {
private final ServiceRegistryWrapper serviceTracker;
- private static final Logger logger = LoggerFactory.getLogger(ObjectNameAttributeResolvingStrategy.class);
+ private static final Logger LOG = LoggerFactory.getLogger(ObjectNameAttributeResolvingStrategy.class);
ObjectNameAttributeResolvingStrategy(ServiceRegistryWrapper serviceTracker) {
super(SimpleType.OBJECTNAME);
String serviceName = mappedDep.getServiceName();
String refName = mappedDep.getRefName();
String namespace = mappedDep.getNamespace();
- logger.trace("Getting service instance by service name {} : {} and ref name {}", namespace, serviceName, refName);
+ LOG.trace("Getting service instance by service name {} : {} and ref name {}", namespace, serviceName, refName);
ObjectName on = serviceTracker.getByServiceAndRefName(namespace, serviceName, refName);
- logger.debug("Attribute {} : {} parsed to type {}", attrName, value, getOpenType());
+ LOG.debug("Attribute {} : {} parsed to type {}", attrName, value, getOpenType());
return Optional.of(on);
}
import com.google.common.base.Preconditions;
import com.google.common.collect.Maps;
+import java.util.Map;
+import java.util.Map.Entry;
+import javax.management.openmbean.ArrayType;
+import javax.management.openmbean.CompositeType;
+import javax.management.openmbean.OpenType;
+import javax.management.openmbean.SimpleType;
import org.opendaylight.controller.config.yangjmxgenerator.attribute.AttributeIfc;
import org.opendaylight.controller.config.yangjmxgenerator.attribute.ListAttribute;
import org.opendaylight.controller.config.yangjmxgenerator.attribute.ListDependenciesAttribute;
import org.opendaylight.controller.netconf.confignetconfconnector.mapping.attributes.AttributeIfcSwitchStatement;
import org.opendaylight.controller.netconf.confignetconfconnector.mapping.config.ServiceRegistryWrapper;
-import javax.management.openmbean.ArrayType;
-import javax.management.openmbean.CompositeType;
-import javax.management.openmbean.OpenType;
-import javax.management.openmbean.SimpleType;
-import java.util.Map;
-import java.util.Map.Entry;
-
public class ObjectResolver extends AttributeIfcSwitchStatement<AttributeResolvingStrategy<?, ? extends OpenType<?>>> {
private final ServiceRegistryWrapper serviceTracker;
import com.google.common.base.Optional;
import com.google.common.collect.Maps;
import java.lang.reflect.InvocationTargetException;
-import java.text.ParseException;
-import org.opendaylight.controller.netconf.api.NetconfDocumentedException;
-import org.opendaylight.controller.netconf.confignetconfconnector.util.Util;
-import org.slf4j.Logger;
-import org.slf4j.LoggerFactory;
-
-import javax.management.openmbean.SimpleType;
import java.lang.reflect.Method;
import java.math.BigDecimal;
import java.math.BigInteger;
+import java.text.ParseException;
import java.util.Date;
import java.util.Map;
+import javax.management.openmbean.SimpleType;
+import org.opendaylight.controller.netconf.api.NetconfDocumentedException;
+import org.opendaylight.controller.netconf.confignetconfconnector.util.Util;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
final class SimpleAttributeResolvingStrategy extends AbstractAttributeResolvingStrategy<Object, SimpleType<?>> {
- private static final Logger logger = LoggerFactory.getLogger(SimpleAttributeResolvingStrategy.class);
+ private static final Logger LOG = LoggerFactory.getLogger(SimpleAttributeResolvingStrategy.class);
SimpleAttributeResolvingStrategy(SimpleType<?> simpleType) {
super(simpleType);
prefferedPlugin = prefferedPlugin == null ? resolverPlugins.get(DEFAULT_RESOLVERS) : prefferedPlugin;
Object parsedValue = prefferedPlugin.resolveObject(cls, attrName, (String) value);
- logger.debug("Attribute {} : {} parsed to type {} with value {}", attrName, value, getOpenType(), parsedValue);
+ LOG.debug("Attribute {} : {} parsed to type {} with value {}", attrName, value, getOpenType(), parsedValue);
return Optional.of(parsedValue);
}
method = type.getMethod("valueOf", String.class);
return method.invoke(null, value);
} catch (IllegalAccessException | InvocationTargetException | NoSuchMethodException e) {
- logger.trace("Error parsing object {}",e);
+ LOG.trace("Error parsing object ",e);
throw new NetconfDocumentedException("Error parsing object.",
NetconfDocumentedException.ErrorType.application,
NetconfDocumentedException.ErrorTag.operation_failed,
try {
return Util.readDate(value);
} catch (ParseException e) {
- logger.trace("Unable parse value {} due to {}",value, e);
+ LOG.trace("Unable parse value {} due to ",value, e);
throw new NetconfDocumentedException("Unable to parse value "+value+" as date.",
NetconfDocumentedException.ErrorType.application,
NetconfDocumentedException.ErrorTag.operation_failed,
import com.google.common.base.Preconditions;
import com.google.common.collect.Maps;
-import org.opendaylight.controller.config.yangjmxgenerator.attribute.JavaAttribute;
-
+import java.util.Map;
import javax.management.openmbean.CompositeType;
import javax.management.openmbean.OpenType;
-import java.util.Map;
+import org.opendaylight.controller.config.yangjmxgenerator.attribute.JavaAttribute;
final class UnionCompositeAttributeResolvingStrategy extends CompositeAttributeResolvingStrategy {
package org.opendaylight.controller.netconf.confignetconfconnector.mapping.attributes.toxml;
import java.util.List;
-
import org.opendaylight.controller.netconf.confignetconfconnector.util.Util;
import org.w3c.dom.Element;
package org.opendaylight.controller.netconf.confignetconfconnector.mapping.attributes.toxml;
+import com.google.common.base.Optional;
import java.util.Map;
import java.util.Map.Entry;
-
import org.opendaylight.controller.netconf.confignetconfconnector.util.Util;
import org.opendaylight.controller.netconf.util.xml.XmlUtil;
import org.w3c.dom.Document;
import org.w3c.dom.Element;
-import com.google.common.base.Optional;
-
public class CompositeAttributeWritingStrategy implements AttributeWritingStrategy {
private final String key;
package org.opendaylight.controller.netconf.confignetconfconnector.mapping.attributes.toxml;
+import com.google.common.base.Optional;
import org.opendaylight.controller.netconf.api.xml.XmlNetconfConstants;
import org.opendaylight.controller.netconf.confignetconfconnector.mapping.attributes.mapping.ObjectNameAttributeMappingStrategy;
import org.opendaylight.controller.netconf.confignetconfconnector.util.Util;
import org.w3c.dom.Document;
import org.w3c.dom.Element;
-import com.google.common.base.Optional;
-
public class ObjectNameAttributeWritingStrategy implements AttributeWritingStrategy {
private final Document document;
import com.google.common.base.Preconditions;
import com.google.common.collect.Maps;
+import java.util.Map;
+import java.util.Map.Entry;
+import javax.management.openmbean.ArrayType;
+import javax.management.openmbean.CompositeType;
+import javax.management.openmbean.OpenType;
+import javax.management.openmbean.SimpleType;
import org.opendaylight.controller.config.yangjmxgenerator.attribute.AttributeIfc;
import org.opendaylight.controller.config.yangjmxgenerator.attribute.ListAttribute;
import org.opendaylight.controller.config.yangjmxgenerator.attribute.ListDependenciesAttribute;
import org.opendaylight.controller.netconf.confignetconfconnector.mapping.attributes.AttributeIfcSwitchStatement;
import org.w3c.dom.Document;
-import javax.management.openmbean.ArrayType;
-import javax.management.openmbean.CompositeType;
-import javax.management.openmbean.OpenType;
-import javax.management.openmbean.SimpleType;
-import java.util.Map;
-import java.util.Map.Entry;
-
public class ObjectXmlWriter extends AttributeIfcSwitchStatement<AttributeWritingStrategy> {
private Document document;
package org.opendaylight.controller.netconf.confignetconfconnector.mapping.attributes.toxml;
import com.google.common.base.Optional;
+import java.util.Map;
+import java.util.Map.Entry;
import org.opendaylight.controller.netconf.confignetconfconnector.util.Util;
import org.opendaylight.controller.netconf.util.xml.XmlUtil;
import org.w3c.dom.Document;
import org.w3c.dom.Element;
-import java.util.Map;
-import java.util.Map.Entry;
-
public class RuntimeBeanEntryWritingStrategy extends CompositeAttributeWritingStrategy {
public RuntimeBeanEntryWritingStrategy(Document document, String key,
package org.opendaylight.controller.netconf.confignetconfconnector.mapping.attributes.toxml;
+import com.google.common.base.Optional;
import org.opendaylight.controller.netconf.confignetconfconnector.util.Util;
import org.opendaylight.controller.netconf.util.xml.XmlUtil;
import org.w3c.dom.Document;
import org.w3c.dom.Element;
-import com.google.common.base.Optional;
-
public class SimpleAttributeWritingStrategy implements AttributeWritingStrategy {
private final Document document;
import com.google.common.base.Preconditions;
import com.google.common.io.BaseEncoding;
+import java.util.List;
import org.opendaylight.controller.netconf.confignetconfconnector.util.Util;
import org.w3c.dom.Document;
-import java.util.List;
-
public class SimpleBinaryAttributeWritingStrategy extends SimpleAttributeWritingStrategy {
/**
package org.opendaylight.controller.netconf.confignetconfconnector.mapping.attributes.toxml;
import com.google.common.base.Preconditions;
+import java.util.Map;
import org.opendaylight.controller.netconf.confignetconfconnector.util.Util;
import org.w3c.dom.Document;
-import java.util.Map;
-
public class SimpleCompositeAttributeWritingStrategy extends SimpleAttributeWritingStrategy {
/**
package org.opendaylight.controller.netconf.confignetconfconnector.mapping.attributes.toxml;
+import com.google.common.base.Optional;
+import com.google.common.base.Preconditions;
import java.util.Map;
-
import org.opendaylight.controller.netconf.confignetconfconnector.util.Util;
import org.opendaylight.controller.netconf.util.xml.XmlUtil;
import org.opendaylight.yangtools.yang.common.QName;
import org.w3c.dom.Document;
import org.w3c.dom.Element;
-import com.google.common.base.Optional;
-import com.google.common.base.Preconditions;
-
public class SimpleIdentityRefAttributeWritingStrategy extends SimpleAttributeWritingStrategy {
private static final String PREFIX = "prefix";
package org.opendaylight.controller.netconf.confignetconfconnector.mapping.attributes.toxml;
import com.google.common.base.Preconditions;
-import org.opendaylight.controller.netconf.confignetconfconnector.util.Util;
-import org.w3c.dom.Document;
-
import java.util.List;
import java.util.Map;
+import org.opendaylight.controller.netconf.confignetconfconnector.util.Util;
+import org.w3c.dom.Document;
public class SimpleUnionAttributeWritingStrategy extends SimpleAttributeWritingStrategy {
import com.google.common.collect.Lists;
import com.google.common.collect.Maps;
import com.google.common.collect.Multimap;
-
import java.util.Collection;
import java.util.Collections;
import java.util.Date;
import java.util.Map;
import java.util.Map.Entry;
import java.util.Set;
-
import javax.management.ObjectName;
-
import org.opendaylight.controller.config.api.jmx.ObjectNameUtil;
import org.opendaylight.controller.netconf.api.NetconfDocumentedException;
import org.opendaylight.controller.netconf.api.xml.XmlNetconfConstants;
import com.google.common.base.Optional;
import com.google.common.collect.Lists;
import com.google.common.collect.Maps;
-
import java.util.Date;
import java.util.List;
import java.util.Map;
import java.util.Map.Entry;
-
import javax.management.ObjectName;
import javax.management.openmbean.OpenType;
-
import org.opendaylight.controller.config.util.ConfigRegistryClient;
import org.opendaylight.controller.config.yangjmxgenerator.RuntimeBeanEntry;
import org.opendaylight.controller.config.yangjmxgenerator.attribute.AttributeIfc;
import org.w3c.dom.Element;
public final class InstanceConfig {
- private static final Logger logger = LoggerFactory.getLogger(InstanceConfig.class);
+ private static final Logger LOG = LoggerFactory.getLogger(InstanceConfig.class);
private final Map<String, AttributeIfc> yangToAttrConfig;
private final String nullableDummyContainerName;
try {
AttributeResolvingStrategy<?, ? extends OpenType<?>> attributeResolvingStrategy = resolvingStrategies
.get(attributeName);
- logger.trace("Trying to set value {} of attribute {} with {}", value, attributeName, attributeResolvingStrategy);
+ LOG.trace("Trying to set value {} of attribute {} with {}", value, attributeName, attributeResolvingStrategy);
value.resolveValue(attributeResolvingStrategy, attributeName);
value.setJmxName(
List<XmlElement> recognisedChildren, List<XmlElement> typeAndName) throws NetconfDocumentedException {
List<XmlElement> foundConfigNodes = moduleElement.getChildElementsWithinNamespace(name, moduleNamespace);
if (foundConfigNodes.isEmpty()) {
- logger.debug("No config nodes {}:{} found in {}", moduleNamespace, name, moduleElement);
- logger.debug("Trying lookup of config nodes without specified namespace");
+ LOG.debug("No config nodes {}:{} found in {}", moduleNamespace, name, moduleElement);
+ LOG.debug("Trying lookup of config nodes without specified namespace");
foundConfigNodes = moduleElement.getChildElementsWithinNamespace(name,
XmlNetconfConstants.URN_OPENDAYLIGHT_PARAMS_XML_NS_YANG_CONTROLLER_CONFIG);
// In case module type or name element is not present in config it
// We need to remove config type and name from available module
// config elements
foundConfigNodes.removeAll(typeAndName);
- logger.debug("Found {} config nodes {} without specified namespace in {}", foundConfigNodes.size(), name,
+ LOG.debug("Found {} config nodes {} without specified namespace in {}", foundConfigNodes.size(), name,
moduleElement);
} else {
List<XmlElement> foundWithoutNamespaceNodes = moduleElement.getChildElementsWithinNamespace(name,
package org.opendaylight.controller.netconf.confignetconfconnector.mapping.config;
import com.google.common.base.Optional;
-
import java.util.Date;
import java.util.Map;
-
import javax.management.ObjectName;
-
import org.opendaylight.controller.config.api.jmx.ObjectNameUtil;
import org.opendaylight.controller.netconf.api.NetconfDocumentedException;
import org.opendaylight.controller.netconf.api.xml.XmlNetconfConstants;
private final String instanceName;
private final EditStrategyType editStrategy;
- private static final Logger logger = LoggerFactory.getLogger(ModuleElementDefinition.class);
+ private static final Logger LOG = LoggerFactory.getLogger(ModuleElementDefinition.class);
public ModuleElementDefinition(String instanceName, String currentStrategy, EditStrategyType defaultStrategy) {
this.instanceName = instanceName;
_edStrategy = InstanceConfigElementResolved.parseStrategy(currentStrategy, defaultStrategy);
} catch (OperationNotPermittedException e) {
_edStrategy = defaultStrategy;
- logger.warn("Operation not permitted on current strategy {} while default strategy is {}. Element definition strategy set to default.",
+ LOG.warn("Operation not permitted on current strategy {} while default strategy is {}. Element definition strategy set to default.",
currentStrategy,
defaultStrategy,
e);
public EditConfigStrategy getEditStrategy() {
switch (editStrategy) {
- case delete :
- case remove :
- case none : return NONE_EDIT_CONFIG_STRATEGY;
- default : return MISSING_INSTANCE_HANDLING_STRATEGY;
+ case delete :
+ case remove :
+ case none :
+ return NONE_EDIT_CONFIG_STRATEGY;
+ default :
+ return MISSING_INSTANCE_HANDLING_STRATEGY;
}
}
}
import com.google.common.base.Optional;
import com.google.common.base.Preconditions;
import com.google.common.collect.Maps;
-
+import java.util.List;
+import java.util.Map;
+import java.util.Map.Entry;
+import java.util.regex.Matcher;
+import java.util.regex.Pattern;
+import javax.management.ObjectName;
import org.opendaylight.controller.config.api.jmx.ObjectNameUtil;
import org.opendaylight.controller.netconf.api.NetconfDocumentedException;
import org.opendaylight.controller.netconf.api.xml.XmlNetconfConstants;
import org.w3c.dom.Document;
import org.w3c.dom.Element;
-import javax.management.ObjectName;
-
-import java.util.List;
-import java.util.Map;
-import java.util.Map.Entry;
-import java.util.regex.Matcher;
-import java.util.regex.Pattern;
-
public final class Services {
private static final String PROVIDER_KEY = "provider";
package org.opendaylight.controller.netconf.confignetconfconnector.mapping.rpc;
import com.google.common.collect.Maps;
+import java.util.Collections;
+import java.util.Date;
+import java.util.List;
+import java.util.Map;
+import java.util.Map.Entry;
+import javax.management.openmbean.OpenType;
import org.opendaylight.controller.config.yangjmxgenerator.RuntimeBeanEntry.Rpc;
import org.opendaylight.controller.config.yangjmxgenerator.attribute.AttributeIfc;
import org.opendaylight.controller.config.yangjmxgenerator.attribute.JavaAttribute;
import org.opendaylight.controller.netconf.confignetconfconnector.operations.editconfig.EditConfig;
import org.opendaylight.controller.netconf.util.xml.XmlElement;
-import javax.management.openmbean.OpenType;
-import java.util.Collections;
-import java.util.Date;
-import java.util.List;
-import java.util.Map;
-import java.util.Map.Entry;
-
public final class InstanceRuntimeRpc {
private final Map<String, AttributeIfc> yangToAttrConfig;
import com.google.common.base.Preconditions;
import com.google.common.collect.Maps;
+import java.util.Map;
import org.opendaylight.controller.config.yangjmxgenerator.RuntimeBeanEntry;
import org.opendaylight.controller.config.yangjmxgenerator.RuntimeBeanEntry.Rpc;
-import java.util.Map;
-
public final class ModuleRpcs {
private final Map<String, String> yangToJavaNames = Maps.newHashMap();
package org.opendaylight.controller.netconf.confignetconfconnector.mapping.rpc;
import com.google.common.base.Preconditions;
-import org.opendaylight.controller.netconf.confignetconfconnector.operations.runtimerpc.RuntimeRpcElementResolved;
-
import java.util.Map;
+import org.opendaylight.controller.netconf.confignetconfconnector.operations.runtimerpc.RuntimeRpcElementResolved;
public class Rpcs {
private final Map<String, Map<String, ModuleRpcs>> mappedRpcs;
import com.google.common.base.Predicate;
import com.google.common.collect.Collections2;
import com.google.common.collect.Sets;
+import java.util.Map;
+import java.util.Map.Entry;
+import java.util.Set;
+import javax.management.ObjectName;
import org.opendaylight.controller.netconf.confignetconfconnector.mapping.config.InstanceConfig;
import org.opendaylight.controller.netconf.util.xml.XmlUtil;
import org.w3c.dom.Document;
import org.w3c.dom.Element;
-import javax.management.ObjectName;
-import java.util.Map;
-import java.util.Map.Entry;
-import java.util.Set;
-
public class InstanceRuntime {
/**
import com.google.common.collect.HashMultimap;
import com.google.common.collect.Maps;
import com.google.common.collect.Multimap;
-
import java.util.Collection;
import java.util.Map;
import java.util.Set;
-
import javax.management.ObjectName;
-
import org.opendaylight.controller.config.api.jmx.ObjectNameUtil;
import org.opendaylight.controller.netconf.api.xml.XmlNetconfConstants;
import org.opendaylight.controller.netconf.confignetconfconnector.mapping.config.Config;
package org.opendaylight.controller.netconf.confignetconfconnector.operations;
+import com.google.common.base.Optional;
import org.opendaylight.controller.config.api.ConflictingVersionException;
import org.opendaylight.controller.config.api.ValidationException;
import org.opendaylight.controller.config.api.jmx.CommitStatus;
import org.w3c.dom.Document;
import org.w3c.dom.Element;
-import com.google.common.base.Optional;
-
public class Commit extends AbstractConfigNetconfOperation {
- private static final Logger logger = LoggerFactory.getLogger(Commit.class);
+ private static final Logger LOG = LoggerFactory.getLogger(Commit.class);
private final TransactionProvider transactionProvider;
CommitStatus status;
try {
status = this.transactionProvider.commitTransaction();
- logger.trace("Datastore {} committed successfully: {}", Datastore.candidate, status);
+ LOG.trace("Datastore {} committed successfully: {}", Datastore.candidate, status);
} catch (ConflictingVersionException | ValidationException e) {
throw NetconfDocumentedException.wrap(e);
}
- logger.trace("Datastore {} committed successfully: {}", Datastore.candidate, status);
+ LOG.trace("Datastore {} committed successfully: {}", Datastore.candidate, status);
return XmlUtil.createElement(document, XmlNetconfConstants.OK, Optional.<String>absent());
}
* and is available at http://www.eclipse.org/legal/epl-v10.html
*/
- package org.opendaylight.controller.netconf.confignetconfconnector.operations;
+package org.opendaylight.controller.netconf.confignetconfconnector.operations;
import com.google.common.base.Optional;
-
+import java.util.HashMap;
+import java.util.Map;
import org.opendaylight.controller.config.util.ConfigRegistryClient;
import org.opendaylight.controller.netconf.api.NetconfDocumentedException;
import org.opendaylight.controller.netconf.api.NetconfDocumentedException.ErrorSeverity;
import org.w3c.dom.Document;
import org.w3c.dom.Element;
-import java.util.HashMap;
-import java.util.Map;
-
public class DiscardChanges extends AbstractConfigNetconfOperation {
public static final String DISCARD = "discard-changes";
- private static final Logger logger = LoggerFactory.getLogger(DiscardChanges.class);
+ private static final Logger LOG = LoggerFactory.getLogger(DiscardChanges.class);
private final TransactionProvider transactionProvider;
try {
this.transactionProvider.abortTransaction();
} catch (final IllegalStateException e) {
- logger.warn("Abort failed: ", e);
+ LOG.warn("Abort failed: ", e);
final Map<String, String> errorInfo = new HashMap<>();
errorInfo
.put(ErrorTag.operation_failed.name(),
throw new NetconfDocumentedException(e.getMessage(), e, ErrorType.application, ErrorTag.operation_failed,
ErrorSeverity.error, errorInfo);
}
- logger.trace("Changes discarded successfully from datastore {}", Datastore.candidate);
+ LOG.trace("Changes discarded successfully from datastore {}", Datastore.candidate);
return XmlUtil.createElement(document, XmlNetconfConstants.OK, Optional.<String>absent());
package org.opendaylight.controller.netconf.confignetconfconnector.operations;
import com.google.common.base.Optional;
-
+import java.util.HashMap;
+import java.util.Map;
import org.opendaylight.controller.config.api.ValidationException;
import org.opendaylight.controller.config.util.ConfigRegistryClient;
import org.opendaylight.controller.netconf.api.NetconfDocumentedException;
import org.w3c.dom.Document;
import org.w3c.dom.Element;
-import java.util.HashMap;
-import java.util.Map;
-
public class Validate extends AbstractConfigNetconfOperation {
public static final String VALIDATE = "validate";
- private static final Logger logger = LoggerFactory.getLogger(Validate.class);
+ private static final Logger LOG = LoggerFactory.getLogger(Validate.class);
private final TransactionProvider transactionProvider;
try {
transactionProvider.validateTransaction();
} catch (ValidationException e) {
- logger.warn("Validation failed", e);
+ LOG.warn("Validation failed", e);
throw NetconfDocumentedException.wrap(e);
} catch (IllegalStateException e) {
- logger.warn("Validation failed", e);
+ LOG.warn("Validation failed", e);
final Map<String, String> errorInfo = new HashMap<>();
errorInfo
.put(ErrorTag.operation_failed.name(),
}
- logger.trace("Datastore {} validated successfully", Datastore.candidate);
+ LOG.trace("Datastore {} validated successfully", Datastore.candidate);
return XmlUtil.createElement(document, XmlNetconfConstants.OK, Optional.<String>absent());
}
package org.opendaylight.controller.netconf.confignetconfconnector.operations.editconfig;
+import java.util.Map;
+import javax.management.InstanceNotFoundException;
+import javax.management.ObjectName;
import org.opendaylight.controller.config.util.ConfigTransactionClient;
import org.opendaylight.controller.netconf.confignetconfconnector.exception.NetconfConfigHandlingException;
import org.opendaylight.controller.netconf.confignetconfconnector.mapping.attributes.fromxml.AttributeConfigElement;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
-import javax.management.InstanceNotFoundException;
-import javax.management.ObjectName;
-import java.util.Map;
-
public abstract class AbstractEditConfigStrategy implements EditConfigStrategy {
- private static final Logger logger = LoggerFactory.getLogger(AbstractEditConfigStrategy.class);
+ private static final Logger LOG = LoggerFactory.getLogger(AbstractEditConfigStrategy.class);
@Override
public void executeConfiguration(String module, String instance, Map<String, AttributeConfigElement> configuration,
try {
ObjectName on = ta.lookupConfigBean(module, instance);
- logger.debug("ServiceInstance for {} {} located successfully under {}", module, instance, on);
+ LOG.debug("ServiceInstance for {} {} located successfully under {}", module, instance, on);
executeStrategy(configuration, ta, on, services);
} catch (InstanceNotFoundException e) {
handleMissingInstance(configuration, ta, module, instance, services);
public class DeleteEditConfigStrategy extends AbstractEditConfigStrategy {
- private static final Logger logger = LoggerFactory.getLogger(DeleteEditConfigStrategy.class);
+ private static final Logger LOG = LoggerFactory.getLogger(DeleteEditConfigStrategy.class);
@Override
void executeStrategy(Map<String, AttributeConfigElement> configuration, ConfigTransactionClient ta, ObjectName on, ServiceRegistryWrapper services) throws NetconfConfigHandlingException {
try {
ta.destroyModule(on);
- logger.debug("ServiceInstance {} deleted successfully", on);
+ LOG.debug("ServiceInstance {} deleted successfully", on);
} catch (InstanceNotFoundException e) {
throw new NetconfConfigHandlingException(
String.format("Unable to delete %s because of exception %s" + on, e.getMessage()),
import com.google.common.base.Preconditions;
import com.google.common.collect.Maps;
import com.google.common.collect.Multimap;
-
import java.util.Date;
import java.util.HashMap;
import java.util.Map;
import java.util.Set;
-
import javax.management.InstanceNotFoundException;
import javax.management.ObjectName;
-
import org.opendaylight.controller.config.api.ValidationException;
import org.opendaylight.controller.config.util.ConfigRegistryClient;
import org.opendaylight.controller.config.util.ConfigTransactionClient;
public class EditConfig extends AbstractConfigNetconfOperation {
- private static final Logger logger = LoggerFactory.getLogger(EditConfig.class);
+ private static final Logger LOG = LoggerFactory.getLogger(EditConfig.class);
private final YangStoreSnapshot yangStoreSnapshot;
executeSet(getConfigRegistryClient(), editConfigExecution);
}
- logger.trace("Operation {} successful", EditConfigXmlParser.EDIT_CONFIG);
+ LOG.trace("Operation {} successful", EditConfigXmlParser.EDIT_CONFIG);
return XmlUtil.createElement(document, XmlNetconfConstants.OK, Optional.<String>absent());
}
private void executeSet(ConfigRegistryClient configRegistryClient,
EditConfigXmlParser.EditConfigExecution editConfigExecution) throws NetconfDocumentedException {
set(configRegistryClient, editConfigExecution);
- logger.debug("Set phase for {} operation successful", EditConfigXmlParser.EDIT_CONFIG);
+ LOG.debug("Set phase for {} operation successful", EditConfigXmlParser.EDIT_CONFIG);
}
private void executeTests(ConfigRegistryClient configRegistryClient,
try {
test(configRegistryClient, editConfigExecution, editConfigExecution.getDefaultStrategy());
} catch (final ValidationException e) {
- logger.warn("Test phase for {} failed", EditConfigXmlParser.EDIT_CONFIG, e);
+ LOG.warn("Test phase for {} failed", EditConfigXmlParser.EDIT_CONFIG, e);
final Map<String, String> errorInfo = new HashMap<>();
errorInfo.put(ErrorTag.operation_failed.name(), e.getMessage());
throw new NetconfDocumentedException("Test phase: " + e.getMessage(), e, ErrorType.application,
ErrorTag.operation_failed, ErrorSeverity.error, errorInfo);
}
- logger.debug("Test phase for {} operation successful", EditConfigXmlParser.EDIT_CONFIG);
+ LOG.debug("Test phase for {} operation successful", EditConfigXmlParser.EDIT_CONFIG);
}
private void test(ConfigRegistryClient configRegistryClient, EditConfigExecution execution,
ObjectName on = refNameToServiceEntry.getValue().getObjectName(ta.getTransactionName());
try {
ObjectName saved = ta.saveServiceReference(qnameOfService, refNameToServiceEntry.getKey(), on);
- logger.debug("Saving service {} with on {} under name {} with service on {}", qnameOfService,
+ LOG.debug("Saving service {} with on {} under name {} with service on {}", qnameOfService,
on, refNameToServiceEntry.getKey(), saved);
} catch (InstanceNotFoundException e) {
throw new NetconfDocumentedException(String.format("Unable to save ref name " + refNameToServiceEntry.getKey() + " for instance " + on, e),
public static Map<String/* Namespace from yang file */,
Map<String /* Name of module entry from yang file */, ModuleConfig>> transformMbeToModuleConfigs
- (final ConfigRegistryClient configRegistryClient, Map<String/* Namespace from yang file */,
+ (final ConfigRegistryClient configRegistryClient, Map<String/* Namespace from yang file */,
Map<String /* Name of module entry from yang file */, ModuleMXBeanEntry>> mBeanEntries) {
Map<String, Map<String, ModuleConfig>> namespaceToModuleNameToModuleConfig = Maps.newHashMap();
package org.opendaylight.controller.netconf.confignetconfconnector.operations.editconfig;
+import java.util.Map;
import org.opendaylight.controller.config.util.ConfigTransactionClient;
import org.opendaylight.controller.netconf.confignetconfconnector.exception.NetconfConfigHandlingException;
import org.opendaylight.controller.netconf.confignetconfconnector.mapping.attributes.fromxml.AttributeConfigElement;
import org.opendaylight.controller.netconf.confignetconfconnector.mapping.config.ServiceRegistryWrapper;
-import java.util.Map;
-
public interface EditConfigStrategy {
void executeConfiguration(String module, String instance, Map<String, AttributeConfigElement> configuration,
import com.google.common.annotations.VisibleForTesting;
import com.google.common.base.Optional;
import com.google.common.collect.Multimap;
-
import java.util.Arrays;
import java.util.Map;
-
import org.opendaylight.controller.config.api.ServiceReferenceReadableRegistry;
import org.opendaylight.controller.netconf.api.NetconfDocumentedException;
import org.opendaylight.controller.netconf.api.xml.XmlNetconfConstants;
public class EditConfigXmlParser {
- private static final Logger logger = LoggerFactory.getLogger(EditConfigXmlParser.class);
+ private static final Logger LOG = LoggerFactory.getLogger(EditConfigXmlParser.class);
public static final String EDIT_CONFIG = "edit-config";
public static final String DEFAULT_OPERATION_KEY = "default-operation";
targetElement = xml.getOnlyChildElementWithSameNamespace(EditConfigXmlParser.TARGET_KEY);
targetChildNode = targetElement.getOnlyChildElementWithSameNamespace();
} catch (final MissingNameSpaceException | UnexpectedNamespaceException e) {
- logger.trace("Can't get only child element with same namespace due to {}",e);
+ LOG.trace("Can't get only child element with same namespace", e);
throw NetconfDocumentedException.wrap(e);
}
String datastoreValue = targetChildNode.getName();
Datastore targetDatastore = Datastore.valueOf(datastoreValue);
- logger.debug("Setting {} to '{}'", EditConfigXmlParser.TARGET_KEY, targetDatastore);
+ LOG.debug("Setting {} to '{}'", EditConfigXmlParser.TARGET_KEY, targetDatastore);
// check target
if (targetDatastore != Datastore.candidate){
} else {
testOption = EditConfigXmlParser.TestOption.getDefault();
}
- logger.debug("Setting {} to '{}'", EditConfigXmlParser.TEST_OPTION_KEY, testOption);
+ LOG.debug("Setting {} to '{}'", EditConfigXmlParser.TEST_OPTION_KEY, testOption);
// Error option
Optional<XmlElement> errorOptionElement = xml
.getOnlyChildElementWithSameNamespaceOptionally(EditConfigXmlParser.DEFAULT_OPERATION_KEY);
if (defaultContent.isPresent()) {
String mergeStrategyString = defaultContent.get().getTextContent();
- logger.trace("Setting merge strategy to {}", mergeStrategyString);
+ LOG.trace("Setting merge strategy to {}", mergeStrategyString);
editStrategyType = EditStrategyType.valueOf(mergeStrategyString);
}
try {
configElement = xml.getOnlyChildElementWithSameNamespace(XmlNetconfConstants.CONFIG_KEY);
} catch (MissingNameSpaceException e) {
- logger.trace("Can't get only child element with same namespace due to {}",e);
+ LOG.trace("Can't get only child element with same namespace due to ",e);
throw NetconfDocumentedException.wrap(e);
}
public class MergeEditConfigStrategy extends AbstractEditConfigStrategy {
- private static final Logger logger = LoggerFactory.getLogger(MergeEditConfigStrategy.class);
+ private static final Logger LOG = LoggerFactory.getLogger(MergeEditConfigStrategy.class);
public MergeEditConfigStrategy() {
AttributeConfigElement ace = configAttributeEntry.getValue();
if (!ace.getResolvedValue().isPresent()) {
- logger.debug("Skipping attribute {} for {}", configAttributeEntry.getKey(), on);
+ LOG.debug("Skipping attribute {} for {}", configAttributeEntry.getKey(), on);
continue;
}
// Merge value with currentValue
toBeMergedIn = merge(oldValue, toBeMergedIn);
ta.setAttribute(on, ace.getJmxName(), new Attribute(ace.getJmxName(), toBeMergedIn));
- logger.debug("Attribute {} set to {} for {}", configAttributeEntry.getKey(), toBeMergedIn, on);
+ LOG.debug("Attribute {} set to {} for {}", configAttributeEntry.getKey(), toBeMergedIn, on);
} catch (Exception e) {
- logger.error("Error while merging objectnames of {}", on, e);
+ LOG.error("Error while merging objectnames of {}", on, e);
throw new NetconfConfigHandlingException(String.format("Unable to set attributes for %s, Error with attribute %s : %s ",
on,
configAttributeEntry.getKey(),
package org.opendaylight.controller.netconf.confignetconfconnector.operations.editconfig;
+import java.util.Map;
+import javax.management.InstanceAlreadyExistsException;
+import javax.management.ObjectName;
import org.opendaylight.controller.config.util.ConfigTransactionClient;
import org.opendaylight.controller.netconf.api.NetconfDocumentedException;
import org.opendaylight.controller.netconf.confignetconfconnector.exception.NetconfConfigHandlingException;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
-import javax.management.InstanceAlreadyExistsException;
-import javax.management.ObjectName;
-import java.util.Map;
-
public class MissingInstanceHandlingStrategy extends AbstractEditConfigStrategy {
- private static final Logger logger = LoggerFactory.getLogger(MissingInstanceHandlingStrategy.class);
+ private static final Logger LOG = LoggerFactory.getLogger(MissingInstanceHandlingStrategy.class);
@Override
void handleMissingInstance(Map<String, AttributeConfigElement> configuration, ConfigTransactionClient ta,
String module, String instance, ServiceRegistryWrapper services) throws NetconfConfigHandlingException {
try {
ObjectName on = ta.createModule(module, instance);
- logger.trace("New instance for {} {} created under name {}", module, instance, on);
+ LOG.trace("New instance for {} {} created under name {}", module, instance, on);
} catch (InstanceAlreadyExistsException e1) {
throw new NetconfConfigHandlingException(String.format("Unable to create instance for %s : %s.", module, instance),
NetconfDocumentedException.ErrorType.application,
package org.opendaylight.controller.netconf.confignetconfconnector.operations.editconfig;
+import java.util.Map;
import org.opendaylight.controller.config.util.ConfigTransactionClient;
import org.opendaylight.controller.netconf.confignetconfconnector.mapping.attributes.fromxml.AttributeConfigElement;
import org.opendaylight.controller.netconf.confignetconfconnector.mapping.config.ServiceRegistryWrapper;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
-import java.util.Map;
-
public class NoneEditConfigStrategy implements EditConfigStrategy {
- private static final Logger logger = LoggerFactory.getLogger(NoneEditConfigStrategy.class);
+ private static final Logger LOG = LoggerFactory.getLogger(NoneEditConfigStrategy.class);
@Override
public void executeConfiguration(String module, String instance, Map<String, AttributeConfigElement> configuration,
ConfigTransactionClient ta, ServiceRegistryWrapper services) {
- logger.debug("Skipping configuration element for {}:{}", module, instance);
+ LOG.debug("Skipping configuration element for {}:{}", module, instance);
}
}
package org.opendaylight.controller.netconf.confignetconfconnector.operations.editconfig;
+import java.util.Map;
import org.opendaylight.controller.config.util.ConfigTransactionClient;
import org.opendaylight.controller.netconf.confignetconfconnector.mapping.attributes.fromxml.AttributeConfigElement;
import org.opendaylight.controller.netconf.confignetconfconnector.mapping.config.ServiceRegistryWrapper;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
-import java.util.Map;
-
public class RemoveEditConfigStrategy extends DeleteEditConfigStrategy {
- private static final Logger logger = LoggerFactory.getLogger(RemoveEditConfigStrategy.class);
+ private static final Logger LOG = LoggerFactory.getLogger(RemoveEditConfigStrategy.class);
@Override
void handleMissingInstance(Map<String, AttributeConfigElement> configuration, ConfigTransactionClient ta,
String module, String instance, ServiceRegistryWrapper services) {
- logger.warn("Unable to delete {}:{}, ServiceInstance not found", module, instance);
+ LOG.warn("Unable to delete {}:{}, ServiceInstance not found", module, instance);
}
}
public class ReplaceEditConfigStrategy extends AbstractEditConfigStrategy {
- private static final Logger logger = LoggerFactory.getLogger(ReplaceEditConfigStrategy.class);
+ private static final Logger LOG = LoggerFactory.getLogger(ReplaceEditConfigStrategy.class);
@Override
void handleMissingInstance(Map<String, AttributeConfigElement> configuration, ConfigTransactionClient ta,
if (!ace.getResolvedValue().isPresent()) {
Object value = ace.getResolvedDefaultValue();
ta.setAttribute(on, ace.getJmxName(), new Attribute(ace.getJmxName(), value));
- logger.debug("Attribute {} set to default value {} for {}", configAttributeEntry.getKey(), value,
+ LOG.debug("Attribute {} set to default value {} for {}", configAttributeEntry.getKey(), value,
on);
} else {
Object value = ace.getResolvedValue().get();
ta.setAttribute(on, ace.getJmxName(), new Attribute(ace.getJmxName(), value));
- logger.debug("Attribute {} set to value {} for {}", configAttributeEntry.getKey(), value, on);
+ LOG.debug("Attribute {} set to value {} for {}", configAttributeEntry.getKey(), value, on);
}
} catch (Exception e) {
package org.opendaylight.controller.netconf.confignetconfconnector.operations.get;
import com.google.common.collect.Maps;
-
import java.util.List;
import java.util.Map;
import java.util.Set;
-
import javax.management.ObjectName;
-
import org.opendaylight.controller.config.util.ConfigRegistryClient;
import org.opendaylight.controller.config.yangjmxgenerator.ModuleMXBeanEntry;
import org.opendaylight.controller.config.yangjmxgenerator.RuntimeBeanEntry;
public class Get extends AbstractConfigNetconfOperation {
private final YangStoreSnapshot yangStoreSnapshot;
- private static final Logger logger = LoggerFactory.getLogger(Get.class);
+ private static final Logger LOG = LoggerFactory.getLogger(Get.class);
public Get(YangStoreSnapshot yangStoreSnapshot, ConfigRegistryClient configRegistryClient,
String netconfSessionIdForReporting) {
final Element element = runtime.toXml(runtimeBeans, configBeans, document);
- logger.trace("{} operation successful", XmlNetconfConstants.GET);
+ LOG.trace("{} operation successful", XmlNetconfConstants.GET);
return element;
}
package org.opendaylight.controller.netconf.confignetconfconnector.operations.getconfig;
import java.util.Set;
-
import javax.management.ObjectName;
-
import org.opendaylight.controller.config.util.ConfigRegistryClient;
import org.opendaylight.controller.config.util.ConfigTransactionClient;
import org.opendaylight.controller.netconf.confignetconfconnector.transactions.TransactionProvider;
package org.opendaylight.controller.netconf.confignetconfconnector.operations.getconfig;
import java.util.Set;
-
import javax.management.ObjectName;
-
import org.opendaylight.controller.config.util.ConfigRegistryClient;
public interface DatastoreQueryStrategy {
private final TransactionProvider transactionProvider;
- private static final Logger logger = LoggerFactory.getLogger(GetConfig.class);
+ private static final Logger LOG = LoggerFactory.getLogger(GetConfig.class);
public GetConfig(YangStoreSnapshot yangStoreSnapshot, Optional<String> maybeNamespace,
TransactionProvider transactionProvider, ConfigRegistryClient configRegistryClient,
XmlNetconfConstants.URN_IETF_PARAMS_XML_NS_NETCONF_BASE_1_0);
XmlElement sourceNode = sourceElement.getOnlyChildElement();
String sourceParsed = sourceNode.getName();
- logger.debug("Setting source datastore to '{}'", sourceParsed);
+ LOG.debug("Setting source datastore to '{}'", sourceParsed);
Datastore sourceDatastore = Datastore.valueOf(sourceParsed);
// Filter option: ignore for now, TODO only load modules specified by the filter
ServiceRegistryWrapper serviceTracker = new ServiceRegistryWrapper(ta);
dataElement = configMapping.toXml(instances, this.maybeNamespace, document, dataElement, serviceTracker);
- logger.trace("{} operation successful", GET_CONFIG);
+ LOG.trace("{} operation successful", GET_CONFIG);
return dataElement;
}
package org.opendaylight.controller.netconf.confignetconfconnector.operations.getconfig;
import java.util.Set;
-
import javax.management.ObjectName;
-
import org.opendaylight.controller.config.util.ConfigRegistryClient;
public class RunningDatastoreQueryStrategy implements DatastoreQueryStrategy {
import com.google.common.base.Optional;
import com.google.common.base.Preconditions;
import com.google.common.collect.Maps;
-
+import java.util.Map;
+import javax.management.ObjectName;
+import javax.management.openmbean.OpenType;
import org.opendaylight.controller.config.util.ConfigRegistryClient;
import org.opendaylight.controller.config.yangjmxgenerator.ModuleMXBeanEntry;
import org.opendaylight.controller.config.yangjmxgenerator.RuntimeBeanEntry;
import org.opendaylight.controller.netconf.confignetconfconnector.mapping.rpc.ModuleRpcs;
import org.opendaylight.controller.netconf.confignetconfconnector.mapping.rpc.Rpcs;
import org.opendaylight.controller.netconf.confignetconfconnector.operations.AbstractConfigNetconfOperation;
-import org.opendaylight.controller.netconf.confignetconfconnector.operations.Commit;
import org.opendaylight.controller.netconf.confignetconfconnector.osgi.YangStoreSnapshot;
import org.opendaylight.controller.netconf.mapping.api.HandlingPriority;
import org.opendaylight.controller.netconf.util.exception.MissingNameSpaceException;
import org.w3c.dom.Document;
import org.w3c.dom.Element;
-import javax.management.ObjectName;
-import javax.management.openmbean.OpenType;
-
-import java.util.Map;
-
public class RuntimeRpc extends AbstractConfigNetconfOperation {
- private static final Logger logger = LoggerFactory.getLogger(Commit.class);
+ private static final Logger LOG = LoggerFactory.getLogger(RuntimeRpc.class);
public static final String CONTEXT_INSTANCE = "context-instance";
private final YangStoreSnapshot yangStoreSnapshot;
try {
namespace = xml.getNamespace();
} catch (MissingNameSpaceException e) {
- logger.trace("Can't get namespace from xml element due to {}",e);
+ LOG.trace("Can't get namespace from xml element due to ",e);
throw NetconfDocumentedException.wrap(e);
}
final XmlElement contextInstanceElement = xml.getOnlyChildElement(CONTEXT_INSTANCE);
try {
netconfOperationNamespace = operationElement.getNamespace();
} catch (MissingNameSpaceException e) {
- logger.debug("Cannot retrieve netconf operation namespace from message due to {}", e);
+ LOG.debug("Cannot retrieve netconf operation namespace from message due to ", e);
return HandlingPriority.CANNOT_HANDLE;
}
netconfOperationName);
} catch (IllegalStateException e) {
- logger.debug("Cannot handle runtime operation {}:{}", netconfOperationNamespace, netconfOperationName, e);
+ LOG.debug("Cannot handle runtime operation {}:{}", netconfOperationNamespace, netconfOperationName, e);
return HandlingPriority.CANNOT_HANDLE;
}
// TODO check for namespaces and unknown elements
final NetconfOperationExecution execution = fromXml(xml);
- logger.debug("Invoking operation {} on {} with arguments {}", execution.operationName, execution.on,
+ LOG.debug("Invoking operation {} on {} with arguments {}", execution.operationName, execution.on,
execution.attributes);
final Object result = executeOperation(getConfigRegistryClient(), execution.on, execution.operationName,
execution.attributes);
- logger.trace("Operation {} called successfully on {} with arguments {} with result {}", execution.operationName,
+ LOG.trace("Operation {} called successfully on {} with arguments {} with result {}", execution.operationName,
execution.on, execution.attributes, result);
if (execution.isVoid()) {
package org.opendaylight.controller.netconf.confignetconfconnector.operations.runtimerpc;
+import com.google.common.annotations.VisibleForTesting;
+import com.google.common.base.Preconditions;
+import com.google.common.base.Strings;
+import com.google.common.collect.Maps;
import java.util.HashMap;
import java.util.Map;
import java.util.regex.Matcher;
import java.util.regex.Pattern;
-
import javax.management.ObjectName;
-
import org.opendaylight.controller.config.api.jmx.ObjectNameUtil;
import org.opendaylight.controller.netconf.api.xml.XmlNetconfConstants;
import org.opendaylight.controller.netconf.confignetconfconnector.mapping.rpc.ModuleRpcs;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.controller.config.rev130405.Modules;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.controller.config.rev130405.modules.Module;
-import com.google.common.annotations.VisibleForTesting;
-import com.google.common.base.Preconditions;
-import com.google.common.base.Strings;
-import com.google.common.collect.Maps;
-
/**
* Represents parsed xpath to runtime bean instance
*/
package org.opendaylight.controller.netconf.confignetconfconnector.osgi;
+import static com.google.common.base.Preconditions.checkState;
+
+import java.util.Dictionary;
+import java.util.Hashtable;
import org.opendaylight.controller.netconf.mapping.api.NetconfOperationServiceFactory;
import org.opendaylight.yangtools.yang.model.api.SchemaContextProvider;
import org.osgi.framework.BundleActivator;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
-import java.util.Dictionary;
-import java.util.Hashtable;
-
-import static com.google.common.base.Preconditions.checkState;
-
public class Activator implements BundleActivator {
- private static final Logger logger = LoggerFactory.getLogger(Activator.class);
+ private static final Logger LOG = LoggerFactory.getLogger(Activator.class);
private BundleContext context;
private ServiceRegistration osgiRegistration;
ServiceTrackerCustomizer<SchemaContextProvider, ConfigRegistryLookupThread> customizer = new ServiceTrackerCustomizer<SchemaContextProvider, ConfigRegistryLookupThread>() {
@Override
public ConfigRegistryLookupThread addingService(ServiceReference<SchemaContextProvider> reference) {
- logger.debug("Got addingService(SchemaContextProvider) event, starting ConfigRegistryLookupThread");
+ LOG.debug("Got addingService(SchemaContextProvider) event, starting ConfigRegistryLookupThread");
checkState(configRegistryLookup == null, "More than one onYangStoreAdded received");
SchemaContextProvider schemaContextProvider = reference.getBundle().getBundleContext().getService(reference);
@Override
public void modifiedService(ServiceReference<SchemaContextProvider> reference, ConfigRegistryLookupThread configRegistryLookup) {
- logger.debug("Got modifiedService(SchemaContextProvider) event");
+ LOG.debug("Got modifiedService(SchemaContextProvider) event");
configRegistryLookup.yangStoreService.refresh();
}
@Override
public void run() {
NetconfOperationServiceFactoryImpl factory = new NetconfOperationServiceFactoryImpl(yangStoreService);
- logger.debug("Registering into OSGi");
+ LOG.debug("Registering into OSGi");
Dictionary<String, String> properties = new Hashtable<>();
properties.put("name", "config-netconf-connector");
osgiRegistration = context.registerService(NetconfOperationServiceFactory.class, factory, properties);
import com.google.common.base.Optional;
import com.google.common.collect.Sets;
+import java.util.Set;
import org.opendaylight.controller.config.util.ConfigRegistryClient;
import org.opendaylight.controller.netconf.confignetconfconnector.operations.Commit;
import org.opendaylight.controller.netconf.confignetconfconnector.operations.DiscardChanges;
import org.opendaylight.controller.netconf.confignetconfconnector.transactions.TransactionProvider;
import org.opendaylight.controller.netconf.mapping.api.NetconfOperation;
-import java.util.Set;
-
final class NetconfOperationProvider {
private final Set<NetconfOperation> operations;
package org.opendaylight.controller.netconf.confignetconfconnector.osgi;
+import java.lang.management.ManagementFactory;
+import javax.management.MBeanServer;
import org.opendaylight.controller.config.util.ConfigRegistryJMXClient;
import org.opendaylight.controller.netconf.mapping.api.NetconfOperationServiceFactory;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
-import javax.management.MBeanServer;
-import java.lang.management.ManagementFactory;
-
public class NetconfOperationServiceFactoryImpl implements NetconfOperationServiceFactory {
public static final int ATTEMPT_TIMEOUT_MS = 1000;
private final YangStoreService yangStoreService;
private final ConfigRegistryJMXClient jmxClient;
- private static final Logger logger = LoggerFactory.getLogger(NetconfOperationServiceFactoryImpl.class);
+ private static final Logger LOG = LoggerFactory.getLogger(NetconfOperationServiceFactoryImpl.class);
public NetconfOperationServiceFactoryImpl(YangStoreService yangStoreService) {
this(yangStoreService, ManagementFactory.getPlatformMBeanServer());
} catch (IllegalStateException e) {
++i;
if (i > SILENT_ATTEMPTS) {
- logger.info("JMX client not created after {} attempts, still trying", i, e);
+ LOG.info("JMX client not created after {} attempts, still trying", i, e);
} else {
- logger.debug("JMX client could not be created, reattempting, try {}", i, e);
+ LOG.debug("JMX client could not be created, reattempting, try {}", i, e);
}
try {
Thread.sleep(ATTEMPT_TIMEOUT_MS);
jmxClient = configRegistryJMXClient;
if (i > SILENT_ATTEMPTS) {
- logger.info("Created JMX client after {} attempts", i);
+ LOG.info("Created JMX client after {} attempts", i);
} else {
- logger.debug("Created JMX client after {} attempts", i);
+ LOG.debug("Created JMX client after {} attempts", i);
}
}
package org.opendaylight.controller.netconf.confignetconfconnector.osgi;
+import com.google.common.annotations.VisibleForTesting;
+import com.google.common.base.Optional;
+import com.google.common.base.Preconditions;
+import com.google.common.collect.Sets;
import java.util.HashSet;
import java.util.List;
import java.util.Map;
import java.util.Set;
-
import org.opendaylight.controller.config.api.LookupRegistry;
import org.opendaylight.controller.config.util.ConfigRegistryJMXClient;
import org.opendaylight.controller.config.yangjmxgenerator.ModuleMXBeanEntry;
import org.opendaylight.controller.netconf.mapping.api.NetconfOperationService;
import org.opendaylight.yangtools.yang.model.api.Module;
-import com.google.common.annotations.VisibleForTesting;
-import com.google.common.base.Optional;
-import com.google.common.base.Preconditions;
-import com.google.common.collect.Sets;
-
/**
* Manages life cycle of {@link YangStoreSnapshot}.
*/
import java.lang.ref.SoftReference;
import java.util.concurrent.atomic.AtomicReference;
-
import org.opendaylight.yangtools.yang.model.api.SchemaContextProvider;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
*/
package org.opendaylight.controller.netconf.confignetconfconnector.osgi;
+import java.util.Map;
+import java.util.Set;
import org.opendaylight.controller.config.yangjmxgenerator.ModuleMXBeanEntry;
import org.opendaylight.yangtools.yang.common.QName;
import org.opendaylight.yangtools.yang.model.api.Module;
import org.opendaylight.yangtools.yang.model.api.ModuleIdentifier;
-import java.util.Map;
-import java.util.Set;
-
public interface YangStoreSnapshot extends AutoCloseable {
/**
package org.opendaylight.controller.netconf.confignetconfconnector.osgi;
import com.google.common.collect.Maps;
-
import java.util.Collections;
import java.util.HashMap;
import java.util.Map;
import java.util.Map.Entry;
import java.util.Set;
-
import org.opendaylight.controller.config.yangjmxgenerator.ModuleMXBeanEntry;
import org.opendaylight.controller.config.yangjmxgenerator.PackageTranslator;
import org.opendaylight.controller.config.yangjmxgenerator.ServiceInterfaceEntry;
import org.slf4j.LoggerFactory;
public class YangStoreSnapshotImpl implements YangStoreSnapshot {
- private static final Logger logger = LoggerFactory.getLogger(YangStoreSnapshotImpl.class);
+ private static final Logger LOG = LoggerFactory.getLogger(YangStoreSnapshotImpl.class);
private final Map<String /* Namespace from yang file */,
public YangStoreSnapshotImpl(final SchemaContext resolveSchemaContext) {
- logger.trace("Resolved modules:{}", resolveSchemaContext.getModules());
+ LOG.trace("Resolved modules:{}", resolveSchemaContext.getModules());
this.schemaContext = resolveSchemaContext;
// JMX generator
import com.google.common.base.Optional;
import com.google.common.base.Preconditions;
+import java.util.ArrayList;
+import java.util.List;
+import java.util.Set;
+import javax.management.InstanceNotFoundException;
+import javax.management.ObjectName;
import org.opendaylight.controller.config.api.ConflictingVersionException;
import org.opendaylight.controller.config.api.ValidationException;
import org.opendaylight.controller.config.api.jmx.CommitStatus;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
-import javax.management.InstanceNotFoundException;
-import javax.management.ObjectName;
-import java.util.ArrayList;
-import java.util.List;
-import java.util.Set;
-
public class TransactionProvider implements AutoCloseable {
- private static final Logger logger = LoggerFactory.getLogger(TransactionProvider.class);
+ private static final Logger LOG = LoggerFactory.getLogger(TransactionProvider.class);
private final ConfigRegistryClient configRegistryClient;
configRegistryClient.getConfigTransactionClient(tx).abortConfig();
}
} catch (Exception e) {
- logger.debug("Ignoring exception while closing transaction {}", tx, e);
+ LOG.debug("Ignoring exception while closing transaction {}", tx, e);
}
}
allOpenedTransactions.clear();
// Transaction was already closed somehow
if (!isStillOpenTransaction(transaction)) {
- logger.warn("Fixing illegal state: transaction {} was closed in {}", transaction,
+ LOG.warn("Fixing illegal state: transaction {} was closed in {}", transaction,
netconfSessionIdForReporting);
transaction = null;
return Optional.absent();
return status;
} catch (ValidationException validationException) {
// no clean up: user can reconfigure and recover this transaction
- logger.warn("Transaction {} failed on {}", taON, validationException.toString());
+ LOG.warn("Transaction {} failed on {}", taON, validationException.toString());
throw validationException;
} catch (ConflictingVersionException e) {
- logger.error("Exception while commit of {}, aborting transaction", taON, e);
+ LOG.error("Exception while commit of {}, aborting transaction", taON, e);
// clean up
abortTransaction();
throw e;
}
public synchronized void abortTransaction() {
- logger.debug("Aborting current transaction");
+ LOG.debug("Aborting current transaction");
Optional<ObjectName> taON = getTransaction();
Preconditions.checkState(taON.isPresent(), NO_TRANSACTION_FOUND_FOR_SESSION + netconfSessionIdForReporting);
}
public synchronized void abortTestTransaction(ObjectName testTx) {
- logger.debug("Aborting transaction {}", testTx);
+ LOG.debug("Aborting transaction {}", testTx);
ConfigTransactionClient transactionClient = configRegistryClient.getConfigTransactionClient(testTx);
allOpenedTransactions.remove(testTx);
transactionClient.abortConfig();
transactionClient.destroyModule(instance);
} catch (InstanceNotFoundException e) {
if (isTest){
- logger.debug("Unable to clean configuration in transactiom {}", taON, e);
+ LOG.debug("Unable to clean configuration in transactiom {}", taON, e);
} else {
- logger.warn("Unable to clean configuration in transactiom {}", taON, e);
+ LOG.warn("Unable to clean configuration in transactiom {}", taON, e);
}
throw new IllegalStateException("Unable to clean configuration in transactiom " + taON, e);
}
}
- logger.debug("Transaction {} wiped clean of {} config beans", taON, i);
+ LOG.debug("Transaction {} wiped clean of {} config beans", taON, i);
transactionClient.removeAllServiceReferences();
- logger.debug("Transaction {} wiped clean of all service references", taON);
+ LOG.debug("Transaction {} wiped clean of all service references", taON);
}
public void wipeTransaction() {
package org.opendaylight.controller.netconf.confignetconfconnector.util;
-import com.google.common.base.Preconditions;
+import static org.opendaylight.yangtools.yang.common.SimpleDateFormatUtil.getRevisionFormat;
+import com.google.common.base.Preconditions;
import java.text.ParseException;
import java.util.Date;
-import static org.opendaylight.yangtools.yang.common.SimpleDateFormatUtil.getRevisionFormat;
-
public final class Util {
public static String writeDate(final Date date) {
import com.google.common.collect.Lists;
import com.google.common.collect.Maps;
import com.google.common.collect.Sets;
-
import java.io.FileNotFoundException;
import java.io.IOException;
import java.io.InputStream;
import java.util.Map;
import java.util.Map.Entry;
import java.util.Set;
-
import javax.management.InstanceAlreadyExistsException;
import javax.management.InstanceNotFoundException;
import javax.management.ObjectName;
import javax.xml.parsers.ParserConfigurationException;
-
import org.custommonkey.xmlunit.AbstractNodeTester;
import org.custommonkey.xmlunit.NodeTest;
import org.custommonkey.xmlunit.NodeTestException;
public class NetconfMappingTest extends AbstractConfigTest {
- private static final Logger logger = LoggerFactory.getLogger(NetconfMappingTest.class);
+ private static final Logger LOG = LoggerFactory.getLogger(NetconfMappingTest.class);
private static final String INSTANCE_NAME = "instance-from-code";
private static final String NETCONF_SESSION_ID = "foo";
for (int i = 0; i < TESTS_COUNT; i++) {
String file = String.format(format, i + 1);
- logger.info("Reading {}", file);
+ LOG.info("Reading {}", file);
try {
edit(file);
} catch (NetconfDocumentedException e) {
final Document request = XmlFileLoader.xmlFileToDocument(filename);
- logger.debug("Executing netconf operation\n{}", XmlUtil.toString(request));
+ LOG.debug("Executing netconf operation\n{}", XmlUtil.toString(request));
HandlingPriority priority = op.canHandle(request);
Preconditions.checkState(priority != HandlingPriority.CANNOT_HANDLE);
final Document response = op.handle(request, NetconfOperationChainedExecution.EXECUTION_TERMINATION_POINT);
- logger.debug("Got response\n{}", XmlUtil.toString(response));
+ LOG.debug("Got response\n{}", XmlUtil.toString(response));
return response;
}
package org.opendaylight.controller.netconf.confignetconfconnector;
+import static org.junit.Assert.assertEquals;
+
import org.junit.Test;
import org.opendaylight.controller.netconf.confignetconfconnector.mapping.config.Services;
import org.opendaylight.controller.netconf.confignetconfconnector.mapping.config.Services.ServiceInstance;
-import static org.junit.Assert.assertEquals;
-
public class ServiceTrackerTest {
@Test
package org.opendaylight.controller.netconf.confignetconfconnector.operations;
+import static org.junit.Assert.assertEquals;
+import static org.mockito.Mockito.doNothing;
+import static org.mockito.Mockito.doThrow;
+import static org.mockito.Mockito.mock;
+
import org.junit.Test;
import org.opendaylight.controller.config.api.ValidationException;
import org.opendaylight.controller.netconf.api.NetconfDocumentedException;
import org.opendaylight.controller.netconf.util.xml.XmlUtil;
import org.w3c.dom.Element;
-import static org.junit.Assert.assertEquals;
-import static org.mockito.Mockito.doNothing;
-import static org.mockito.Mockito.doThrow;
-import static org.mockito.Mockito.mock;
-
public class ValidateTest {
public static final String NETCONF_SESSION_ID_FOR_REPORTING = "foo";
package org.opendaylight.controller.netconf.confignetconfconnector.operations.editconfig;
+import static org.mockito.Matchers.any;
+import static org.mockito.Matchers.anyMapOf;
+import static org.mockito.Matchers.anyString;
+import static org.mockito.Mockito.doNothing;
+import static org.mockito.Mockito.doReturn;
+import static org.mockito.Mockito.mock;
+import static org.mockito.Mockito.times;
+import static org.mockito.Mockito.verify;
+
import com.google.common.base.Optional;
import com.google.common.collect.HashMultimap;
import com.google.common.collect.Maps;
import com.google.common.collect.Multimap;
+import java.util.Collections;
+import java.util.Map;
+import javax.management.ObjectName;
import org.junit.Before;
import org.junit.Test;
import org.mockito.Mock;
import org.opendaylight.controller.netconf.confignetconfconnector.transactions.TransactionProvider;
import org.opendaylight.controller.netconf.util.xml.XmlUtil;
-import javax.management.ObjectName;
-import java.util.Collections;
-import java.util.Map;
-
-import static org.mockito.Matchers.any;
-import static org.mockito.Matchers.anyMapOf;
-import static org.mockito.Matchers.anyString;
-import static org.mockito.Mockito.doNothing;
-import static org.mockito.Mockito.doReturn;
-import static org.mockito.Mockito.mock;
-import static org.mockito.Mockito.times;
-import static org.mockito.Mockito.verify;
-
public class EditConfigTest {
@Mock
import com.google.common.collect.Maps;
import com.google.common.collect.Sets;
-
import java.net.URI;
import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.Date;
import java.util.Map;
import java.util.Set;
-
import org.junit.Assert;
import org.junit.Test;
import org.hamcrest.CoreMatchers;
Code Review / controller.git / commitdiff