@Override
AttributeConfigElement readElementHook(List<XmlElement> configNodes) throws NetconfDocumentedException {
List<Object> innerList = Lists.newArrayList();
- for (int i = 0; i < configNodes.size(); i++) {
- innerList.add(innerStrategy.readElement(Lists.newArrayList(configNodes.get(i))).getValue());
+ for (XmlElement configNode : configNodes) {
+ innerList.add(innerStrategy.readElement(Lists.newArrayList(configNode)).getValue());
}
return AttributeConfigElement.create(getNullableDefault(), innerList);
}
package org.opendaylight.controller.netconf.confignetconfconnector.mapping.attributes.fromxml;
import com.google.common.base.Preconditions;
+import java.util.List;
+import java.util.Map;
import org.opendaylight.controller.netconf.api.NetconfDocumentedException;
import org.opendaylight.controller.netconf.confignetconfconnector.mapping.attributes.mapping.ObjectNameAttributeMappingStrategy;
import org.opendaylight.controller.netconf.util.xml.XmlElement;
import org.opendaylight.controller.netconf.util.xml.XmlNetconfConstants;
-import org.slf4j.Logger;
-import org.slf4j.LoggerFactory;
-
-import java.util.List;
-import java.util.Map;
public class ObjectNameAttributeReadingStrategy extends AbstractAttributeReadingStrategy {
private static final Object PREFIX_SEPARATOR = ":";
- private static final Logger logger = LoggerFactory.getLogger(ObjectNameAttributeReadingStrategy.class);
public ObjectNameAttributeReadingStrategy(String nullableDefault) {
super(nullableDefault);
}
private ObjectNameAttributeMappingStrategy.MappedDependency resolve(XmlElement firstChild) throws NetconfDocumentedException{
- XmlElement typeElement = null;
- typeElement = firstChild.getOnlyChildElementWithSameNamespace(XmlNetconfConstants.TYPE_KEY);
+ XmlElement typeElement = firstChild.getOnlyChildElementWithSameNamespace(XmlNetconfConstants.TYPE_KEY);
Map.Entry<String, String> prefixNamespace = typeElement.findNamespaceOfTextContent();
String serviceName = checkPrefixAndExtractServiceName(typeElement, prefixNamespace);
public static String checkPrefixAndExtractServiceName(XmlElement typeElement, Map.Entry<String, String> prefixNamespace) throws NetconfDocumentedException {
String serviceName = typeElement.getTextContent();
-
+ // FIXME: comparing Entry with String:
Preconditions.checkState(!prefixNamespace.equals(""), "Service %s value not prefixed with namespace",
XmlNetconfConstants.TYPE_KEY);
String prefix = prefixNamespace.getKey() + PREFIX_SEPARATOR;
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.DependencyAttribute;
import org.opendaylight.controller.config.yangjmxgenerator.attribute.ListAttribute;
import org.opendaylight.controller.config.yangjmxgenerator.attribute.ListDependenciesAttribute;
import org.opendaylight.controller.config.yangjmxgenerator.attribute.TOAttribute;
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 ObjectMapper extends AttributeIfcSwitchStatement<AttributeMappingStrategy<?, ? extends OpenType<?>>> {
- private final ServiceRegistryWrapper dependencyTracker;
-
- public ObjectMapper(ServiceRegistryWrapper depTracker) {
- this.dependencyTracker = depTracker;
- }
public Map<String, AttributeMappingStrategy<?, ? extends OpenType<?>>> prepareMapping(
Map<String, AttributeIfc> configDefinition) {
@Override
protected Object parseObject(Class<?> type, String value) {
- return new Character(value.charAt(0));
+ return value.charAt(0);
}
}
+++ /dev/null
-/*
- * Copyright (c) 2013 Cisco Systems, Inc. and others. All rights reserved.
- *
- * This program and the accompanying materials are made available under the
- * terms of the Eclipse Public License v1.0 which accompanies this distribution,
- * and is available at http://www.eclipse.org/legal/epl-v10.html
- */
-package org.opendaylight.controller.netconf.confignetconfconnector.mapping.attributes.toxml;
-
-public abstract class AbstractAttributeWritingStrategy {
- protected Object preprocess(Object value) {
- return value;
- }
-}
Util.checkType(runtimeBeanInstanceMappingEntry.getValue(), Map.class);
Map<?, ?> innerMap = (Map<?, ?>) runtimeBeanInstanceMappingEntry.getValue();
Element runtimeInstanceNode = XmlUtil.createElement(getDocument(), "_"
- + (String) runtimeBeanInstanceMappingEntry.getKey(), Optional.<String>absent());
+ + runtimeBeanInstanceMappingEntry.getKey(), Optional.<String>absent());
innerNode.appendChild(runtimeInstanceNode);
for (Entry<?, ?> innerObjectEntry : innerMap.entrySet()) {
package org.opendaylight.controller.netconf.confignetconfconnector.mapping.config;
+import static com.google.common.base.Preconditions.checkState;
+
import com.google.common.base.Optional;
import com.google.common.base.Preconditions;
import com.google.common.collect.HashMultimap;
import org.opendaylight.controller.netconf.util.xml.XmlUtil;
import org.w3c.dom.Document;
import org.w3c.dom.Element;
-import static com.google.common.base.Preconditions.checkState;
public class Config {
Map<String, Map<String, Collection<ObjectName>>> moduleToInstances = getMappedInstances(instancesToMap,
moduleConfigs);
- Element root = dataElement;
if (maybeNamespace.isPresent()) {
- root.setAttributeNS(maybeNamespace.get(), dataElement.getNodeName(), "xmlns");
+ dataElement.setAttributeNS(maybeNamespace.get(), dataElement.getNodeName(), "xmlns");
}
Element modulesElement = XmlUtil.createElement(document, XmlNetconfConstants.MODULES_KEY, Optional.of(XmlNetconfConstants.URN_OPENDAYLIGHT_PARAMS_XML_NS_YANG_CONTROLLER_CONFIG));
- root.appendChild(modulesElement);
+ dataElement.appendChild(modulesElement);
for (String moduleNamespace : moduleToInstances.keySet()) {
for (Entry<String, Collection<ObjectName>> moduleMappingEntry : moduleToInstances.get(moduleNamespace)
.entrySet()) {
}
for (ObjectName objectName : moduleMappingEntry.getValue()) {
- modulesElement.appendChild(mapping.toXml(objectName, serviceTracker, document, moduleNamespace));
+ modulesElement.appendChild(mapping.toXml(objectName, document, moduleNamespace));
}
}
}
- root.appendChild(Services.toXml(serviceTracker, document));
+ dataElement.appendChild(Services.toXml(serviceTracker, document));
- return root;
+ return dataElement;
}
// TODO refactor, replace string representing namespace with namespace class
import com.google.common.base.Optional;
import com.google.common.collect.Lists;
import com.google.common.collect.Maps;
-import com.google.common.collect.Multimap;
+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.Document;
import org.w3c.dom.Element;
-import javax.management.ObjectName;
-import javax.management.openmbean.OpenType;
-import java.util.Date;
-import java.util.List;
-import java.util.Map;
-import java.util.Map.Entry;
-
public final class InstanceConfig {
private static final Logger logger = LoggerFactory.getLogger(InstanceConfig.class);
this.configRegistryClient = configRegistryClient;
}
- private Map<String, Object> getMappedConfiguration(ObjectName on, ServiceRegistryWrapper depTracker) {
+ private Map<String, Object> getMappedConfiguration(ObjectName on) {
// TODO make field, mappingStrategies can be instantiated only once
- Map<String, AttributeMappingStrategy<?, ? extends OpenType<?>>> mappingStrategies = new ObjectMapper(depTracker)
+ Map<String, AttributeMappingStrategy<?, ? extends OpenType<?>>> mappingStrategies = new ObjectMapper()
.prepareMapping(jmxToAttrConfig);
Map<String, Object> toXml = Maps.newHashMap();
return toXml;
}
- public Element toXml(ObjectName on, ServiceRegistryWrapper depTracker, String namespace, Document document, Element rootElement) {
-
- Element cfgElement = rootElement;
+ public Element toXml(ObjectName on, String namespace, Document document, Element rootElement) {
Map<String, AttributeWritingStrategy> strats = new ObjectXmlWriter().prepareWriting(yangToAttrConfig, document);
- Map<String, Object> mappedConfig = getMappedConfiguration(on, depTracker);
+ Map<String, Object> mappedConfig = getMappedConfiguration(on);
for (Entry<String, ?> mappingEntry : mappedConfig.entrySet()) {
try {
- strats.get(mappingEntry.getKey()).writeElement(cfgElement, namespace, mappingEntry.getValue());
+ strats.get(mappingEntry.getKey()).writeElement(rootElement, namespace, mappingEntry.getValue());
} catch (Exception e) {
throw new IllegalStateException("Unable to write value " + mappingEntry.getValue() + " for attribute "
+ mappingEntry.getValue(), e);
}
}
- return cfgElement;
+ return rootElement;
}
private void resolveConfiguration(InstanceConfigElementResolved mappedConfig, ServiceRegistryWrapper depTracker) {
}
public InstanceConfigElementResolved fromXml(XmlElement moduleElement, ServiceRegistryWrapper services, String moduleNamespace,
- EditStrategyType defaultStrategy, Multimap<String, String> providedServices, Map<String, Map<Date,EditConfig.IdentityMapping>> identityMap) throws NetconfDocumentedException {
+ EditStrategyType defaultStrategy,
+ Map<String, Map<Date,EditConfig.IdentityMapping>> identityMap) throws NetconfDocumentedException {
Map<String, AttributeConfigElement> retVal = Maps.newHashMap();
Map<String, AttributeReadingStrategy> strats = new ObjectXmlReader().prepareReading(yangToAttrConfig, identityMap);
List<XmlElement> recognisedChildren = Lists.newArrayList();
- XmlElement type = null;
- XmlElement name = null;
+ XmlElement type;
+ XmlElement name;
type = moduleElement.getOnlyChildElementWithSameNamespace(XmlNetconfConstants.TYPE_KEY);
name = moduleElement.getOnlyChildElementWithSameNamespace(XmlNetconfConstants.NAME_KEY);
List<XmlElement> typeAndName = Lists.newArrayList(type, name);
XmlNetconfConstants.URN_IETF_PARAMS_XML_NS_NETCONF_BASE_1_0);
InstanceConfigElementResolved instanceConfigElementResolved = perInstanceEditStrategy.equals("") ? new InstanceConfigElementResolved(
- retVal, defaultStrategy, providedServices) : new InstanceConfigElementResolved(perInstanceEditStrategy, retVal, defaultStrategy, providedServices);
+ retVal, defaultStrategy) : new InstanceConfigElementResolved(perInstanceEditStrategy, retVal, defaultStrategy);
resolveConfiguration(instanceConfigElementResolved, services);
return instanceConfigElementResolved;
package org.opendaylight.controller.netconf.confignetconfconnector.mapping.config;
-import com.google.common.collect.Multimap;
import java.util.Map;
import org.opendaylight.controller.netconf.api.NetconfDocumentedException;
import org.opendaylight.controller.netconf.confignetconfconnector.exception.OperationNotPermittedException;
private final EditStrategyType editStrategy;
private final Map<String, AttributeConfigElement> configuration;
- private final Multimap<String, String> providedServices;
- public InstanceConfigElementResolved(String currentStrategy, Map<String, AttributeConfigElement> configuration, EditStrategyType defaultStrategy, Multimap<String, String> providedServices) throws NetconfDocumentedException {
- EditStrategyType valueOf = null;
- valueOf = parseStrategy(currentStrategy, defaultStrategy);
- this.editStrategy = valueOf;
+ public InstanceConfigElementResolved(String currentStrategy, Map<String, AttributeConfigElement> configuration,
+ EditStrategyType defaultStrategy)
+ throws NetconfDocumentedException {
+ this.editStrategy = parseStrategy(currentStrategy, defaultStrategy);
this.configuration = configuration;
- this.providedServices = providedServices;
}
- public InstanceConfigElementResolved(Map<String, AttributeConfigElement> configuration, EditStrategyType defaultStrategy, Multimap<String, String> providedServices) {
+ public InstanceConfigElementResolved(Map<String, AttributeConfigElement> configuration, EditStrategyType defaultStrategy) {
editStrategy = defaultStrategy;
this.configuration = configuration;
- this.providedServices = providedServices;
}
public EditConfigStrategy getEditStrategy() {
- return editStrategy.getFittingStrategy(providedServices);
+ return editStrategy.getFittingStrategy();
}
public Map<String, AttributeConfigElement> getConfiguration() {
package org.opendaylight.controller.netconf.confignetconfconnector.mapping.config;
import com.google.common.base.Optional;
-import com.google.common.collect.HashMultimap;
-import com.google.common.collect.Multimap;
+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.confignetconfconnector.operations.editconfig.EditConfig;
import org.opendaylight.controller.netconf.util.xml.XmlElement;
import org.opendaylight.controller.netconf.util.xml.XmlNetconfConstants;
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 javax.management.ObjectName;
-import java.util.Collection;
-import java.util.Date;
-import java.util.Map;
-
public class ModuleConfig {
private final String moduleName;
private final InstanceConfig instanceConfig;
- private final Multimap<String, String> providedServices;
- public ModuleConfig(String moduleName, InstanceConfig mbeanMapping, Collection<QName> providedServices) {
+ public ModuleConfig(String moduleName, InstanceConfig mbeanMapping) {
this.moduleName = moduleName;
this.instanceConfig = mbeanMapping;
- this.providedServices = mapServices(providedServices);
- }
-
- private Multimap<String, String> mapServices(Collection<QName> providedServices) {
- Multimap<String, String> mapped = HashMultimap.create();
-
- for (QName providedService : providedServices) {
- String key = providedService.getNamespace().toString();
- mapped.put(key, providedService.getLocalName());
- }
-
- return mapped;
- }
-
- public InstanceConfig getMbeanMapping() {
- return instanceConfig;
- }
-
- public Multimap<String, String> getProvidedServices() {
- return providedServices;
}
- public Element toXml(ObjectName instanceON, ServiceRegistryWrapper depTracker, Document document, String namespace) {
+ public Element toXml(ObjectName instanceON, Document document, String namespace) {
Element root = XmlUtil.createElement(document, XmlNetconfConstants.MODULE_KEY, Optional.<String>absent());
// type belongs to config.yang namespace, but needs to be <type prefix:moduleNS>prefix:moduleName</type>
root.appendChild(nameElement);
- root = instanceConfig.toXml(instanceON, depTracker, namespace, document, root);
+ root = instanceConfig.toXml(instanceON, namespace, document, root);
return root;
}
public ModuleElementResolved fromXml(XmlElement moduleElement, ServiceRegistryWrapper depTracker, String instanceName,
String moduleNamespace, EditStrategyType defaultStrategy, Map<String, Map<Date,EditConfig.IdentityMapping>> identityMap) throws NetconfDocumentedException {
- InstanceConfigElementResolved ice = instanceConfig.fromXml(moduleElement, depTracker, moduleNamespace, defaultStrategy, providedServices, identityMap);
+ InstanceConfigElementResolved ice = instanceConfig.fromXml(moduleElement, depTracker, moduleNamespace, defaultStrategy, identityMap);
return new ModuleElementResolved(instanceName, ice);
}
return instanceName;
}
- public EditStrategyType getEditStrategyType() {
- return editStrategy;
- }
-
public EditConfigStrategy getEditStrategy() {
switch (editStrategy) {
case delete :
*/
package org.opendaylight.controller.netconf.confignetconfconnector.mapping.config;
-import com.google.common.annotations.VisibleForTesting;
import com.google.common.base.Preconditions;
import com.google.common.collect.Maps;
-import com.google.common.collect.Sets;
-import org.opendaylight.controller.config.api.ServiceReferenceReadableRegistry;
-import org.opendaylight.yangtools.yang.common.QName;
-
+import java.util.Map;
import javax.management.InstanceNotFoundException;
import javax.management.ObjectName;
-import java.util.Collection;
-import java.util.Collections;
-import java.util.Map;
-import java.util.Set;
+import org.opendaylight.controller.config.api.ServiceReferenceReadableRegistry;
+import org.opendaylight.yangtools.yang.common.QName;
public class ServiceRegistryWrapper {
private ServiceReferenceReadableRegistry configServiceRefRegistry;
- private long suffix = 1;
-
public ServiceRegistryWrapper(ServiceReferenceReadableRegistry configServiceRefRegistry) {
this.configServiceRefRegistry = configServiceRefRegistry;
}
- public boolean hasRefName(String namespace, String serviceName, ObjectName on) {
- String qname = configServiceRefRegistry.getServiceInterfaceName(namespace, serviceName);
- Map<String, ObjectName> forQName = configServiceRefRegistry.getServiceMapping().get(qname);
- if(forQName==null){
- return false;
- }
- return forQName.values().contains(on);
- }
-
public ObjectName getByServiceAndRefName(String namespace, String serviceName, String refName) {
Map<String, Map<String, String>> serviceNameToRefNameToInstance = getMappedServices().get(namespace);
- Preconditions.checkArgument(serviceNameToRefNameToInstance != null, "No serviceInstances mapped to " + namespace);
+ Preconditions.checkNotNull(serviceNameToRefNameToInstance, "No serviceInstances mapped to " + namespace);
Map<String, String> refNameToInstance = serviceNameToRefNameToInstance.get(serviceName);
- Preconditions.checkArgument(refNameToInstance != null, "No serviceInstances mapped to " + serviceName + " , "
+ Preconditions.checkNotNull(refNameToInstance, "No serviceInstances mapped to " + serviceName + " , "
+ serviceNameToRefNameToInstance.keySet());
String instanceId = refNameToInstance.get(refName);
return retVal;
}
-
- @VisibleForTesting
- public String getNewDefaultRefName(String namespace, String serviceName, String moduleName, String instanceName) {
- String refName;
- refName = "ref_" + instanceName;
-
- Map<String, Map<String, String>> serviceNameToRefNameToInstance = getMappedServices().get(namespace);
-
- Map<String, String> refNameToInstance;
- if(serviceNameToRefNameToInstance == null || !serviceNameToRefNameToInstance.containsKey(serviceName)) {
- refNameToInstance = Collections.emptyMap();
- } else {
- refNameToInstance = serviceNameToRefNameToInstance.get(serviceName);
- }
-
- final Set<String> refNamesAsSet = toSet(refNameToInstance.keySet());
- if (refNamesAsSet.contains(refName)) {
- refName = findAvailableRefName(refName, refNamesAsSet);
- }
-
- return refName;
- }
-
-
- private Set<String> toSet(Collection<String> values) {
- Set<String> refNamesAsSet = Sets.newHashSet();
-
- for (String refName : values) {
- boolean resultAdd = refNamesAsSet.add(refName);
- Preconditions.checkState(resultAdd,
- "Error occurred building services element, reference name {} was present twice", refName);
- }
-
- return refNamesAsSet;
- }
-
- private String findAvailableRefName(String refName, Set<String> refNamesAsSet) {
- String availableRefName = "";
-
- while (true) {
- availableRefName = refName + "_" + suffix++;
- if (!refNamesAsSet.contains(availableRefName)){
- return availableRefName;
- }
- }
- }
}
return rpc;
}
- public Map<String, String> getYangToJavaNames() {
- return yangToJavaNames;
- }
-
- public Map<String, Map<String, InstanceRuntimeRpc>> getRpcMapping() {
- return rpcMapping;
- }
}
if (on.getKeyPropertyList().size() != keyListSize + 1){
return false;
}
- if (!on.getKeyPropertyList().containsKey(string)){
- return false;
- }
- return true;
+ return on.getKeyPropertyList().containsKey(string);
}
}));
}
public Element toXml(ObjectName rootOn, Set<ObjectName> childRbeOns, Document document, String instanceIndex,
Element parentElement, String namespace) {
- Element xml = instanceMapping.toXml(rootOn, null, namespace, document, parentElement);
+ Element xml = instanceMapping.toXml(rootOn, namespace, document, parentElement);
if (instanceIndex != null) {
xml.setAttribute(KEY_ATTRIBUTE_KEY, instanceIndex);
package org.opendaylight.controller.netconf.confignetconfconnector.mapping.runtime;
import com.google.common.collect.Sets;
+import java.util.Collection;
+import java.util.Set;
+import javax.management.ObjectName;
import org.opendaylight.controller.netconf.confignetconfconnector.mapping.config.ModuleConfig;
-import org.opendaylight.controller.netconf.confignetconfconnector.mapping.config.ServiceRegistryWrapper;
import org.w3c.dom.Document;
import org.w3c.dom.Element;
-import javax.management.ObjectName;
-import java.util.Collection;
-import java.util.Set;
-
public class ModuleRuntime {
private final InstanceRuntime instanceRuntime;
- public ModuleRuntime(String moduleName, InstanceRuntime instanceRuntime) {
+ public ModuleRuntime(InstanceRuntime instanceRuntime) {
this.instanceRuntime = instanceRuntime;
}
- public InstanceRuntime getMbeanMapping() {
- return instanceRuntime;
- }
-
private ObjectName findRoot(Collection<ObjectName> runtimeBeanOns) {
for (ObjectName objectName : runtimeBeanOns) {
if (objectName.getKeyPropertyList().size() == 3){
}
public Element toXml(String namespace, Collection<ObjectName> runtimeBeanOns,
- Document document, ModuleConfig moduleConfig, ObjectName configBeanON, ServiceRegistryWrapper serviceTracker) {
+ Document document, ModuleConfig moduleConfig, ObjectName configBeanON) {
- Element moduleElement = moduleConfig.toXml(configBeanON, serviceTracker, document, namespace);
+ Element moduleElement = moduleConfig.toXml(configBeanON, document, namespace);
ObjectName rootName = findRoot(runtimeBeanOns);
Set<ObjectName> childrenRuntimeBeans = Sets.newHashSet(runtimeBeanOns);
childrenRuntimeBeans.remove(rootName);
+ // FIXME: why is this called and not used?
instanceRuntime.toXml(rootName, childrenRuntimeBeans, document, moduleElement, namespace);
return moduleElement;
package org.opendaylight.controller.netconf.confignetconfconnector.mapping.runtime;
+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.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.confignetconfconnector.mapping.config.Config;
import org.opendaylight.controller.netconf.confignetconfconnector.mapping.config.ModuleConfig;
-import org.opendaylight.controller.netconf.confignetconfconnector.mapping.config.ServiceRegistryWrapper;
import org.opendaylight.controller.netconf.util.xml.XmlNetconfConstants;
import org.opendaylight.controller.netconf.util.xml.XmlUtil;
import org.w3c.dom.Document;
import org.w3c.dom.Element;
-import com.google.common.base.Optional;
-import com.google.common.collect.HashMultimap;
-import com.google.common.collect.Maps;
-import com.google.common.collect.Multimap;
-
public class Runtime {
private final Map<String, Map<String, ModuleRuntime>> moduleRuntimes;
return retVal;
}
- public Element toXml(Set<ObjectName> instancesToMap, Set<ObjectName> configBeans, Document document, ServiceRegistryWrapper serviceRegistry) {
+ public Element toXml(Set<ObjectName> instancesToMap, Set<ObjectName> configBeans, Document document) {
Element root = XmlUtil.createElement(document, XmlNetconfConstants.DATA_KEY, Optional.<String>absent());
Element modulesElement = XmlUtil.createElement(document, XmlNetconfConstants.MODULES_KEY, Optional.of(XmlNetconfConstants.URN_OPENDAYLIGHT_PARAMS_XML_NS_YANG_CONTROLLER_CONFIG));
Element runtimeXml;
ModuleConfig moduleConfig = moduleConfigs.get(localNamespace).get(moduleName);
if(instanceToRbe==null || !instanceToRbe.containsKey(instanceName)) {
- runtimeXml = moduleConfig.toXml(instanceON, serviceRegistry, document, localNamespace);
+ runtimeXml = moduleConfig.toXml(instanceON, document, localNamespace);
} else {
ModuleRuntime moduleRuntime = moduleRuntimes.get(localNamespace).get(moduleName);
runtimeXml = moduleRuntime.toXml(localNamespace, instanceToRbe.get(instanceName), document,
- moduleConfig, instanceON, serviceRegistry);
+ moduleConfig, instanceON);
}
modulesElement.appendChild(runtimeXml);
}
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;
import org.opendaylight.controller.netconf.api.NetconfDocumentedException.ErrorSeverity;
import org.opendaylight.controller.netconf.api.NetconfDocumentedException.ErrorTag;
import org.opendaylight.controller.netconf.api.NetconfDocumentedException.ErrorType;
-import org.opendaylight.controller.netconf.confignetconfconnector.exception.NetconfConfigHandlingException;
import org.opendaylight.controller.netconf.confignetconfconnector.mapping.config.Config;
import org.opendaylight.controller.netconf.confignetconfconnector.mapping.config.InstanceConfig;
import org.opendaylight.controller.netconf.confignetconfconnector.mapping.config.InstanceConfigElementResolved;
import org.w3c.dom.Document;
import org.w3c.dom.Element;
-import javax.management.InstanceNotFoundException;
-import javax.management.ObjectName;
-import java.util.Date;
-import java.util.HashMap;
-import java.util.Map;
-import java.util.Set;
-
public class EditConfig extends AbstractConfigNetconfOperation {
private static final Logger logger = LoggerFactory.getLogger(EditConfig.class);
@VisibleForTesting
Element getResponseInternal(final Document document,
- final EditConfigXmlParser.EditConfigExecution editConfigExecution) throws NetconfDocumentedException, NetconfConfigHandlingException {
+ final EditConfigXmlParser.EditConfigExecution editConfigExecution) throws NetconfDocumentedException {
if (editConfigExecution.shouldTest()) {
executeTests(getConfigRegistryClient(), editConfigExecution);
return identityNameToSchemaNode.containsKey(idName);
}
- // FIXME method never used
- public IdentitySchemaNode getIdentitySchemaNode(String idName) {
- Preconditions.checkState(identityNameToSchemaNode.containsKey(idName), "No identity under name %s", idName);
- return identityNameToSchemaNode.get(idName);
- }
}
private static Map<String, Map<Date, IdentityMapping>> transformIdentities(Set<Module> modules) {
ModuleMXBeanEntry moduleMXBeanEntry = moduleNameToMbe.getValue();
ModuleConfig moduleConfig = new ModuleConfig(moduleName, new InstanceConfig(configRegistryClient,
- moduleMXBeanEntry.getAttributes()), moduleMXBeanEntry
- .getProvidedServices().values());
+ moduleMXBeanEntry.getAttributes()));
Map<String, ModuleConfig> moduleNameToModuleConfig = namespaceToModuleNameToModuleConfig.get(namespace);
if(moduleNameToModuleConfig == null) {
EditConfigXmlParser.EditConfigExecution editConfigExecution;
Config cfg = getConfigMapping(getConfigRegistryClient(), yangStoreSnapshot);
- editConfigExecution = editConfigXmlParser.fromXml(xml, cfg, transactionProvider, getConfigRegistryClient());
+ editConfigExecution = editConfigXmlParser.fromXml(xml, cfg);
Element responseInternal;
responseInternal = getResponseInternal(document, editConfigExecution);
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.config.util.ConfigRegistryClient;
import org.opendaylight.controller.netconf.api.NetconfDocumentedException;
import org.opendaylight.controller.netconf.confignetconfconnector.mapping.config.Config;
import org.opendaylight.controller.netconf.confignetconfconnector.mapping.config.ModuleElementDefinition;
import org.opendaylight.controller.netconf.confignetconfconnector.mapping.config.ServiceRegistryWrapper;
import org.opendaylight.controller.netconf.confignetconfconnector.mapping.config.Services;
import org.opendaylight.controller.netconf.confignetconfconnector.operations.Datastore;
-import org.opendaylight.controller.netconf.confignetconfconnector.transactions.TransactionProvider;
import org.opendaylight.controller.netconf.util.exception.MissingNameSpaceException;
import org.opendaylight.controller.netconf.util.exception.UnexpectedNamespaceException;
import org.opendaylight.controller.netconf.util.xml.XmlElement;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
-import java.util.Arrays;
-import java.util.Map;
-
public class EditConfigXmlParser {
private static final Logger logger = LoggerFactory.getLogger(EditConfigXmlParser.class);
public EditConfigXmlParser() {
}
- EditConfigXmlParser.EditConfigExecution fromXml(final XmlElement xml, final Config cfgMapping,
- TransactionProvider transactionProvider, ConfigRegistryClient configRegistryClient)
+ EditConfigXmlParser.EditConfigExecution fromXml(final XmlElement xml, final Config cfgMapping)
throws NetconfDocumentedException {
//TODO remove transactionProvider and CfgRegistry from parameters, accept only service ref store
package org.opendaylight.controller.netconf.confignetconfconnector.operations.editconfig;
-import com.google.common.collect.Multimap;
-import org.opendaylight.controller.netconf.api.NetconfDocumentedException;
-import org.opendaylight.controller.netconf.confignetconfconnector.exception.OperationNotPermittedException;
-
import java.util.EnumSet;
import java.util.Set;
+import org.opendaylight.controller.netconf.api.NetconfDocumentedException;
+import org.opendaylight.controller.netconf.confignetconfconnector.exception.OperationNotPermittedException;
public enum EditStrategyType {
// can be default
}
}
- public EditConfigStrategy getFittingStrategy(Multimap<String, String> providedServices) {
+ public EditConfigStrategy getFittingStrategy() {
switch (this) {
case merge:
- return new MergeEditConfigStrategy(providedServices);
+ return new MergeEditConfigStrategy();
case replace:
- return new ReplaceEditConfigStrategy(providedServices);
+ return new ReplaceEditConfigStrategy();
case delete:
return new DeleteEditConfigStrategy();
case remove:
package org.opendaylight.controller.netconf.confignetconfconnector.operations.editconfig;
-import com.google.common.collect.HashMultimap;
-import com.google.common.collect.Multimap;
-import org.opendaylight.controller.config.api.jmx.ObjectNameUtil;
+import java.util.Map;
+import java.util.Map.Entry;
+import javax.management.Attribute;
+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.Attribute;
-import javax.management.InstanceNotFoundException;
-import javax.management.ObjectName;
-import java.util.Map;
-import java.util.Map.Entry;
-
public class MergeEditConfigStrategy extends AbstractEditConfigStrategy {
private static final Logger logger = LoggerFactory.getLogger(MergeEditConfigStrategy.class);
- private final Multimap<String, String> providedServices;
public MergeEditConfigStrategy() {
- this.providedServices = HashMultimap.create();
- }
- public MergeEditConfigStrategy(Multimap<String, String> providedServices) {
- this.providedServices = providedServices;
}
@Override
NetconfDocumentedException.ErrorTag.operation_failed,
NetconfDocumentedException.ErrorSeverity.error);
}
-
- private void addRefNames(ServiceRegistryWrapper services, Multimap<String, String> providedServices, ConfigTransactionClient ta, ObjectName on) throws InstanceNotFoundException {
- for (Entry<String, String> namespaceToService : providedServices.entries()) {
-
- if(services.hasRefName(namespaceToService.getKey(),
- namespaceToService.getValue(), on)){
- continue;
- }
-
- String refName = services.getNewDefaultRefName(namespaceToService.getKey(), namespaceToService.getValue(),
- ObjectNameUtil.getFactoryName(on), ObjectNameUtil.getInstanceName(on));
- ta.saveServiceReference(
- ta.getServiceInterfaceName(namespaceToService.getKey(), namespaceToService.getValue()), refName, on);
- }
- }
-
@Override
void executeStrategy(Map<String, AttributeConfigElement> configuration, ConfigTransactionClient ta, ObjectName on, ServiceRegistryWrapper services) throws NetconfConfigHandlingException {
- try {
- addRefNames(services, providedServices, ta, on);
- } catch (InstanceNotFoundException e) {
- throw new NetconfConfigHandlingException(String.format("Unable to save default ref name for instance %s. Instance was not found.",e),
- NetconfDocumentedException.ErrorType.application,
- NetconfDocumentedException.ErrorTag.operation_failed,
- NetconfDocumentedException.ErrorSeverity.error);
- }
for (Entry<String, AttributeConfigElement> configAttributeEntry : configuration.entrySet()) {
try {
@Override
void handleMissingInstance(Map<String, AttributeConfigElement> configuration, ConfigTransactionClient ta,
String module, String instance, ServiceRegistryWrapper services) throws NetconfConfigHandlingException {
- ObjectName on = null;
try {
- on = ta.createModule(module, instance);
+ ObjectName on = ta.createModule(module, instance);
logger.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),
@Override
void executeStrategy(Map<String, AttributeConfigElement> configuration, ConfigTransactionClient ta,
ObjectName objectName, ServiceRegistryWrapper services) {
- return;
}
}
package org.opendaylight.controller.netconf.confignetconfconnector.operations.editconfig;
-import com.google.common.collect.HashMultimap;
-import com.google.common.collect.Multimap;
-import org.opendaylight.controller.config.api.jmx.ObjectNameUtil;
+import java.util.Map;
+import java.util.Map.Entry;
+import javax.management.Attribute;
+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.Attribute;
-import javax.management.InstanceNotFoundException;
-import javax.management.ObjectName;
-import java.util.Map;
-import java.util.Map.Entry;
-
public class ReplaceEditConfigStrategy extends AbstractEditConfigStrategy {
private static final Logger logger = LoggerFactory.getLogger(ReplaceEditConfigStrategy.class);
- private final Multimap<String, String> providedServices;
-
- public ReplaceEditConfigStrategy() {
- this.providedServices = HashMultimap.create();
- }
-
- public ReplaceEditConfigStrategy(Multimap<String, String> providedServices) {
- this.providedServices = providedServices;
- }
-
@Override
void handleMissingInstance(Map<String, AttributeConfigElement> configuration, ConfigTransactionClient ta,
String module, String instance, ServiceRegistryWrapper services) throws NetconfConfigHandlingException {
NetconfDocumentedException.ErrorSeverity.error);
}
- private void addRefNames(ServiceRegistryWrapper services, Multimap<String, String> providedServices, ConfigTransactionClient ta, ObjectName on) throws InstanceNotFoundException {
- for (Entry<String, String> namespaceToService : providedServices.entries()) {
-
- if(services.hasRefName(namespaceToService.getKey(),
- namespaceToService.getValue(), on)){
- continue;
- }
-
- String refName = services.getNewDefaultRefName(namespaceToService.getKey(), namespaceToService.getValue(),
- ObjectNameUtil.getFactoryName(on), ObjectNameUtil.getInstanceName(on));
- ta.saveServiceReference(
- ta.getServiceInterfaceName(namespaceToService.getKey(), namespaceToService.getValue()), refName, on);
- }
- }
-
@Override
void executeStrategy(Map<String, AttributeConfigElement> configuration, ConfigTransactionClient ta, ObjectName on, ServiceRegistryWrapper services) throws NetconfConfigHandlingException {
- try {
- addRefNames(services, providedServices, ta, on);
- } catch (InstanceNotFoundException e) {
- throw new NetconfConfigHandlingException(String.format("Unable to save default ref name for instance %s. Instance not found. ",on),
- NetconfDocumentedException.ErrorType.application,
- NetconfDocumentedException.ErrorTag.operation_failed,
- NetconfDocumentedException.ErrorSeverity.error);
- }
-
for (Entry<String, AttributeConfigElement> configAttributeEntry : configuration.entrySet()) {
try {
AttributeConfigElement ace = configAttributeEntry.getValue();
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.util.ConfigTransactionClient;
import org.opendaylight.controller.config.yangjmxgenerator.ModuleMXBeanEntry;
import org.opendaylight.controller.config.yangjmxgenerator.RuntimeBeanEntry;
import org.opendaylight.controller.netconf.api.NetconfDocumentedException;
import org.opendaylight.controller.netconf.confignetconfconnector.mapping.config.InstanceConfig;
import org.opendaylight.controller.netconf.confignetconfconnector.mapping.config.ModuleConfig;
-import org.opendaylight.controller.netconf.confignetconfconnector.mapping.config.ServiceRegistryWrapper;
import org.opendaylight.controller.netconf.confignetconfconnector.mapping.runtime.InstanceRuntime;
import org.opendaylight.controller.netconf.confignetconfconnector.mapping.runtime.ModuleRuntime;
import org.opendaylight.controller.netconf.confignetconfconnector.mapping.runtime.Runtime;
import org.opendaylight.controller.netconf.confignetconfconnector.operations.Datastore;
import org.opendaylight.controller.netconf.confignetconfconnector.operations.editconfig.EditConfig;
import org.opendaylight.controller.netconf.confignetconfconnector.osgi.YangStoreSnapshot;
-import org.opendaylight.controller.netconf.confignetconfconnector.transactions.TransactionProvider;
import org.opendaylight.controller.netconf.util.exception.MissingNameSpaceException;
import org.opendaylight.controller.netconf.util.exception.UnexpectedElementException;
import org.opendaylight.controller.netconf.util.exception.UnexpectedNamespaceException;
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.Set;
-
public class Get extends AbstractConfigNetconfOperation {
private final YangStoreSnapshot yangStoreSnapshot;
private static final Logger logger = LoggerFactory.getLogger(Get.class);
- private final TransactionProvider transactionProvider;
public Get(YangStoreSnapshot yangStoreSnapshot, ConfigRegistryClient configRegistryClient,
- String netconfSessionIdForReporting, TransactionProvider transactionProvider) {
+ String netconfSessionIdForReporting) {
super(configRegistryClient, netconfSessionIdForReporting);
this.yangStoreSnapshot = yangStoreSnapshot;
- this.transactionProvider = transactionProvider;
}
private Map<String, Map<String, ModuleRuntime>> createModuleRuntimes(ConfigRegistryClient configRegistryClient,
}
InstanceRuntime rootInstanceRuntime = createInstanceRuntime(root, cache);
- ModuleRuntime moduleRuntime = new ModuleRuntime(module, rootInstanceRuntime);
+ ModuleRuntime moduleRuntime = new ModuleRuntime(rootInstanceRuntime);
innerMap.put(module, moduleRuntime);
}
final Runtime runtime = new Runtime(moduleRuntimes, moduleConfigs);
- ObjectName txOn = transactionProvider.getOrCreateTransaction();
- ConfigTransactionClient ta = getConfigRegistryClient().getConfigTransactionClient(txOn);
- final Element element = runtime.toXml(runtimeBeans, configBeans, document, new ServiceRegistryWrapper(ta));
+ final Element element = runtime.toXml(runtimeBeans, configBeans, document);
logger.trace("{} operation successful", XmlNetconfConstants.GET);
}
private Element getResponseInternal(final Document document, final ConfigRegistryClient configRegistryClient,
- final Datastore source) throws NetconfDocumentedException {
+ final Datastore source) {
Element dataElement = XmlUtil.createElement(document, XmlNetconfConstants.DATA_KEY, Optional.<String>absent());
final Set<ObjectName> instances = Datastore.getInstanceQueryStrategy(source, this.transactionProvider)
.queryInstances(configRegistryClient);
}
private Element toXml(Document doc, Object result, AttributeIfc returnType, String namespace, String elementName) throws NetconfDocumentedException {
- AttributeMappingStrategy<?, ? extends OpenType<?>> mappingStrategy = new ObjectMapper(null).prepareStrategy(returnType);
+ AttributeMappingStrategy<?, ? extends OpenType<?>> mappingStrategy = new ObjectMapper().prepareStrategy(returnType);
Optional<?> mappedAttributeOpt = mappingStrategy.mapAttribute(result);
Preconditions.checkState(mappedAttributeOpt.isPresent(), "Unable to map return value %s as %s", result, returnType.getOpenType());
ops.add(new EditConfig(yangStoreSnapshot, transactionProvider, configRegistryClient,
netconfSessionIdForReporting));
ops.add(new Commit(transactionProvider, configRegistryClient, netconfSessionIdForReporting));
- ops.add(new Get(yangStoreSnapshot, configRegistryClient, netconfSessionIdForReporting, transactionProvider));
+ ops.add(new Get(yangStoreSnapshot, configRegistryClient, netconfSessionIdForReporting));
ops.add(new DiscardChanges(transactionProvider, configRegistryClient, netconfSessionIdForReporting));
ops.add(new Validate(transactionProvider, configRegistryClient, netconfSessionIdForReporting));
ops.add(new RuntimeRpc(yangStoreSnapshot, configRegistryClient, netconfSessionIdForReporting));
}
public void wipeTestTransaction(ObjectName taON) {
- wipeInternal(taON, true, null);
+ wipeInternal(taON, true);
}
/**
* Wiping means removing all module instances keeping the transaction open + service references.
*/
- synchronized void wipeInternal(ObjectName taON, boolean isTest, String moduleName) {
+ synchronized void wipeInternal(ObjectName taON, boolean isTest) {
ConfigTransactionClient transactionClient = configRegistryClient.getConfigTransactionClient(taON);
- Set<ObjectName> lookupConfigBeans = moduleName == null ? transactionClient.lookupConfigBeans()
- : transactionClient.lookupConfigBeans(moduleName);
+ Set<ObjectName> lookupConfigBeans = transactionClient.lookupConfigBeans();
int i = lookupConfigBeans.size();
for (ObjectName instance : lookupConfigBeans) {
try {
public void wipeTransaction() {
Optional<ObjectName> taON = getTransaction();
Preconditions.checkState(taON.isPresent(), NO_TRANSACTION_FOUND_FOR_SESSION + netconfSessionIdForReporting);
- wipeInternal(taON.get(), false, null);
+ wipeInternal(taON.get(), false);
}
}
edit("netconfMessages/editConfig.xml");
Document config = getConfigCandidate();
- assertCorrectServiceNames(config, Sets.newHashSet("ref_test2", "user_to_instance_from_code", "ref_dep_user",
+ assertCorrectServiceNames(config, Sets.newHashSet("user_to_instance_from_code", "ref_dep_user",
"ref_dep_user_two", "ref_from_code_to_instance-from-code_dep_1",
"ref_from_code_to_instance-from-code_1"));
edit("netconfMessages/editConfig_addServiceName.xml");
config = getConfigCandidate();
- assertCorrectServiceNames(config, Sets.newHashSet("ref_test2", "user_to_instance_from_code", "ref_dep_user",
+ assertCorrectServiceNames(config, Sets.newHashSet("user_to_instance_from_code", "ref_dep_user",
"ref_dep_user_two", "ref_from_code_to_instance-from-code_dep_1",
"ref_from_code_to_instance-from-code_1", "ref_dep_user_another"));
edit("netconfMessages/editConfig_addServiceNameOnTest.xml");
config = getConfigCandidate();
- assertCorrectServiceNames(config, Sets.newHashSet("ref_test2", "user_to_instance_from_code", "ref_dep_user",
+ assertCorrectServiceNames(config, Sets.newHashSet("user_to_instance_from_code", "ref_dep_user",
"ref_dep_user_two", "ref_from_code_to_instance-from-code_dep_1",
"ref_from_code_to_instance-from-code_1", "ref_dep_user_another"));
commit();
config = getConfigRunning();
assertCorrectRefNamesForDependencies(config);
- assertCorrectServiceNames(config, Sets.newHashSet("ref_test2", "user_to_instance_from_code", "ref_dep_user",
+ assertCorrectServiceNames(config, Sets.newHashSet("user_to_instance_from_code", "ref_dep_user",
"ref_dep_user_two", "ref_from_code_to_instance-from-code_dep_1",
"ref_from_code_to_instance-from-code_1", "ref_dep_user_another"));
edit("netconfMessages/editConfig_replace_default.xml");
config = getConfigCandidate();
- assertCorrectServiceNames(config, Sets.newHashSet("ref_dep", "ref_dep2"));
+ assertCorrectServiceNames(config, Collections.<String>emptySet());
edit("netconfMessages/editConfig_remove.xml");
config = getConfigCandidate();
nt.performTest(tester, Node.TEXT_NODE);
}
- private void assertCorrectServiceNames(Document configCandidate, final Set<String> refNames) throws NodeTestException {
-
+ private void assertCorrectServiceNames(Document configCandidate, Set<String> refNames) throws NodeTestException {
+ final Set<String> refNames2 = new HashSet<>(refNames);
NodeList servicesNodes = configCandidate.getElementsByTagName("services");
assertEquals(1, servicesNodes.getLength());
if(element.getNodeName() != null) {
if(element.getNodeName().equals("name")) {
String elmText = element.getTextContent();
- if(refNames.contains(elmText)) {
- refNames.remove(elmText);
- return;
+ if(refNames2.contains(elmText)) {
+ refNames2.remove(elmText);
} else {
throw new NodeTestException("Unexpected services defined: " + elmText);
}
@Override
public void noMoreNodes(NodeTest forTest) throws NodeTestException {
- assertTrue(refNames.isEmpty());
+ assertEquals(Collections.<String>emptySet(), refNames2);
+ assertTrue(refNames2.toString(), refNames2.isEmpty());
}
};
nt.performTest(tester, Node.ELEMENT_NODE);
}
private Document get() throws NetconfDocumentedException, ParserConfigurationException, SAXException, IOException {
- Get getOp = new Get(yangStoreSnapshot, configRegistryClient, NETCONF_SESSION_ID, transactionProvider);
+ Get getOp = new Get(yangStoreSnapshot, configRegistryClient, NETCONF_SESSION_ID);
return executeOp(getOp, "netconfMessages/get.xml");
}
notificationVerifier.assertNotificationCount(2);
notificationVerifier.assertNotificationContent(0, 0, 0, 9);
- notificationVerifier.assertNotificationContent(1, 4, 4, 9);
+ notificationVerifier.assertNotificationContent(1, 4, 3, 9);
mockedAggregator.assertSnapshotCount(2);
// Capabilities are stripped for persister
mockedAggregator.assertSnapshotContent(0, 0, 0, 1);
- mockedAggregator.assertSnapshotContent(1, 4, 4, 3);
+ mockedAggregator.assertSnapshotContent(1, 4, 3, 3);
}
private VerifyingPersister mockAggregator() throws IOException {
Code Review / controller.git / commitdiff