<plugin>
<groupId>org.apache.felix</groupId>
<artifactId>maven-bundle-plugin</artifactId>
- <version>${bundle.plugin.version}</version>
<extensions>true</extensions>
<configuration>
<instructions>
org.apache.felix.dm,</Import-Package>
<Export-Package>org.opendaylight.controller.appauth,
org.opendaylight.controller.appauth.authorization</Export-Package>
- <Bundle-Activator></Bundle-Activator>
</instructions>
</configuration>
</plugin>
<plugin>
<groupId>org.apache.felix</groupId>
<artifactId>maven-bundle-plugin</artifactId>
- <version>${bundle.plugin.version}</version>
<extensions>true</extensions>
<configuration>
<instructions>
<plugin>
<groupId>org.apache.felix</groupId>
<artifactId>maven-bundle-plugin</artifactId>
- <version>${bundle.plugin.version}</version>
<extensions>true</extensions>
<configuration>
<instructions>
* passed and so on.
*/
public class CacheConfigException extends Exception {
+ private static final long serialVersionUID = 1L;
/**
* Instantiates a new cache config exception.
* allocated already exists
*/
public class CacheExistException extends Exception {
+ private static final long serialVersionUID = 1L;
/**
* Instantiates a new cache exist exception.
* Listener being added fails for any reason
*/
public class CacheListenerAddException extends Exception {
+ private static final long serialVersionUID = 1L;
/**
* Instantiates a new cache listener add exception.
* @deprecated for internal use
* The Class ListenRoleChangeAddException.
*/
+@Deprecated
public class ListenRoleChangeAddException extends Exception {
+ private static final long serialVersionUID = 1L;
/**
* Instantiates a new listen role change add exception.
<plugin>
<groupId>org.apache.felix</groupId>
<artifactId>maven-bundle-plugin</artifactId>
- <version>${bundle.plugin.version}</version>
<extensions>true</extensions>
<configuration>
<instructions>
!org.hornetq.*,
!org.jboss.*,
javax.transaction,
- *,
org.opendaylight.controller.clustering.services,
- org.opendaylight.controller.sal.core</Import-Package>
+ org.opendaylight.controller.sal.core,*</Import-Package>
<Bundle-Activator>org.opendaylight.controller.clustering.services_implementation.internal.Activator</Bundle-Activator>
<!-- Add in the DynamicImport-Package ONLY the packages that -->
<!-- contains types that MUST be unmarshalled by the -->
<plugin>
<groupId>org.apache.felix</groupId>
<artifactId>maven-bundle-plugin</artifactId>
- <version>${bundle.plugin.version}</version>
<extensions>true</extensions>
<configuration>
<instructions>
<plugin>
<groupId>org.apache.felix</groupId>
<artifactId>maven-bundle-plugin</artifactId>
- <version>${bundle.plugin.version}</version>
<extensions>true</extensions>
<configuration>
<instructions>
import java.io.Serializable;
public class ComplexClass implements IComplex, Serializable {
+ private static final long serialVersionUID = 1L;
private String identity;
public ComplexClass(String i) {
import java.io.Serializable;
public class ComplexClass1 implements IComplex, Serializable {
+ private static final long serialVersionUID = 1L;
private String identity;
public ComplexClass1(String i) {
import java.io.Serializable;
public class ComplexContainer implements Serializable {
- private IComplex f;
- private IComplex f1;
- private Integer state;
+ private static final long serialVersionUID = 1L;
+ private final IComplex f;
+ private final IComplex f1;
+ private final Integer state;
public ComplexContainer(String i, Integer s) {
this.state = s;
import java.io.Serializable;
public class StringContainer implements Serializable {
+ private static final long serialVersionUID = 1L;
private String mystring;
public StringContainer() {
<plugin>
<groupId>org.apache.felix</groupId>
<artifactId>maven-bundle-plugin</artifactId>
- <version>${bundle.plugin.version}</version>
<extensions>true</extensions>
<configuration>
<instructions>
<plugin>
<groupId>org.apache.felix</groupId>
<artifactId>maven-bundle-plugin</artifactId>
- <version>${bundle.plugin.version}</version>
<extensions>true</extensions>
<configuration>
<instructions>
<asm.version>4.1</asm.version>
<!-- Plugin Versions -->
<bouncycastle.version>1.50</bouncycastle.version>
- <bundle.plugin.version>2.3.7</bundle.plugin.version>
+ <bundle.plugin.version>2.4.0</bundle.plugin.version>
<bundlescanner.version>0.4.2-SNAPSHOT</bundlescanner.version>
<checkstyle.version>2.10</checkstyle.version>
<clustering.services.version>0.5.1-SNAPSHOT</clustering.services.version>
<configFile>enunciate.xml</configFile>
</configuration>
<dependencies>
- <dependency>
- <groupId>org.opendaylight.controller</groupId>
- <artifactId>commons.logback_settings</artifactId>
- <version>0.0.2-SNAPSHOT</version>
- </dependency>
<dependency>
<groupId>org.codehaus.enunciate</groupId>
<artifactId>enunciate-swagger</artifactId>
<version>${enunciate.version}</version>
</dependency>
+ <dependency>
+ <groupId>org.opendaylight.controller</groupId>
+ <artifactId>commons.logback_settings</artifactId>
+ <version>0.0.2-SNAPSHOT</version>
+ </dependency>
</dependencies>
<executions>
<execution>
<plugin>
<groupId>org.jacoco</groupId>
<artifactId>jacoco-maven-plugin</artifactId>
- <version>${jacoco.version}</version>
<executions>
<execution>
<goals>
package org.opendaylight.controller.config.yangjmxgenerator.plugin.gofactory;
-import com.google.common.base.Joiner;
-import com.google.common.base.Optional;
+import java.util.LinkedHashMap;
+
import org.opendaylight.controller.config.api.DependencyResolver;
import org.opendaylight.controller.config.api.ModuleIdentifier;
import org.opendaylight.controller.config.yangjmxgenerator.ModuleMXBeanEntry;
import org.opendaylight.controller.config.yangjmxgenerator.plugin.java.JavaFileInputBuilder;
import org.opendaylight.controller.config.yangjmxgenerator.plugin.java.TypeName;
-import java.util.LinkedHashMap;
+import com.google.common.base.Joiner;
+import com.google.common.base.Optional;
public class ConcreteModuleGeneratedObjectFactory {
}
private static String getNewCtor(FullyQualifiedName fqn) {
- LinkedHashMap<String, String> parameters = new LinkedHashMap<String, String>(){
- {
- put(ModuleIdentifier.class.getCanonicalName(), "identifier");
- put(DependencyResolver.class.getCanonicalName(), "dependencyResolver");
- }
- };
+ LinkedHashMap<String, String> parameters = new LinkedHashMap<>();
+ parameters.put(ModuleIdentifier.class.getCanonicalName(), "identifier");
+ parameters.put(DependencyResolver.class.getCanonicalName(), "dependencyResolver");
+
StringBuilder stringBuilder = getCtor(fqn, parameters);
return stringBuilder.toString();
}
}
private static String getCopyCtor(final FullyQualifiedName fqn) {
- LinkedHashMap<String, String> parameters = new LinkedHashMap<String, String>(){
- {
- put(ModuleIdentifier.class.getCanonicalName(), "identifier");
- put(DependencyResolver.class.getCanonicalName(), "dependencyResolver");
- put(fqn.toString(), "oldModule");
- put(AutoCloseable.class.getCanonicalName(), "oldInstance");
- }
- };
+ LinkedHashMap<String, String> parameters = new LinkedHashMap<>();
+ parameters.put(ModuleIdentifier.class.getCanonicalName(), "identifier");
+ parameters.put(DependencyResolver.class.getCanonicalName(), "dependencyResolver");
+ parameters.put(fqn.toString(), "oldModule");
+ parameters.put(AutoCloseable.class.getCanonicalName(), "oldInstance");
StringBuilder stringBuilder = getCtor(fqn, parameters);
return stringBuilder.toString();
}
<plugin>
<groupId>org.apache.felix</groupId>
<artifactId>maven-bundle-plugin</artifactId>
- <version>${bundle.plugin.version}</version>
<extensions>true</extensions>
<configuration>
<instructions>
<plugin>
<groupId>org.apache.felix</groupId>
<artifactId>maven-bundle-plugin</artifactId>
- <version>${bundle.plugin.version}</version>
<extensions>true</extensions>
<configuration>
<instructions>
<plugin>
<groupId>org.apache.felix</groupId>
<artifactId>maven-bundle-plugin</artifactId>
- <version>${bundle.plugin.version}</version>
<extensions>true</extensions>
<configuration>
<instructions>
<plugin>
<groupId>org.apache.felix</groupId>
<artifactId>maven-bundle-plugin</artifactId>
- <version>${bundle.plugin.version}</version>
<extensions>true</extensions>
<configuration>
<instructions>
<plugin>
<groupId>org.apache.felix</groupId>
<artifactId>maven-bundle-plugin</artifactId>
- <version>${bundle.plugin.version}</version>
<extensions>true</extensions>
<configuration>
<instructions>
<plugin>
<groupId>org.apache.felix</groupId>
<artifactId>maven-bundle-plugin</artifactId>
- <version>${bundle.plugin.version}</version>
<extensions>true</extensions>
<configuration>
<instructions>
<plugin>
<groupId>org.apache.felix</groupId>
<artifactId>maven-bundle-plugin</artifactId>
- <version>${bundle.plugin.version}</version>
<extensions>true</extensions>
<configuration>
<instructions>
<dependency>
<groupId>org.opendaylight.yangtools</groupId>
<artifactId>binding-generator-impl</artifactId>
- <version>${yangtools.version}</version>
</dependency>
<dependency>
<groupId>org.opendaylight.yangtools</groupId>
<artifactId>binding-generator-spi</artifactId>
- <version>${yangtools.version}</version>
</dependency>
<dependency>
<groupId>org.opendaylight.yangtools</groupId>
<artifactId>binding-generator-util</artifactId>
- <version>${yangtools.version}</version>
</dependency>
<dependency>
<groupId>org.opendaylight.yangtools</groupId>
<dependency>
<groupId>org.opendaylight.yangtools</groupId>
<artifactId>binding-type-provider</artifactId>
- <version>${yangtools.version}</version>
</dependency>
<dependency>
<groupId>org.opendaylight.yangtools</groupId>
<dependency>
<groupId>org.opendaylight.yangtools</groupId>
<artifactId>yang-parser-api</artifactId>
- <version>${yangtools.version}</version>
</dependency>
<dependency>
<groupId>org.opendaylight.yangtools</groupId>
<artifactId>yang-parser-impl</artifactId>
- <version>${yangtools.version}</version>
</dependency>
<!-- yang model dependencies -->
<dependency>
<plugin>
<groupId>org.apache.felix</groupId>
<artifactId>maven-bundle-plugin</artifactId>
- <version>${bundle.plugin.version}</version>
<extensions>true</extensions>
<configuration>
<instructions>
<instructions>
<Import-Package>*</Import-Package>
<Export-Package>org.eclipse.osgi.framework.console</Export-Package>
- <Bundle-Activator></Bundle-Activator>
</instructions>
</configuration>
</plugin>
<plugin>
<groupId>org.apache.felix</groupId>
<artifactId>maven-bundle-plugin</artifactId>
- <version>${bundle.plugin.version}</version>
<extensions>true</extensions>
<configuration>
<instructions>
<plugin>
<groupId>org.apache.felix</groupId>
<artifactId>maven-bundle-plugin</artifactId>
- <version>${bundle.plugin.version}</version>
<extensions>true</extensions>
<configuration>
<instructions>
<plugin>
<groupId>org.apache.felix</groupId>
<artifactId>maven-bundle-plugin</artifactId>
- <version>${bundle.plugin.version}</version>
<extensions>true</extensions>
<configuration>
<instructions>
<plugin>
<groupId>org.apache.felix</groupId>
<artifactId>maven-bundle-plugin</artifactId>
- <version>${bundle.plugin.version}</version>
<extensions>true</extensions>
<configuration>
<instructions>
<plugin>
<groupId>org.apache.felix</groupId>
<artifactId>maven-bundle-plugin</artifactId>
- <version>${bundle.plugin.version}</version>
<extensions>true</extensions>
<configuration>
<instructions>
<plugin>
<groupId>org.apache.felix</groupId>
<artifactId>maven-bundle-plugin</artifactId>
- <version>${bundle.plugin.version}</version>
<extensions>true</extensions>
<configuration>
<instructions>
<plugin>
<groupId>org.apache.felix</groupId>
<artifactId>maven-bundle-plugin</artifactId>
- <version>${bundle.plugin.version}</version>
<extensions>true</extensions>
<configuration>
<instructions>
<plugin>
<groupId>org.apache.felix</groupId>
<artifactId>maven-bundle-plugin</artifactId>
- <version>${bundle.plugin.version}</version>
<extensions>true</extensions>
<configuration>
<instructions>
/**
* Copyright (c) 2014 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.sal.compatibility;
-import com.google.common.base.Objects;
-import com.google.common.base.Preconditions;
-import org.eclipse.xtext.xbase.lib.Exceptions;
+import java.util.Date;
+import java.util.HashSet;
+import java.util.List;
+
import org.opendaylight.controller.sal.common.util.Arguments;
import org.opendaylight.controller.sal.core.AdvertisedBandwidth;
import org.opendaylight.controller.sal.core.Bandwidth;
import org.opendaylight.yangtools.yang.binding.InstanceIdentifier.IdentifiableItem;
import org.opendaylight.yangtools.yang.binding.InstanceIdentifier.PathArgument;
-import java.util.Date;
-import java.util.HashSet;
-import java.util.List;
+import com.google.common.base.Objects;
+import com.google.common.base.Preconditions;
-@SuppressWarnings("all")
-public class NodeMapping {
+public final class NodeMapping {
public final static String MD_SAL_TYPE = "MD_SAL";
-
+
private final static Class<Node> NODE_CLASS = Node.class;
-
+
private final static Class<NodeConnector> NODECONNECTOR_CLASS = NodeConnector.class;
-
+
private NodeMapping() {
throw new UnsupportedOperationException("Utility class. Instantiation is not allowed.");
}
-
+
public static org.opendaylight.controller.sal.core.Node toADNode(final InstanceIdentifier<? extends Object> node) throws ConstructionException {
NodeId nodeId = NodeMapping.toNodeId(node);
return NodeMapping.toADNode(nodeId);
}
-
- public static org.opendaylight.controller.sal.core.Node toADNode(final NodeId id) {
- try {
+
+ public static org.opendaylight.controller.sal.core.Node toADNode(final NodeId id) throws ConstructionException {
String aDNodeId = NodeMapping.toADNodeId(id);
return new org.opendaylight.controller.sal.core.Node(NodeMapping.MD_SAL_TYPE, aDNodeId);
- } catch (Throwable e) {
- throw Exceptions.sneakyThrow(e);
- }
}
-
+
public static NodeId toNodeId(final InstanceIdentifier<? extends Object> node) {
Preconditions.<InstanceIdentifier<? extends Object>>checkNotNull(node);
List<PathArgument> path = node.getPath();
Preconditions.checkArgument(size >= 2);
final PathArgument arg = path.get(1);
final IdentifiableItem item = Arguments.<IdentifiableItem>checkInstanceOf(arg, IdentifiableItem.class);
- Identifier key = item.getKey();
+ Identifier<?> key = item.getKey();
final NodeKey nodeKey = Arguments.<NodeKey>checkInstanceOf(key, NodeKey.class);
return nodeKey.getId();
}
-
+
public static String toADNodeId(final NodeId nodeId) {
Preconditions.<NodeId>checkNotNull(nodeId);
return nodeId.getValue();
}
-
+
public static org.opendaylight.controller.sal.core.NodeConnector toADNodeConnector(final NodeConnectorRef source) throws ConstructionException {
Preconditions.<NodeConnectorRef>checkNotNull(source);
final InstanceIdentifier<?> path = Preconditions.<InstanceIdentifier<? extends Object>>checkNotNull(source.getValue());
final NodeConnectorKey connectorKey = Arguments.<NodeConnectorKey>checkInstanceOf(item.getKey(), NodeConnectorKey.class);
return NodeMapping.toADNodeConnector(connectorKey.getId(), NodeMapping.toNodeId(path));
}
-
- public static org.opendaylight.controller.sal.core.NodeConnector toADNodeConnector(final NodeConnectorId ncid, final NodeId nid) {
- try {
- String nodeConnectorType = NodeMapping.toNodeConnectorType(ncid, nid);
- Object aDNodeConnectorId = NodeMapping.toADNodeConnectorId(ncid, nid);
- org.opendaylight.controller.sal.core.Node aDNode = NodeMapping.toADNode(nid);
- return new org.opendaylight.controller.sal.core.NodeConnector(nodeConnectorType, aDNodeConnectorId, aDNode);
- } catch (Throwable e) {
- throw Exceptions.sneakyThrow(e);
- }
+
+ public static org.opendaylight.controller.sal.core.NodeConnector toADNodeConnector(final NodeConnectorId ncid, final NodeId nid) throws ConstructionException {
+ String nodeConnectorType = NodeMapping.toNodeConnectorType(ncid, nid);
+ Object aDNodeConnectorId = NodeMapping.toADNodeConnectorId(ncid, nid);
+ org.opendaylight.controller.sal.core.Node aDNode = NodeMapping.toADNode(nid);
+ return new org.opendaylight.controller.sal.core.NodeConnector(nodeConnectorType, aDNodeConnectorId, aDNode);
}
-
+
public static String toNodeConnectorType(final NodeConnectorId ncId, final NodeId nodeId) {
if (ncId.equals(toLocalNodeConnectorId(nodeId))) {
return NodeConnectorIDType.SWSTACK;
}
return nodeConnectorId.getValue();
}
-
+
public static NodeConnectorId toControllerNodeConnectorId(final NodeId node) {
return new NodeConnectorId(node.getValue() + ":" + 4294967293L);
}
-
+
public static NodeConnectorId toLocalNodeConnectorId(final NodeId node) {
return new NodeConnectorId(node.getValue() + ":" + 4294967294L);
}
-
+
public static NodeConnectorId toNormalNodeConnectorId(final NodeId node) {
return new NodeConnectorId(node.getValue() + ":" + 4294967290L);
}
-
+
public static NodeRef toNodeRef(final org.opendaylight.controller.sal.core.Node node) {
Preconditions.checkArgument(MD_SAL_TYPE.equals(node.getType()));
final String nodeId = Arguments.<String>checkInstanceOf(node.getID(), String.class);
final InstanceIdentifier<Node> nodePath = InstanceIdentifier.builder(Nodes.class).child(NODE_CLASS, nodeKey).toInstance();
return new NodeRef(nodePath);
}
-
+
public static NodeConnectorRef toNodeConnectorRef(final org.opendaylight.controller.sal.core.NodeConnector nodeConnector) {
final NodeRef node = NodeMapping.toNodeRef(nodeConnector.getNode());
nodeConnectorId = new NodeConnectorId(Arguments.<String>checkInstanceOf(nodeConnector.getID(), String.class));
}
final NodeConnectorKey connectorKey = new NodeConnectorKey(nodeConnectorId);
- final InstanceIdentifier<NodeConnector> path = InstanceIdentifier.builder(nodePath).child(NODECONNECTOR_CLASS, connectorKey).toInstance();
+ final InstanceIdentifier<NodeConnector> path = nodePath.child(NODECONNECTOR_CLASS, connectorKey);
return new NodeConnectorRef(path);
}
-
+
public static org.opendaylight.controller.sal.core.Node toADNode(final NodeRef node) throws ConstructionException {
return NodeMapping.toADNode(node.getValue());
}
-
+
public static HashSet<Property> toADNodeConnectorProperties(final NodeConnectorUpdated nc) {
final FlowCapableNodeConnectorUpdated fcncu = nc.<FlowCapableNodeConnectorUpdated>getAugmentation(FlowCapableNodeConnectorUpdated.class);
if (!Objects.equal(fcncu, null)) {
}
return new HashSet<Property>();
}
-
+
public static HashSet<Property> toADNodeConnectorProperties(final NodeConnector nc) {
final FlowCapableNodeConnector fcnc = nc.<FlowCapableNodeConnector>getAugmentation(FlowCapableNodeConnector.class);
if (!Objects.equal(fcnc, null)) {
}
return new HashSet<Property>();
}
-
+
public static HashSet<Property> toADNodeConnectorProperties(final FlowNodeConnector fcncu) {
final HashSet<org.opendaylight.controller.sal.core.Property> props = new HashSet<>();
}
return props;
}
-
+
public static Name toAdName(final String name) {
return new Name(name);
}
-
+
public static Config toAdConfig(final PortConfig pc) {
Config config = null;
if (pc.isPORTDOWN()) {
}
return config;
}
-
+
public static org.opendaylight.controller.sal.core.State toAdState(final State s) {
org.opendaylight.controller.sal.core.State state = null;
}
return state;
}
-
+
public static Bandwidth toAdBandwidth(final PortFeatures pf) {
Bandwidth bw = null;
if (pf.isTenMbHd() || pf.isTenMbFd()) {
}
return bw;
}
-
+
public static AdvertisedBandwidth toAdAdvertizedBandwidth(final PortFeatures pf) {
AdvertisedBandwidth abw = null;
final Bandwidth bw = toAdBandwidth(pf);
}
return abw;
}
-
+
public static SupportedBandwidth toAdSupportedBandwidth(final PortFeatures pf) {
SupportedBandwidth sbw = null;
final Bandwidth bw = toAdBandwidth(pf);
}
return sbw;
}
-
+
public static PeerBandwidth toAdPeerBandwidth(final PortFeatures pf) {
PeerBandwidth pbw = null;
final Bandwidth bw = toAdBandwidth(pf);
}
return pbw;
}
-
+
public static HashSet<Property> toADNodeProperties(final NodeUpdated nu) {
final FlowCapableNodeUpdated fcnu = nu.getAugmentation(FlowCapableNodeUpdated.class);
if (fcnu != null) {
}
return new HashSet<org.opendaylight.controller.sal.core.Property>();
}
-
+
public static HashSet<Property> toADNodeProperties(final FlowNode fcnu, final NodeId id) {
final HashSet<org.opendaylight.controller.sal.core.Property> props = new HashSet<>();
}
return props;
}
-
+
public static TimeStamp toADTimestamp() {
final Date date = new Date();
final TimeStamp timestamp = new TimeStamp(date.getTime(), "connectedSince");
return timestamp;
}
-
+
public static MacAddress toADMacAddress(final NodeId id) {
final String nodeId = id.getValue().replaceAll("openflow:", "");
long lNodeId = Long.parseLong(nodeId);
byte[] bytesFromDpid = ToSalConversionsUtils.bytesFromDpid(lNodeId);
return new MacAddress(bytesFromDpid);
}
-
+
public static Tables toADTables(final Short tables) {
return new Tables(tables.byteValue());
}
-
+
public static Capabilities toADCapabiliities(final List<Class<? extends FeatureCapability>> capabilities) {
int b = 0;
}
return new Capabilities(b);
}
-
+
public static Buffers toADBuffers(final Long buffers) {
return new Buffers(buffers.intValue());
}
<plugin>
<groupId>org.opendaylight.yangtools</groupId>
<artifactId>yang-maven-plugin</artifactId>
- <version>${yangtools.version}</version>
<dependencies>
<dependency>
<groupId>org.opendaylight.controller</groupId>
*/
package org.opendaylight.controller.config.yang.md.sal.binding.impl;
-import com.google.common.base.Optional;
-import com.google.common.base.Preconditions;
import java.util.Hashtable;
import java.util.Map.Entry;
import java.util.Set;
+
import org.opendaylight.controller.sal.binding.codegen.impl.SingletonHolder;
import org.opendaylight.yangtools.concepts.Delegator;
import org.opendaylight.yangtools.sal.binding.generator.impl.RuntimeGeneratedMappingServiceImpl;
import org.osgi.framework.BundleContext;
import org.osgi.framework.ServiceReference;
+import com.google.common.base.Optional;
+import com.google.common.base.Preconditions;
+
/**
*
*/
@Override
public java.lang.AutoCloseable createInstance() {
-
+
RuntimeGeneratedMappingServiceProxy potential = tryToReuseGlobalInstance();
if(potential != null) {
return potential;
}
- RuntimeGeneratedMappingServiceImpl service = new RuntimeGeneratedMappingServiceImpl();
- service.setPool(SingletonHolder.CLASS_POOL);
- service.init();
+
+ final RuntimeGeneratedMappingServiceImpl service = new RuntimeGeneratedMappingServiceImpl(SingletonHolder.CLASS_POOL);
bundleContext.registerService(SchemaServiceListener.class, service, new Hashtable<String,String>());
return service;
}
BindingIndependentMappingService, //
Delegator<BindingIndependentMappingService>, //
AutoCloseable {
-
+
private BindingIndependentMappingService delegate;
private ServiceReference<BindingIndependentMappingService> reference;
private BundleContext bundleContext;
this.delegate = Preconditions.checkNotNull(delegate);
}
+ @Override
public CodecRegistry getCodecRegistry() {
return delegate.getCodecRegistry();
}
+ @Override
public CompositeNode toDataDom(DataObject data) {
return delegate.toDataDom(data);
}
+ @Override
public Entry<InstanceIdentifier, CompositeNode> toDataDom(
Entry<org.opendaylight.yangtools.yang.binding.InstanceIdentifier<? extends DataObject>, DataObject> entry) {
return delegate.toDataDom(entry);
}
+ @Override
public InstanceIdentifier toDataDom(
org.opendaylight.yangtools.yang.binding.InstanceIdentifier<? extends DataObject> path) {
return delegate.toDataDom(path);
}
+ @Override
public DataObject dataObjectFromDataDom(
org.opendaylight.yangtools.yang.binding.InstanceIdentifier<? extends DataObject> path,
CompositeNode result) throws DeserializationException {
return delegate.dataObjectFromDataDom(path, result);
}
+ @Override
public org.opendaylight.yangtools.yang.binding.InstanceIdentifier<?> fromDataDom(InstanceIdentifier entry)
throws DeserializationException {
return delegate.fromDataDom(entry);
}
+ @Override
public Set<QName> getRpcQNamesFor(Class<? extends RpcService> service) {
return delegate.getRpcQNamesFor(service);
}
return delegate.getRpcServiceClassFor(namespace,revision);
}
+ @Override
public DataContainer dataObjectFromDataDom(Class<? extends DataContainer> inputClass, CompositeNode domInput) {
return delegate.dataObjectFromDataDom(inputClass, domInput);
}
-
+
@Override
public void close() throws Exception {
if(delegate != null) {
Entry<InstanceIdentifier<? extends DataObject>, DataObject> binding = getCodec().toBinding(entry);
newMap.put(binding.getKey(), binding.getValue());
} catch (DeserializationException e) {
- LOG.debug("Omitting {}", entry, e);
+ LOG.warn("Failed to transform {}, omitting it", entry, e);
}
}
return newMap;
InstanceIdentifier<? extends DataObject> binding = getCodec().toBinding(normalizedPath);
hashSet.add(binding);
} catch (DeserializationException e) {
- LOG.debug("Omitting {}", normalizedPath, e);
+ LOG.warn("Failed to transform {}, omitting it", normalizedPath, e);
}
}
return hashSet;
import javax.annotation.Nullable;
-import org.eclipse.xtext.xbase.lib.Exceptions;
import org.opendaylight.controller.md.sal.common.api.TransactionStatus;
import org.opendaylight.controller.md.sal.common.api.data.AsyncTransaction;
import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType;
@Nullable
@Override
public Optional<DataObject> apply(@Nullable final Optional<NormalizedNode<?, ?>> normalizedNode) {
- try {
- final DataObject dataObject = normalizedNode.isPresent() ? codec.toBinding(path,
- normalizedNode.get()) : null;
+ if (normalizedNode.isPresent()) {
+ final DataObject dataObject;
+ try {
+ dataObject = codec.toBinding(path, normalizedNode.get());
+ } catch (DeserializationException e) {
+ LOG.warn("Failed to create dataobject from node {}", normalizedNode.get(), e);
+ throw new IllegalStateException("Failed to create dataobject", e);
+ }
+
if (dataObject != null) {
updateCache(store, path, dataObject);
+ return Optional.of(dataObject);
}
- return Optional.fromNullable(dataObject);
- } catch (DeserializationException e) {
- Exceptions.sneakyThrow(e);
}
- return null;
+ return Optional.absent();
}
});
}
final Entry<org.opendaylight.yangtools.yang.data.api.InstanceIdentifier, NormalizedNode<?, ?>> normalized = codec
.toNormalizedNode(path, data);
- org.opendaylight.yangtools.yang.data.api.InstanceIdentifier normalizedPath = normalized.getKey();
- ensureParentsByMerge(writeTransaction, store, normalized.getKey(), path);
- LOG.debug("Tx: {} : Putting data {}",getDelegate().getIdentifier(),normalized.getKey());
- writeTransaction.put(store, normalized.getKey(), normalized.getValue());
+ final org.opendaylight.yangtools.yang.data.api.InstanceIdentifier normalizedPath = normalized.getKey();
+ ensureParentsByMerge(writeTransaction, store, normalizedPath, path);
+ LOG.debug("Tx: {} : Putting data {}", getDelegate().getIdentifier(), normalizedPath);
+ writeTransaction.put(store, normalizedPath, normalized.getValue());
}
protected void doMergeWithEnsureParents(final DOMDataReadWriteTransaction writeTransaction,
final Entry<org.opendaylight.yangtools.yang.data.api.InstanceIdentifier, NormalizedNode<?, ?>> normalized = codec
.toNormalizedNode(path, data);
- org.opendaylight.yangtools.yang.data.api.InstanceIdentifier normalizedPath = normalized.getKey();
- ensureParentsByMerge(writeTransaction, store, normalized.getKey(), path);
- LOG.debug("Tx: {} : Merge data {}",getDelegate().getIdentifier(),normalized.getKey());
- writeTransaction.merge(store, normalized.getKey(), normalized.getValue());
+ final org.opendaylight.yangtools.yang.data.api.InstanceIdentifier normalizedPath = normalized.getKey();
+ ensureParentsByMerge(writeTransaction, store, normalizedPath, path);
+ LOG.debug("Tx: {} : Merge data {}",getDelegate().getIdentifier(),normalizedPath);
+ writeTransaction.merge(store, normalizedPath, normalized.getValue());
}
private void ensureParentsByMerge(final DOMDataReadWriteTransaction writeTransaction,
*/
package org.opendaylight.controller.sal.binding.codegen;
-import com.google.common.base.Objects;
import java.lang.reflect.Field;
import java.util.Map;
-import org.eclipse.xtext.xbase.lib.Exceptions;
-import org.opendaylight.controller.sal.binding.codegen.RuntimeCodeSpecification;
+
import org.opendaylight.yangtools.yang.binding.BaseIdentity;
import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
import org.opendaylight.yangtools.yang.binding.RpcService;
-@SuppressWarnings("all")
-public class RuntimeCodeHelper {
- /**
- * Helper method to return delegate from ManagedDirectedProxy with use of reflection.
- *
- * Note: This method uses reflection, but access to delegate field should be
- * avoided and called only if neccessary.
- */
- public static <T extends RpcService> T getDelegate(final RpcService proxy) {
- try {
- Class<? extends RpcService> _class = proxy.getClass();
- final Field field = _class.getField(RuntimeCodeSpecification.DELEGATE_FIELD);
- boolean _equals = Objects.equal(field, null);
- if (_equals) {
- UnsupportedOperationException _unsupportedOperationException = new UnsupportedOperationException("Unable to get delegate from proxy");
- throw _unsupportedOperationException;
- }
- try {
- Object _get = field.get(proxy);
- return ((T) _get);
- } catch (Throwable _e) {
- throw Exceptions.sneakyThrow(_e);
- }
- } catch (Throwable _e_1) {
- throw Exceptions.sneakyThrow(_e_1);
+public final class RuntimeCodeHelper {
+ private RuntimeCodeHelper() {
+ throw new UnsupportedOperationException("Utility class should never be instantiated");
+ }
+
+ private static Field getField(final Class<?> cls, final String name) {
+ try {
+ return cls.getField(name);
+ } catch (NoSuchFieldException e) {
+ throw new IllegalArgumentException(
+ String.format("Class %s is missing field %s", cls, name), e);
+ } catch (SecurityException e) {
+ throw new IllegalStateException(String.format("Failed to examine class %s", cls), e);
+ }
}
- }
- /**
- * Helper method to set delegate to ManagedDirectedProxy with use of reflection.
- *
- * Note: This method uses reflection, but setting delegate field should not occur too much
- * to introduce any significant performance hits.
- */
- public static void setDelegate(final RpcService proxy, final RpcService delegate) {
- try {
- Class<? extends RpcService> _class = proxy.getClass();
- final Field field = _class.getField(RuntimeCodeSpecification.DELEGATE_FIELD);
- boolean _equals = Objects.equal(field, null);
- if (_equals) {
- UnsupportedOperationException _unsupportedOperationException = new UnsupportedOperationException("Unable to set delegate to proxy");
- throw _unsupportedOperationException;
- }
- boolean _or = false;
- boolean _equals_1 = Objects.equal(delegate, null);
- if (_equals_1) {
- _or = true;
- } else {
- Class<? extends Object> _type = field.getType();
- Class<? extends RpcService> _class_1 = delegate.getClass();
- boolean _isAssignableFrom = _type.isAssignableFrom(_class_1);
- _or = (_equals_1 || _isAssignableFrom);
- }
- if (_or) {
- field.set(proxy, delegate);
- } else {
- IllegalArgumentException _illegalArgumentException = new IllegalArgumentException("delegate class is not assignable to proxy");
- throw _illegalArgumentException;
- }
- } catch (Throwable _e) {
- throw Exceptions.sneakyThrow(_e);
+ private static Field getDelegateField(final Class<?> cls) {
+ return getField(cls, RuntimeCodeSpecification.DELEGATE_FIELD);
}
- }
- /**
- * Helper method to set delegate to ManagedDirectedProxy with use of reflection.
- *
- * Note: This method uses reflection, but setting delegate field should not occur too much
- * to introduce any significant performance hits.
- */
- public static void setDelegate(final Object proxy, final Object delegate) {
- try {
- Class<? extends Object> _class = proxy.getClass();
- final Field field = _class.getField(RuntimeCodeSpecification.DELEGATE_FIELD);
- boolean _equals = Objects.equal(field, null);
- if (_equals) {
- UnsupportedOperationException _unsupportedOperationException = new UnsupportedOperationException("Unable to set delegate to proxy");
- throw _unsupportedOperationException;
- }
- boolean _or = false;
- boolean _equals_1 = Objects.equal(delegate, null);
- if (_equals_1) {
- _or = true;
- } else {
- Class<? extends Object> _type = field.getType();
- Class<? extends Object> _class_1 = delegate.getClass();
- boolean _isAssignableFrom = _type.isAssignableFrom(_class_1);
- _or = (_equals_1 || _isAssignableFrom);
- }
- if (_or) {
- field.set(proxy, delegate);
- } else {
- IllegalArgumentException _illegalArgumentException = new IllegalArgumentException("delegate class is not assignable to proxy");
- throw _illegalArgumentException;
- }
- } catch (Throwable _e) {
- throw Exceptions.sneakyThrow(_e);
+ private static Object getFieldValue(final Field field, final Object obj) {
+ try {
+ return field.get(obj);
+ } catch (IllegalAccessException e) {
+ throw new IllegalStateException(String.format("Failed to get field %s of object %s", field, obj), e);
+ }
+ }
+
+ private static void setFieldValue(final Field field, final Object obj, final Object value) {
+ try {
+ field.set(obj, value);
+ } catch (IllegalAccessException e) {
+ throw new IllegalStateException(String.format("Failed to set field %s to %s", field, value), e);
+ }
+ }
+
+ /**
+ * Helper method to return delegate from ManagedDirectedProxy with use of reflection.
+ *
+ * Note: This method uses reflection, but access to delegate field should be
+ * avoided and called only if necessary.
+ */
+ @SuppressWarnings("unchecked")
+ public static <T extends RpcService> T getDelegate(final RpcService proxy) {
+ return (T)getFieldValue(getDelegateField(proxy.getClass()), proxy);
+ }
+
+ /**
+ * Helper method to set delegate to ManagedDirectedProxy with use of reflection.
+ *
+ * Note: This method uses reflection, but setting delegate field should not occur too much
+ * to introduce any significant performance hits.
+ */
+ public static void setDelegate(final Object proxy, final Object delegate) {
+ final Field field = getDelegateField(proxy.getClass());
+
+ if (delegate != null) {
+ final Class<?> ft = field.getType();
+ if (!ft.isAssignableFrom(delegate.getClass())) {
+ throw new IllegalArgumentException(
+ String.format("Field %s type %s is not compatible with delegate type %s",
+ field, ft, delegate.getClass()));
+ }
+ }
+
+ setFieldValue(field, proxy, delegate);
}
- }
- public static Map<InstanceIdentifier<? extends Object>,? extends RpcService> getRoutingTable(final RpcService target, final Class<? extends BaseIdentity> tableClass) {
- try {
- Class<? extends RpcService> _class = target.getClass();
- String _routingTableField = RuntimeCodeSpecification.getRoutingTableField(tableClass);
- final Field field = _class.getField(_routingTableField);
- boolean _equals = Objects.equal(field, null);
- if (_equals) {
- UnsupportedOperationException _unsupportedOperationException = new UnsupportedOperationException(
- "Unable to get routing table. Table field does not exists");
- throw _unsupportedOperationException;
- }
- try {
- Object _get = field.get(target);
- return ((Map<InstanceIdentifier<? extends Object>,? extends RpcService>) _get);
- } catch (Throwable _e) {
- throw Exceptions.sneakyThrow(_e);
- }
- } catch (Throwable _e_1) {
- throw Exceptions.sneakyThrow(_e_1);
+ @SuppressWarnings("unchecked")
+ public static Map<InstanceIdentifier<? extends Object>,? extends RpcService> getRoutingTable(final RpcService target, final Class<? extends BaseIdentity> tableClass) {
+ final Field field = getField(target.getClass(), RuntimeCodeSpecification.getRoutingTableField(tableClass));
+ return (Map<InstanceIdentifier<? extends Object>,? extends RpcService>) getFieldValue(field, target);
}
- }
- public static void setRoutingTable(final RpcService target, final Class<? extends BaseIdentity> tableClass, final Map<InstanceIdentifier<? extends Object>,? extends RpcService> routingTable) {
- try {
- Class<? extends RpcService> _class = target.getClass();
- String _routingTableField = RuntimeCodeSpecification.getRoutingTableField(tableClass);
- final Field field = _class.getField(_routingTableField);
- boolean _equals = Objects.equal(field, null);
- if (_equals) {
- UnsupportedOperationException _unsupportedOperationException = new UnsupportedOperationException(
- "Unable to set routing table. Table field does not exists");
- throw _unsupportedOperationException;
- }
- field.set(target, routingTable);
- } catch (Throwable _e) {
- throw Exceptions.sneakyThrow(_e);
+ public static void setRoutingTable(final RpcService target, final Class<? extends BaseIdentity> tableClass, final Map<InstanceIdentifier<? extends Object>,? extends RpcService> routingTable) {
+ final Field field = getField(target.getClass(), RuntimeCodeSpecification.getRoutingTableField(tableClass));
+ setFieldValue(field, target, routingTable);
}
- }
-}
\ No newline at end of file
+}
class RuntimeCodeGenerator implements org.opendaylight.controller.sal.binding.codegen.RuntimeCodeGenerator, NotificationInvokerFactory {
val CtClass BROKER_NOTIFICATION_LISTENER;
- val ClassPool classPool;
val extension JavassistUtils utils;
val Map<Class<? extends NotificationListener>, RuntimeGeneratedInvokerPrototype> invokerClasses;
new(ClassPool pool) {
- classPool = pool;
utils = new JavassistUtils(pool);
invokerClasses = new WeakHashMap();
BROKER_NOTIFICATION_LISTENER = org.opendaylight.controller.sal.binding.api.NotificationListener.asCtClass;
*/
package org.opendaylight.controller.sal.binding.codegen.impl;
-import com.google.common.util.concurrent.ListeningExecutorService;
-import com.google.common.util.concurrent.MoreExecutors;
-import com.google.common.util.concurrent.ThreadFactoryBuilder;
import java.util.concurrent.BlockingQueue;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.ThreadFactory;
import java.util.concurrent.ThreadPoolExecutor;
import java.util.concurrent.TimeUnit;
+
import javassist.ClassPool;
+
import org.apache.commons.lang3.StringUtils;
import org.opendaylight.controller.sal.binding.codegen.RuntimeCodeGenerator;
import org.opendaylight.controller.sal.binding.spi.NotificationInvokerFactory;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
+import com.google.common.util.concurrent.ListeningExecutorService;
+import com.google.common.util.concurrent.MoreExecutors;
+import com.google.common.util.concurrent.ThreadFactoryBuilder;
+
public class SingletonHolder {
private static final Logger logger = LoggerFactory.getLogger(SingletonHolder.class);
// occurs in RejectedExecutionHandler.
// This impl saturates threadpool first, then queue. When both are full caller will get blocked.
BlockingQueue<Runnable> queue = new LinkedBlockingQueue<Runnable>(queueSize) {
+ private static final long serialVersionUID = 1L;
+
@Override
public boolean offer(Runnable r) {
// ThreadPoolExecutor will spawn a new thread after core size is reached only if the queue.offer returns false.
private static final InstanceIdentifier<Nodes> NODES_INSTANCE_ID_BA = InstanceIdentifier.builder(Nodes.class) //
.toInstance();
- private static final InstanceIdentifier<Node> NODE_INSTANCE_ID_BA = InstanceIdentifier
- .builder(NODES_INSTANCE_ID_BA) //
- .child(Node.class, NODE_KEY).toInstance();
+ private static final InstanceIdentifier<Node> NODE_INSTANCE_ID_BA =
+ NODES_INSTANCE_ID_BA.child(Node.class, NODE_KEY);
private static final org.opendaylight.yangtools.yang.data.api.InstanceIdentifier NODE_INSTANCE_ID_BI = //
org.opendaylight.yangtools.yang.data.api.InstanceIdentifier.builder() //
/**
* Test for Bug 148
- *
+ *
* @throws Exception
*/
@Test
// Node meterStatsNodeWithDuration = createTestNode(NodeMeterStatistics.class, nodeMeterStatistics(5, true));
// commitNodeAndVerifyTransaction(meterStatsNodeWithDuration);
//
-//
+//
// Node nodeWithUpdatedList = (Node) baDataService.readOperationalData(NODE_INSTANCE_ID_BA);
// AugmentationVerifier.from(nodeWithUpdatedList) //
// .assertHasAugmentation(FlowCapableNode.class) //
// .assertHasAugmentation(NodeMeterStatistics.class);
-//
+//
// List<MeterStats> meterStats = nodeWithUpdatedList.getAugmentation(NodeMeterStatistics.class).getMeterStatistics().getMeterStats();
// assertNotNull(meterStats);
// assertFalse(meterStats.isEmpty());
public void startBindingToDomMappingService() {
checkState(classPool != null, "ClassPool needs to be present");
- mappingServiceImpl = new RuntimeGeneratedMappingServiceImpl();
- mappingServiceImpl.setPool(classPool);
- mappingServiceImpl.init();
+ mappingServiceImpl = new RuntimeGeneratedMappingServiceImpl(classPool);
}
public void updateYangSchema(final String[] files) {
private static final NodeKey NODE_FOO_KEY = new NodeKey(new NodeId("foo"));
private static final NodeKey NODE_BAR_KEY = new NodeKey(new NodeId("foo"));
private static InstanceIdentifier<Nodes> NODES_PATH = InstanceIdentifier.builder(Nodes.class).build();
- private static InstanceIdentifier<Node> NODE_FOO_PATH = InstanceIdentifier.builder(NODES_PATH)
- .child(Node.class, NODE_FOO_KEY).build();
- private static InstanceIdentifier<Node> NODE_BAR_PATH = InstanceIdentifier.builder(NODES_PATH)
- .child(Node.class, NODE_FOO_KEY).build();
+ private static InstanceIdentifier<Node> NODE_FOO_PATH = NODES_PATH.child(Node.class, NODE_FOO_KEY);
+ private static InstanceIdentifier<Node> NODE_BAR_PATH = NODES_PATH.child(Node.class, NODE_FOO_KEY);
@Test
public void testConcurrentCreate() throws InterruptedException, ExecutionException {
private static final UnorderedListKey UNORDERED_FOO_KEY = new UnorderedListKey("foo");
private static final UnorderedListKey UNORDERED_BAR_KEY = new UnorderedListKey("bar");
- private static final InstanceIdentifier<UnorderedList> UNORDERED_FOO_PATH = InstanceIdentifier.builder(UNORDERED_CONTAINER_PATH).child(UnorderedList.class,UNORDERED_FOO_KEY).build();
- private static final InstanceIdentifier<UnorderedList> UNORDERED_BAR_PATH = InstanceIdentifier.builder(UNORDERED_CONTAINER_PATH).child(UnorderedList.class,UNORDERED_BAR_KEY).build();
+ private static final InstanceIdentifier<UnorderedList> UNORDERED_FOO_PATH = UNORDERED_CONTAINER_PATH.child(UnorderedList.class,UNORDERED_FOO_KEY);
+ private static final InstanceIdentifier<UnorderedList> UNORDERED_BAR_PATH = UNORDERED_CONTAINER_PATH.child(UnorderedList.class,UNORDERED_BAR_KEY);
private static final OrderedListKey ORDERED_FOO_KEY = new OrderedListKey("foo");
private static final OrderedListKey ORDERED_BAR_KEY = new OrderedListKey("bar");
- private static final InstanceIdentifier<OrderedList> ORDERED_FOO_PATH = InstanceIdentifier.builder(ORDERED_CONTAINER_PATH).child(OrderedList.class,ORDERED_FOO_KEY).build();
- private static final InstanceIdentifier<OrderedList> ORDERED_BAR_PATH = InstanceIdentifier.builder(ORDERED_CONTAINER_PATH).child(OrderedList.class,ORDERED_BAR_KEY).build();
+ private static final InstanceIdentifier<OrderedList> ORDERED_FOO_PATH = ORDERED_CONTAINER_PATH.child(OrderedList.class,ORDERED_FOO_KEY);
+ private static final InstanceIdentifier<OrderedList> ORDERED_BAR_PATH = ORDERED_CONTAINER_PATH.child(OrderedList.class,ORDERED_BAR_KEY);
@Test
private static final FlowKey FLOW_KEY = new FlowKey(new FlowId("test"));
- private static final InstanceIdentifier<Flow> NODE_0_FLOW_PATH = InstanceIdentifier.builder(NODE_0_TABLE_PATH)
- .child(Flow.class, FLOW_KEY).build();
+ private static final InstanceIdentifier<Flow> NODE_0_FLOW_PATH = NODE_0_TABLE_PATH.child(Flow.class, FLOW_KEY);
- private static final InstanceIdentifier<Flow> NODE_1_FLOW_PATH = InstanceIdentifier.builder(NODE_1_TABLE_PATH)
- .child(Flow.class, FLOW_KEY).build();
+ private static final InstanceIdentifier<Flow> NODE_1_FLOW_PATH = NODE_1_TABLE_PATH.child(Flow.class, FLOW_KEY);
- private static final InstanceIdentifier<TableFeatures> NODE_0_TABLE_FEATURES_PATH = InstanceIdentifier
- .builder(NODE_0_TABLE_PATH).child(TableFeatures.class, TABLE_FEATURES_KEY).build();
+ private static final InstanceIdentifier<TableFeatures> NODE_0_TABLE_FEATURES_PATH =
+ NODE_0_TABLE_PATH.child(TableFeatures.class, TABLE_FEATURES_KEY);
private static final TableFeatures TABLE_FEATURES = new TableFeaturesBuilder()//
.setKey(TABLE_FEATURES_KEY) //
.toInstance();
- private static final InstanceIdentifier<Node> NODE_INSTANCE_ID_BA = InstanceIdentifier//
- .builder(NODES_INSTANCE_ID_BA) //
- .child(Node.class, NODE_KEY).toInstance();
+ private static final InstanceIdentifier<Node> NODE_INSTANCE_ID_BA = NODES_INSTANCE_ID_BA.child(Node.class, NODE_KEY);
- private static final InstanceIdentifier<SupportedActions> SUPPORTED_ACTIONS_INSTANCE_ID_BA = InstanceIdentifier//
- .builder(NODES_INSTANCE_ID_BA) //
+ private static final InstanceIdentifier<SupportedActions> SUPPORTED_ACTIONS_INSTANCE_ID_BA = //
+ NODES_INSTANCE_ID_BA.builder() //
.child(Node.class, NODE_KEY) //
.augmentation(FlowCapableNode.class) //
.child(SupportedActions.class)
NodeConnectorId ncId = new NodeConnectorId("openflow:1:bar");
NodeConnectorKey nodeKey = new NodeConnectorKey(ncId );
- InstanceIdentifier<NodeConnector> ncInstanceId = InstanceIdentifier.builder(NODE_INSTANCE_ID_BA).child(NodeConnector.class, nodeKey).toInstance();
+ InstanceIdentifier<NodeConnector> ncInstanceId = NODE_INSTANCE_ID_BA.child(NodeConnector.class, nodeKey);
NodeConnectorBuilder ncBuilder = new NodeConnectorBuilder();
ncBuilder.setId(ncId);
ncBuilder.setKey(nodeKey);
*/
package org.opendaylight.controller.sal.binding.test.bugfix;
-import com.google.common.collect.ImmutableSet;
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertNotNull;
+import static org.junit.Assert.assertNull;
+
+import java.util.ArrayList;
+import java.util.Collections;
+import java.util.List;
+import java.util.Map;
+
import org.junit.Test;
import org.opendaylight.controller.md.sal.common.api.TransactionStatus;
import org.opendaylight.controller.sal.binding.api.data.DataModificationTransaction;
import org.opendaylight.yangtools.yang.common.RpcResult;
import org.opendaylight.yangtools.yang.data.api.CompositeNode;
-import java.util.ArrayList;
-import java.util.Collections;
-import java.util.List;
-import java.util.Map;
-
-import static org.junit.Assert.assertEquals;
-import static org.junit.Assert.assertNotNull;
-import static org.junit.Assert.assertNull;
+import com.google.common.collect.ImmutableSet;
public class FlagsSerializationTest extends AbstractDataServiceTest {
private static final NodeKey NODE_KEY = new NodeKey(new NodeId(NODE_ID));
private static final FlowKey FLOW_KEY = new FlowKey(new FlowId(FLOW_ID));
private static final TableKey TABLE_KEY = new TableKey(TABLE_ID);
-
+
private static final Map<QName, Object> NODE_KEY_BI = Collections.<QName, Object> singletonMap(NODE_ID_QNAME,
NODE_ID);
// private static final org.opendaylight.yangtools.yang.data.api.InstanceIdentifier FLOW_INSTANCE_ID_BI = //
// org.opendaylight.yangtools.yang.data.api.InstanceIdentifier.builder() //
-//
+//
// .node(Flows.QNAME) //
// .nodeWithKey(Flow.QNAME, FLOW_KEY_BI) //
// .toInstance();
private static final InstanceIdentifier<? extends DataObject> FLOW_INSTANCE_ID_BA = //
- InstanceIdentifier.builder(NODE_INSTANCE_ID_BA) //
+ NODE_INSTANCE_ID_BA.builder() //
.augmentation(FlowCapableNode.class)
.child(Table.class,TABLE_KEY)
.child(Flow.class, FLOW_KEY) //
FlowModFlags checkOverlapFlags = new FlowModFlags(true,false,false,false,false);
ImmutableSet<String> domCheckOverlapFlags = ImmutableSet.<String>of("CHECK_OVERLAP");
testFlags(checkOverlapFlags,domCheckOverlapFlags);
-
-
-
+
+
+
FlowModFlags allFalseFlags = new FlowModFlags(false,false,false,false,false);
ImmutableSet<String> domAllFalseFlags = ImmutableSet.<String>of();
testFlags(allFalseFlags,domAllFalseFlags);
-
+
FlowModFlags allTrueFlags = new FlowModFlags(true,true,true,true,true);
ImmutableSet<String> domAllTrueFlags = ImmutableSet.<String>of("CHECK_OVERLAP","NO_BYT_COUNTS", "NO_PKT_COUNTS", "RESET_COUNTS", "SEND_FLOW_REM");
testFlags(allTrueFlags,domAllTrueFlags);
-
+
FlowModFlags nullFlags = null;
ImmutableSet<String> domNullFlags = null;
testFlags(null,null);
-
-
+
+
}
private void testFlags(FlowModFlags flagsToTest, ImmutableSet<String> domFlags) throws Exception {
Flow flow = createFlow(flagsToTest);
assertNotNull(flow);
-
+
CompositeNode domFlow = biDataService.readConfigurationData(mappingService.toDataDom(FLOW_INSTANCE_ID_BA));
-
+
assertNotNull(domFlow);
org.opendaylight.yangtools.yang.data.api.Node<?> readedFlags = domFlow.getFirstSimpleByName(FLOW_FLAGS_QNAME);
-
+
if(domFlags != null) {
assertNotNull(readedFlags);
assertEquals(domFlags,readedFlags.getValue());
assertNull(readedFlags);
}
assertEquals(flagsToTest, flow.getFlags());
-
+
DataModificationTransaction transaction = baDataService.beginTransaction();
transaction.removeConfigurationData(FLOW_INSTANCE_ID_BA);
RpcResult<TransactionStatus> result = transaction.commit().get();
assertEquals(TransactionStatus.COMMITED, result.getResult());
-
+
}
private Flow createFlow(FlowModFlags flagsToTest) throws Exception {
flow.setKey(FLOW_KEY);
flow.setMatch(match.build());
-
+
flow.setFlags(flagsToTest);
-
+
InstructionsBuilder instructions = new InstructionsBuilder();
InstructionBuilder instruction = new InstructionBuilder();
-
+
instruction.setOrder(10);
ApplyActionsBuilder applyActions = new ApplyActionsBuilder();
List<Action> actionList = new ArrayList<>();
private static final InstanceIdentifier<Nodes> NODES_INSTANCE_ID_BA = InstanceIdentifier.builder(Nodes.class) //
.toInstance();
- private static final InstanceIdentifier<Node> NODE_INSTANCE_ID_BA = InstanceIdentifier//
- .builder(NODES_INSTANCE_ID_BA) //
+ private static final InstanceIdentifier<Node> NODE_INSTANCE_ID_BA = //
+ NODES_INSTANCE_ID_BA.builder() //
.child(Node.class, NODE_KEY).toInstance();
- private static final InstanceIdentifier<SupportedActions> SUPPORTED_ACTIONS_INSTANCE_ID_BA = InstanceIdentifier//
- .builder(NODES_INSTANCE_ID_BA) //
+ private static final InstanceIdentifier<SupportedActions> SUPPORTED_ACTIONS_INSTANCE_ID_BA = //
+ NODES_INSTANCE_ID_BA.builder() //
.child(Node.class, NODE_KEY) //
.augmentation(FlowCapableNode.class) //
.child(SupportedActions.class).toInstance();
- private static final InstanceIdentifier<FlowCapableNode> ALL_FLOW_CAPABLE_NODES = InstanceIdentifier //
- .builder(NODES_INSTANCE_ID_BA) //
+ private static final InstanceIdentifier<FlowCapableNode> ALL_FLOW_CAPABLE_NODES = //
+ NODES_INSTANCE_ID_BA.builder() //
.child(Node.class) //
.augmentation(FlowCapableNode.class) //
.build();
.nodeWithKey(Node.QNAME, NODE_KEY_BI) //
.node(SUPPORTED_ACTIONS_QNAME) //
.toInstance();
- private static final InstanceIdentifier<FlowCapableNode> FLOW_AUGMENTATION_PATH = InstanceIdentifier //
- .builder(NODE_INSTANCE_ID_BA) //
+ private static final InstanceIdentifier<FlowCapableNode> FLOW_AUGMENTATION_PATH =
+ NODE_INSTANCE_ID_BA.builder() //
.augmentation(FlowCapableNode.class) //
.build();
fnub.setDescription("Description Foo");
fnub.setSoftware("JUnit emulated");
FlowCapableNode fnu = fnub.build();
- InstanceIdentifier<FlowCapableNode> augmentIdentifier = InstanceIdentifier.builder(NODE_INSTANCE_ID_BA)
- .augmentation(FlowCapableNode.class).toInstance();
+ InstanceIdentifier<FlowCapableNode> augmentIdentifier = NODE_INSTANCE_ID_BA
+ .augmentation(FlowCapableNode.class);
DataModificationTransaction augmentedTransaction = baDataService.beginTransaction();
augmentedTransaction.putOperationalData(augmentIdentifier, fnu);
lastReceivedChangeEvent = SettableFuture.create();
assertEquals(TransactionStatus.COMMITED, result.getResult());
- FlowCapableNode readedAugmentation = (FlowCapableNode) baDataService.readOperationalData(InstanceIdentifier
- .builder(NODE_INSTANCE_ID_BA).augmentation(FlowCapableNode.class).toInstance());
+ FlowCapableNode readedAugmentation = (FlowCapableNode) baDataService.readOperationalData(
+ NODE_INSTANCE_ID_BA.augmentation(FlowCapableNode.class));
assertNotNull(readedAugmentation);
assertEquals(fnu.getHardware(), readedAugmentation.getHardware());
private void testPutNodeConnectorWithAugmentation() throws Exception {
NodeConnectorKey ncKey = new NodeConnectorKey(new NodeConnectorId("test:0:0"));
- InstanceIdentifier<NodeConnector> ncPath = InstanceIdentifier.builder(NODE_INSTANCE_ID_BA)
- .child(NodeConnector.class, ncKey).toInstance();
- InstanceIdentifier<FlowCapableNodeConnector> ncAugmentPath = InstanceIdentifier.builder(ncPath)
- .augmentation(FlowCapableNodeConnector.class).toInstance();
+ InstanceIdentifier<NodeConnector> ncPath = NODE_INSTANCE_ID_BA
+ .child(NodeConnector.class, ncKey);
+ InstanceIdentifier<FlowCapableNodeConnector> ncAugmentPath = ncPath
+ .augmentation(FlowCapableNodeConnector.class);
NodeConnectorBuilder nc = new NodeConnectorBuilder();
nc.setKey(ncKey);
.child(Node.class, NODE_KEY).toInstance();
private static final InstanceIdentifier<Table> TABLE_INSTANCE_ID_BA = //
- InstanceIdentifier.builder(NODE_INSTANCE_ID_BA) //
+ NODE_INSTANCE_ID_BA.builder() //
.augmentation(FlowCapableNode.class).child(Table.class, TABLE_KEY).build();
private static final InstanceIdentifier<? extends DataObject> FLOW_INSTANCE_ID_BA = //
- InstanceIdentifier.builder(TABLE_INSTANCE_ID_BA) //
- .child(Flow.class, FLOW_KEY) //
- .toInstance();
+ TABLE_INSTANCE_ID_BA.child(Flow.class, FLOW_KEY);
/**
*
* The scenario tests writing parent node, which also contains child items
DataObject readedTable = baDataService.readConfigurationData(TABLE_INSTANCE_ID_BA);
assertNotNull("Readed table should not be nul.", readedTable);
assertTrue(readedTable instanceof Table);
-
+
DataObject readedFlow = baDataService.readConfigurationData(FLOW_INSTANCE_ID_BA);
assertNotNull("Readed flow should not be null.",readedFlow);
assertTrue(readedFlow instanceof Flow);
assertEquals(flow, readedFlow);
}
-}
\ No newline at end of file
+}
private static final TableKey TABLE_KEY_BA = new TableKey((short) 0);
private static final InstanceIdentifier<Flow> FLOWS_PATH_BA = //
- InstanceIdentifier.builder(NODE_INSTANCE_ID_BA) //
+ NODE_INSTANCE_ID_BA.builder() //
.augmentation(FlowCapableNode.class) //
.child(Table.class, TABLE_KEY_BA) //
.child(Flow.class) //
.toInstance();
private static final InstanceIdentifier<Flow> FLOW_INSTANCE_ID_BA = //
- InstanceIdentifier.builder(FLOWS_PATH_BA.firstIdentifierOf(Table.class)) //
- .child(Flow.class, FLOW_KEY) //
- .toInstance();
+ FLOWS_PATH_BA.firstIdentifierOf(Table.class).child(Flow.class, FLOW_KEY);
@Test
public void simpleModifyOperation() throws Exception {
.child(Node.class, NODE_KEY).toInstance();
private static GroupKey GROUP_KEY = new GroupKey(new GroupId(0L));
- private static final InstanceIdentifier<GroupStatistics> GROUP_STATISTICS_ID_BA = InstanceIdentifier
- .builder(NODE_INSTANCE_ID_BA).augmentation(FlowCapableNode.class) //
+ private static final InstanceIdentifier<GroupStatistics> GROUP_STATISTICS_ID_BA = NODE_INSTANCE_ID_BA
+ .builder().augmentation(FlowCapableNode.class) //
.child(Group.class, GROUP_KEY) //
.augmentation(NodeGroupStatistics.class) //
.child(GroupStatistics.class) //
import java.util.Map;
import java.util.Map.Entry;
import java.util.Set;
-import java.util.concurrent.Callable;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Future;
import java.util.concurrent.atomic.AtomicLong;
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;
-import org.eclipse.xtext.xbase.lib.Exceptions;
import org.opendaylight.controller.md.sal.common.api.RegistrationListener;
import org.opendaylight.controller.md.sal.common.api.TransactionStatus;
import org.opendaylight.controller.md.sal.common.api.data.DataChangeEvent;
import com.google.common.base.Function;
import com.google.common.base.Preconditions;
import com.google.common.base.Predicate;
+import com.google.common.base.Supplier;
import com.google.common.collect.FluentIterable;
import com.google.common.collect.HashMultimap;
import com.google.common.collect.ImmutableList;
}
protected ImmutableList<DataCommitHandler<P, D>> affectedCommitHandlers(final Set<P> paths) {
- final Callable<ImmutableList<DataCommitHandler<P, D>>> _function = new Callable<ImmutableList<DataCommitHandler<P, D>>>() {
+ final Supplier<ImmutableList<DataCommitHandler<P, D>>> _function = new Supplier<ImmutableList<DataCommitHandler<P, D>>>() {
@Override
- public ImmutableList<DataCommitHandler<P, D>> call() throws Exception {
+ public ImmutableList<DataCommitHandler<P, D>> get() {
Map<P, Collection<DataCommitHandlerRegistrationImpl<P, D>>> _asMap = commitHandlers.asMap();
Set<Entry<P, Collection<DataCommitHandlerRegistrationImpl<P, D>>>> _entrySet = _asMap.entrySet();
FluentIterable<Entry<P, Collection<DataCommitHandlerRegistrationImpl<P, D>>>> _from = FluentIterable
}
protected ImmutableList<DataCommitHandler<P, D>> probablyAffectedCommitHandlers(final HashSet<P> paths) {
- final Callable<ImmutableList<DataCommitHandler<P, D>>> _function = new Callable<ImmutableList<DataCommitHandler<P, D>>>() {
+ final Supplier<ImmutableList<DataCommitHandler<P, D>>> _function = new Supplier<ImmutableList<DataCommitHandler<P, D>>>() {
@Override
- public ImmutableList<DataCommitHandler<P, D>> call() throws Exception {
+ public ImmutableList<DataCommitHandler<P, D>> get() {
Map<P, Collection<DataCommitHandlerRegistrationImpl<P, D>>> _asMap = commitHandlers.asMap();
Set<Entry<P, Collection<DataCommitHandlerRegistrationImpl<P, D>>>> _entrySet = _asMap.entrySet();
FluentIterable<Entry<P, Collection<DataCommitHandlerRegistrationImpl<P, D>>>> _from = FluentIterable
return _dataReadRouter.readOperationalData(path);
}
- private static <T extends Object> T withLock(final Lock lock, final Callable<T> method) {
+ private static <T extends Object> T withLock(final Lock lock, final Supplier<T> method) {
lock.lock();
try {
- return method.call();
- } catch (Exception e) {
- throw Exceptions.sneakyThrow(e);
+ return method.get();
} finally {
lock.unlock();
}
InstanceIdentifier normalizedPath = normalizer.toNormalized(LEAF_TWO_PATH_LEGACY);
- Node<?> outerListLegacy = normalizer.toLegacy(OUTER_LIST_WITH_CHOICE);
+ Node<?> outerListLegacy = DataNormalizer.toLegacy(OUTER_LIST_WITH_CHOICE);
assertNotNull(outerListLegacy);
-
-
-
-
}
}
<dependency>
<groupId>org.opendaylight.controller</groupId>
<artifactId>netconf-client</artifactId>
- <version>${netconf.version}</version>
</dependency>
<dependency>
<groupId>org.opendaylight.controller</groupId>
package org.opendaylight.controller.sal.connector.remoterpc;
-import static com.google.common.base.Preconditions.checkNotNull;
+import static com.google.common.base.Preconditions.checkState;
import java.util.Collection;
import java.util.Collections;
Optional<RoutingTable<RpcRouter.RouteIdentifier, String>> routingTable =
routingTableProvider.getRoutingTable();
- checkNotNull(routingTable.isPresent(), "Routing table is null");
+ checkState(routingTable.isPresent(), "Routing table is null");
return routingTable.get();
}
package org.opendaylight.controller.sal.connector.remoterpc.dto;
-import org.opendaylight.controller.sal.connector.api.RpcRouter;
+import java.io.ByteArrayInputStream;
+import java.io.ByteArrayOutputStream;
+import java.io.IOException;
+import java.io.ObjectInputStream;
+import java.io.ObjectOutputStream;
+import java.io.Serializable;
-import java.io.*;
+import org.opendaylight.controller.sal.connector.api.RpcRouter;
public class Message implements Serializable {
+ private static final long serialVersionUID = 1L;
public static enum MessageType {
PING((byte) 0),
}
public static class Response extends Message implements RpcRouter.RpcReply {
+ private static final long serialVersionUID = 1L;
private ResponseCode code; // response code
public static enum ResponseCode {
SUCCESS(200), BADREQUEST(400), TIMEOUT(408), GONE(410), SERVERERROR(500), SERVICEUNAVAILABLE(503);
- private int code;
+ private final int code;
ResponseCode(int code) {
this.code = code;
*/
public static class MessageBuilder{
- private Message message;
+ private final Message message;
public MessageBuilder(){
message = new Message();
*/
package org.opendaylight.controller.sal.connector.remoterpc.dto;
+import java.io.Serializable;
+
import org.opendaylight.controller.sal.connector.api.RpcRouter;
import org.opendaylight.yangtools.yang.common.QName;
import org.opendaylight.yangtools.yang.data.api.InstanceIdentifier;
-import java.io.Serializable;
-
public class RouteIdentifierImpl implements RpcRouter.RouteIdentifier<QName, QName, InstanceIdentifier>,Serializable {
+ private static final long serialVersionUID = 1L;
private QName context;
private QName type;
*/
package org.opendaylight.controller.sal.connector.remoterpc;
+import java.util.concurrent.Callable;
+import java.util.concurrent.ExecutorService;
+import java.util.concurrent.Executors;
+import java.util.concurrent.FutureTask;
+import java.util.concurrent.TimeUnit;
+
import junit.framework.Assert;
+
import org.junit.After;
import org.junit.Before;
import org.junit.Test;
import org.slf4j.LoggerFactory;
import org.zeromq.ZMQ;
-import java.io.IOException;
-import java.util.concurrent.*;
-
/**
*
*/
serverThread.execute(MessagingUtil.startReplyServer(context, serverAddress, 1));
threadPool.execute(createEmptyMessageTaskAndHandle(handler, serverAddress));
}
- Thread.currentThread().sleep(5000);//wait for all messages to get processed
+ Thread.sleep(5000);//wait for all messages to get processed
//should be connected to 5 remote server
Assert.assertEquals(5, handler.getWorkerCount());
}
import org.opendaylight.yangtools.restconf.client.api.UnsupportedProtocolException;
import org.opendaylight.yangtools.sal.binding.generator.impl.ModuleInfoBackedContext;
import org.opendaylight.yangtools.sal.binding.generator.impl.RuntimeGeneratedMappingServiceImpl;
-import org.opendaylight.yangtools.yang.binding.Augmentation;
import org.opendaylight.yangtools.yang.binding.util.BindingReflections;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
public SalRemoteClientImpl(final URL url) {
Preconditions.checkNotNull(url);
- this.mappingService = new RuntimeGeneratedMappingServiceImpl();
- this.mappingService.setPool(ClassPool.getDefault());
- this.mappingService.init();
+ this.mappingService = new RuntimeGeneratedMappingServiceImpl(ClassPool.getDefault());
final ModuleInfoBackedContext moduleInfo = ModuleInfoBackedContext.create();
moduleInfo.addModuleInfos(BindingReflections.loadModuleInfos());
Uri destPortUri = destPort.getValue().firstKeyOf(NodeConnector.class, NodeConnectorKey.class).getId();
Action outputToControllerAction = new ActionBuilder() //
+ .setOrder(0)
.setAction(new OutputActionCaseBuilder() //
.setOutputAction(new OutputActionBuilder() //
.setMaxLength(new Integer(0xffff)) //
// Wrap our Apply Action in an Instruction
Instruction applyActionsInstruction = new InstructionBuilder() //
+ .setOrder(0)
.setInstruction(new ApplyActionsCaseBuilder()//
.setApplyActions(applyActions) //
.build()) //
<dependency>
<groupId>org.opendaylight.controller</groupId>
<artifactId>sal-binding-it</artifactId>
- <version>1.1-SNAPSHOT</version>
</dependency>
<dependency>
<groupId>org.opendaylight.controller.samples</groupId>
abstract class AbstractStatsTracker<I, K> {
private static final Logger logger = LoggerFactory.getLogger(AbstractStatsTracker.class);
-
+
private static final int WAIT_FOR_REQUEST_CYCLE = 2;
-
+
private final FutureCallback<RpcResult<? extends TransactionAware>> callback =
new FutureCallback<RpcResult<? extends TransactionAware>>() {
@Override
}
protected final InstanceIdentifierBuilder<Node> getNodeIdentifierBuilder() {
- return InstanceIdentifier.builder(getNodeIdentifier());
+ return getNodeIdentifier().builder();
}
protected final NodeRef getNodeRef() {
if (Group.class.equals(key.getTargetType())) {
@SuppressWarnings("unchecked")
InstanceIdentifier<Group> group = (InstanceIdentifier<Group>)key;
- InstanceIdentifier<?> del = InstanceIdentifier.builder(group).augmentation(NodeGroupDescStats.class).toInstance();
+ InstanceIdentifier<?> del = group.augmentation(NodeGroupDescStats.class);
logger.debug("Key {} triggered remove of augmentation {}", key, del);
trans.removeOperationalData(del);
if (Group.class.equals(key.getTargetType())) {
@SuppressWarnings("unchecked")
InstanceIdentifier<Group> group = (InstanceIdentifier<Group>)key;
- InstanceIdentifier<?> del = InstanceIdentifier.builder(group).augmentation(NodeGroupStatistics.class).toInstance();
+ InstanceIdentifier<?> del = group.augmentation(NodeGroupStatistics.class);
logger.debug("Key {} triggered remove of augmentation {}", key, del);
trans.removeOperationalData(del);
InstanceIdentifier<Meter> meter = (InstanceIdentifier<Meter>)key;
InstanceIdentifier<?> nodeMeterStatisticsAugmentation =
- InstanceIdentifier.builder(meter).augmentation(NodeMeterConfigStats.class).toInstance();
+ meter.augmentation(NodeMeterConfigStats.class);
trans.removeOperationalData(nodeMeterStatisticsAugmentation);
}
}
InstanceIdentifier<Meter> meter = (InstanceIdentifier<Meter>)key;
InstanceIdentifier<?> nodeMeterStatisticsAugmentation =
- InstanceIdentifier.builder(meter).augmentation(NodeMeterStatistics.class).toInstance();
+ meter.augmentation(NodeMeterStatistics.class);
trans.removeOperationalData(nodeMeterStatisticsAugmentation);
}
}
if (Queue.class.equals(key.getTargetType())) {
@SuppressWarnings("unchecked")
final InstanceIdentifier<Queue> queue = (InstanceIdentifier<Queue>)key;
- final InstanceIdentifier<?> del = InstanceIdentifier.builder(queue)
- .augmentation(FlowCapableNodeConnectorQueueStatisticsData.class).build();
+ final InstanceIdentifier<?> del = queue
+ .augmentation(FlowCapableNodeConnectorQueueStatisticsData.class);
logger.debug("Key {} triggered remove of augmentation {}", key, del);
trans.removeOperationalData(del);
}
for (Link link : topologyData.getLink()) {
if (id.equals(link.getSource().getSourceNode()) || id.equals(link.getDestination().getDestNode())) {
- InstanceIdentifier<Link> path = InstanceIdentifier.builder(topologyPath)
- .child(Link.class, link.getKey()).build();
+ InstanceIdentifier<Link> path = topologyPath.child(Link.class, link.getKey());
transaction.removeOperationalData(path);
}
}
}
for (Link link : topologyData.getLink()) {
if (id.equals(link.getSource().getSourceTp()) || id.equals(link.getDestination().getDestTp())) {
- InstanceIdentifier<Link> path = InstanceIdentifier.builder(topologyPath)
- .child(Link.class, link.getKey()).build();
+ InstanceIdentifier<Link> path = topologyPath.child(Link.class, link.getKey());
transaction.removeOperationalData(path);
}
}
.child(Topology.class, topology).child(Link.class, link.getKey()).build();
return linkInstanceId;
}
-
+
/**
* @param txId transaction identificator
* @param future transaction result
*/
private static void listenOnTransactionState(final Object txId, Future<RpcResult<TransactionStatus>> future) {
Futures.addCallback(JdkFutureAdapters.listenInPoolThread(future),new FutureCallback<RpcResult<TransactionStatus>>() {
-
+
@Override
public void onFailure(Throwable t) {
LOG.error("Topology export failed for Tx:{}", txId, t);
-
+
}
-
+
@Override
public void onSuccess(RpcResult<TransactionStatus> result) {
if(!result.isSuccessful()) {
*/
package org.opendaylight.controller.netconf.confignetconfconnector.exception;
-import org.opendaylight.controller.netconf.api.NetconfDocumentedException;
-
import java.util.Collections;
import java.util.Map;
+import org.opendaylight.controller.netconf.api.NetconfDocumentedException;
+
public class NetconfConfigHandlingException extends NetconfDocumentedException {
+ private static final long serialVersionUID = 1L;
public NetconfConfigHandlingException(final String message, final ErrorType errorType, final ErrorTag errorTag,
final ErrorSeverity errorSeverity) {
*/
package org.opendaylight.controller.netconf.confignetconfconnector.exception;
-import org.opendaylight.controller.netconf.api.NetconfDocumentedException;
-
import java.util.Collections;
import java.util.Map;
+import org.opendaylight.controller.netconf.api.NetconfDocumentedException;
+
public class NoTransactionFoundException extends NetconfDocumentedException {
+ private static final long serialVersionUID = 1L;
public NoTransactionFoundException(final String message, final ErrorType errorType, final ErrorTag errorTag,
final ErrorSeverity errorSeverity) {
*/
package org.opendaylight.controller.netconf.confignetconfconnector.exception;
-import org.opendaylight.controller.netconf.api.NetconfDocumentedException;
-
import java.util.Collections;
import java.util.Map;
+import org.opendaylight.controller.netconf.api.NetconfDocumentedException;
+
public class OperationNotPermittedException extends NetconfDocumentedException {
+ private static final long serialVersionUID = 1L;
public OperationNotPermittedException(final String message, final ErrorType errorType, final ErrorTag errorTag,
final ErrorSeverity errorSeverity) {
package org.opendaylight.controller.netconf.persist.impl;
-import com.google.common.base.Function;
-import com.google.common.base.Preconditions;
-import com.google.common.base.Stopwatch;
-import com.google.common.collect.Collections2;
+import java.io.IOException;
+import java.io.InputStream;
+import java.util.Collection;
+import java.util.HashSet;
+import java.util.LinkedHashMap;
+import java.util.List;
+import java.util.Map.Entry;
+import java.util.Set;
+import java.util.TreeMap;
+import java.util.concurrent.TimeUnit;
+
+import javax.annotation.concurrent.Immutable;
+
import org.opendaylight.controller.config.api.ConflictingVersionException;
import org.opendaylight.controller.config.persist.api.ConfigSnapshotHolder;
import org.opendaylight.controller.netconf.api.NetconfDocumentedException;
import org.w3c.dom.Element;
import org.xml.sax.SAXException;
-import javax.annotation.concurrent.Immutable;
-import java.io.IOException;
-import java.io.InputStream;
-import java.util.Collection;
-import java.util.HashSet;
-import java.util.LinkedHashMap;
-import java.util.List;
-import java.util.Map.Entry;
-import java.util.Set;
-import java.util.TreeMap;
-import java.util.concurrent.TimeUnit;
+import com.google.common.base.Function;
+import com.google.common.base.Preconditions;
+import com.google.common.base.Stopwatch;
+import com.google.common.collect.Collections2;
@Immutable
public class ConfigPusher {
}
private static class NotEnoughCapabilitiesException extends Exception {
+ private static final long serialVersionUID = 1L;
+
private NotEnoughCapabilitiesException(String message, Throwable cause) {
super(message, cause);
}
*/
package org.opendaylight.controller.netconf.util.exception;
-import org.opendaylight.controller.netconf.api.NetconfDocumentedException;
-
import java.util.Collections;
import java.util.Map;
+import org.opendaylight.controller.netconf.api.NetconfDocumentedException;
+
public class MissingNameSpaceException extends NetconfDocumentedException {
+ private static final long serialVersionUID = 1L;
public MissingNameSpaceException(final String message, final ErrorType errorType, final ErrorTag errorTag,
- final ErrorSeverity errorSeverity) {
+ final ErrorSeverity errorSeverity) {
this(message, errorType, errorTag, errorSeverity, Collections.<String, String> emptyMap());
}
public MissingNameSpaceException(final String message, final ErrorType errorType, final ErrorTag errorTag,
- final ErrorSeverity errorSeverity, final Map<String, String> errorInfo){
+ final ErrorSeverity errorSeverity, final Map<String, String> errorInfo){
super(message,errorType,errorTag,errorSeverity,errorInfo);
}
}
*/
package org.opendaylight.controller.netconf.util.exception;
-import org.opendaylight.controller.netconf.api.NetconfDocumentedException;
-
import java.util.Collections;
import java.util.Map;
+import org.opendaylight.controller.netconf.api.NetconfDocumentedException;
+
public class UnexpectedElementException extends NetconfDocumentedException {
+ private static final long serialVersionUID = 1L;
public UnexpectedElementException(final String message, final ErrorType errorType, final ErrorTag errorTag,
- final ErrorSeverity errorSeverity) {
+ final ErrorSeverity errorSeverity) {
this(message, errorType, errorTag, errorSeverity, Collections.<String, String> emptyMap());
}
public UnexpectedElementException(final String message, final ErrorType errorType, final ErrorTag errorTag,
- final ErrorSeverity errorSeverity, final Map<String, String> errorInfo){
+ final ErrorSeverity errorSeverity, final Map<String, String> errorInfo) {
super(message,errorType,errorTag,errorSeverity,errorInfo);
}
}
*/
package org.opendaylight.controller.netconf.util.exception;
-import org.opendaylight.controller.netconf.api.NetconfDocumentedException;
-
import java.util.Collections;
import java.util.Map;
+import org.opendaylight.controller.netconf.api.NetconfDocumentedException;
+
public class UnexpectedNamespaceException extends NetconfDocumentedException {
+ private static final long serialVersionUID = 1L;
public UnexpectedNamespaceException(final String message, final ErrorType errorType, final ErrorTag errorTag,
final ErrorSeverity errorSeverity) {
<plugin>
<groupId>org.apache.felix</groupId>
<artifactId>maven-bundle-plugin</artifactId>
- <version>2.3.6</version>
<extensions>true</extensions>
<configuration>
<instructions>
<plugin>
<groupId>org.apache.felix</groupId>
<artifactId>maven-bundle-plugin</artifactId>
- <version>${bundle.plugin.version}</version>
<extensions>true</extensions>
<configuration>
<instructions>
<plugin>
<groupId>org.apache.felix</groupId>
<artifactId>maven-bundle-plugin</artifactId>
- <version>${bundle.plugin.version}</version>
<extensions>true</extensions>
<configuration>
<instructions>
<plugin>
<groupId>org.apache.felix</groupId>
<artifactId>maven-bundle-plugin</artifactId>
- <version>${bundle.plugin.version}</version>
<extensions>true</extensions>
<configuration>
<instructions>
<plugin>
<groupId>org.apache.felix</groupId>
<artifactId>maven-bundle-plugin</artifactId>
- <version>${bundle.plugin.version}</version>
<extensions>true</extensions>
<configuration>
<instructions>
<plugin>
<groupId>org.apache.felix</groupId>
<artifactId>maven-bundle-plugin</artifactId>
- <version>${bundle.plugin.version}</version>
<extensions>true</extensions>
<configuration>
<instructions>
<plugin>
<groupId>org.apache.felix</groupId>
<artifactId>maven-bundle-plugin</artifactId>
- <version>${bundle.plugin.version}</version>
<extensions>true</extensions>
<configuration>
<instructions>
<plugin>
<groupId>org.apache.felix</groupId>
<artifactId>maven-bundle-plugin</artifactId>
- <version>${bundle.plugin.version}</version>
<extensions>true</extensions>
<configuration>
<instructions>
<plugin>
<groupId>org.apache.felix</groupId>
<artifactId>maven-bundle-plugin</artifactId>
- <version>${bundle.plugin.version}</version>
<extensions>true</extensions>
<configuration>
<instructions>
<plugin>
<groupId>org.apache.felix</groupId>
<artifactId>maven-bundle-plugin</artifactId>
- <version>${bundle.plugin.version}</version>
<extensions>true</extensions>
<configuration>
<instructions>
<plugin>
<groupId>org.apache.felix</groupId>
<artifactId>maven-bundle-plugin</artifactId>
- <version>2.4.0</version>
<extensions>true</extensions>
<configuration>
<instructions>
<plugin>
<groupId>org.apache.felix</groupId>
<artifactId>maven-bundle-plugin</artifactId>
- <version>${bundle.plugin.version}</version>
<extensions>true</extensions>
<configuration>
<instructions>
<plugin>
<groupId>org.apache.felix</groupId>
<artifactId>maven-bundle-plugin</artifactId>
- <version>${bundle.plugin.version}</version>
<extensions>true</extensions>
<configuration>
<instructions>
<plugin>
<groupId>org.apache.felix</groupId>
<artifactId>maven-bundle-plugin</artifactId>
- <version>2.3.6</version>
<extensions>true</extensions>
<configuration>
<instructions>
<plugin>
<groupId>org.apache.felix</groupId>
<artifactId>maven-bundle-plugin</artifactId>
- <version>${bundle.plugin.version}</version>
<extensions>true</extensions>
<configuration>
<instructions>
<plugin>
<groupId>org.apache.felix</groupId>
<artifactId>maven-bundle-plugin</artifactId>
- <version>${bundle.plugin.version}</version>
<extensions>true</extensions>
<configuration>
<instructions>
<plugin>
<groupId>org.apache.felix</groupId>
<artifactId>maven-bundle-plugin</artifactId>
- <version>${bundle.plugin.version}</version>
<extensions>true</extensions>
<configuration>
<instructions>
<plugin>
<groupId>org.apache.felix</groupId>
<artifactId>maven-bundle-plugin</artifactId>
- <version>${bundle.plugin.version}</version>
<extensions>true</extensions>
<configuration>
<instructions>
<plugin>
<groupId>org.apache.felix</groupId>
<artifactId>maven-bundle-plugin</artifactId>
- <version>${bundle.plugin.version}</version>
<extensions>true</extensions>
<configuration>
<instructions>
<plugin>
<groupId>org.apache.felix</groupId>
<artifactId>maven-bundle-plugin</artifactId>
- <version>${bundle.plugin.version}</version>
<extensions>true</extensions>
<configuration>
<instructions>
<plugin>
<groupId>org.apache.felix</groupId>
<artifactId>maven-bundle-plugin</artifactId>
- <version>${bundle.plugin.version}</version>
<extensions>true</extensions>
<configuration>
<instructions>
<plugin>
<groupId>org.apache.felix</groupId>
<artifactId>maven-bundle-plugin</artifactId>
- <version>${bundle.plugin.version}</version>
<extensions>true</extensions>
<configuration>
<instructions>
<plugin>
<groupId>org.apache.felix</groupId>
<artifactId>maven-bundle-plugin</artifactId>
- <version>${bundle.plugin.version}</version>
<extensions>true</extensions>
<configuration>
<instructions>
<plugin>
<groupId>org.apache.felix</groupId>
<artifactId>maven-bundle-plugin</artifactId>
- <version>${bundle.plugin.version}</version>
<extensions>true</extensions>
<configuration>
<instructions>
<plugin>
<groupId>org.apache.felix</groupId>
<artifactId>maven-bundle-plugin</artifactId>
- <version>${bundle.plugin.version}</version>
<extensions>true</extensions>
<configuration>
<instructions>
<plugin>
<groupId>org.apache.felix</groupId>
<artifactId>maven-bundle-plugin</artifactId>
- <version>${bundle.plugin.version}</version>
<extensions>true</extensions>
<configuration>
<instructions>
<plugin>
<groupId>org.apache.felix</groupId>
<artifactId>maven-bundle-plugin</artifactId>
- <version>${bundle.plugin.version}</version>
<extensions>true</extensions>
<configuration>
<instructions>
<plugin>
<groupId>org.apache.felix</groupId>
<artifactId>maven-bundle-plugin</artifactId>
- <version>${bundle.plugin.version}</version>
<extensions>true</extensions>
<configuration>
<instructions>
<plugin>
<groupId>org.apache.felix</groupId>
<artifactId>maven-bundle-plugin</artifactId>
- <version>${bundle.plugin.version}</version>
<extensions>true</extensions>
<configuration>
<instructions>
<plugin>
<groupId>org.apache.felix</groupId>
<artifactId>maven-bundle-plugin</artifactId>
- <version>${bundle.plugin.version}</version>
<extensions>true</extensions>
<configuration>
<instructions>
<plugin>
<groupId>org.apache.felix</groupId>
<artifactId>maven-bundle-plugin</artifactId>
- <version>${bundle.plugin.version}</version>
<extensions>true</extensions>
<configuration>
<instructions>
<plugin>
<groupId>org.apache.felix</groupId>
<artifactId>maven-bundle-plugin</artifactId>
- <version>${bundle.plugin.version}</version>
<extensions>true</extensions>
<configuration>
<instructions>
<plugin>
<groupId>org.apache.felix</groupId>
<artifactId>maven-bundle-plugin</artifactId>
- <version>${bundle.plugin.version}</version>
<extensions>true</extensions>
<configuration>
<instructions>
<plugin>
<groupId>org.apache.felix</groupId>
<artifactId>maven-bundle-plugin</artifactId>
- <version>${bundle.plugin.version}</version>
<extensions>true</extensions>
<configuration>
<instructions>
<plugin>
<groupId>org.apache.felix</groupId>
<artifactId>maven-bundle-plugin</artifactId>
- <version>${bundle.plugin.version}</version>
<extensions>true</extensions>
<configuration>
<instructions>
<plugin>
<groupId>org.apache.felix</groupId>
<artifactId>maven-bundle-plugin</artifactId>
- <version>${bundle.plugin.version}</version>
<extensions>true</extensions>
<configuration>
<instructions>
<plugin>
<groupId>org.apache.felix</groupId>
<artifactId>maven-bundle-plugin</artifactId>
- <version>${bundle.plugin.version}</version>
<extensions>true</extensions>
<configuration>
<instructions>
<plugin>
<groupId>org.apache.felix</groupId>
<artifactId>maven-bundle-plugin</artifactId>
- <version>${bundle.plugin.version}</version>
<extensions>true</extensions>
<configuration>
<instructions>
<plugin>
<groupId>org.apache.felix</groupId>
<artifactId>maven-bundle-plugin</artifactId>
- <version>${bundle.plugin.version}</version>
<extensions>true</extensions>
<configuration>
<instructions>
org.springframework.security.core.userdetails,
javax.xml.bind.annotation</Import-Package>
<Export-Package>org.opendaylight.controller.usermanager,</Export-Package>
- <Bundle-Activator></Bundle-Activator>
</instructions>
<manifestLocation>${project.basedir}/META-INF</manifestLocation>
</configuration>
<plugin>
<groupId>org.apache.felix</groupId>
<artifactId>maven-bundle-plugin</artifactId>
- <version>${bundle.plugin.version}</version>
<extensions>true</extensions>
<configuration>
<instructions>
<plugin>
<groupId>org.apache.felix</groupId>
<artifactId>maven-bundle-plugin</artifactId>
- <version>${bundle.plugin.version}</version>
<extensions>true</extensions>
<configuration>
<instructions>
<plugin>
<groupId>org.apache.felix</groupId>
<artifactId>maven-bundle-plugin</artifactId>
- <version>${bundle.plugin.version}</version>
<extensions>true</extensions>
<configuration>
<instructions>
<plugin>
<groupId>org.apache.felix</groupId>
<artifactId>maven-bundle-plugin</artifactId>
- <version>2.4.0</version>
<extensions>true</extensions>
<configuration>
<instructions>
<plugin>
<groupId>org.apache.felix</groupId>
<artifactId>maven-bundle-plugin</artifactId>
- <version>${bundle.plugin.version}</version>
<extensions>true</extensions>
<configuration>
<instructions>
<plugin>
<groupId>org.apache.felix</groupId>
<artifactId>maven-bundle-plugin</artifactId>
- <version>${bundle.plugin.version}</version>
<extensions>true</extensions>
<configuration>
<instructions>
<plugin>
<groupId>org.apache.felix</groupId>
<artifactId>maven-bundle-plugin</artifactId>
- <version>${bundle.plugin.version}</version>
<extensions>true</extensions>
<configuration>
<instructions>