--- /dev/null
+<?xml version="1.0" encoding="UTF-8"?>
+<!--
+ 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
+-->
+
+<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
+ <modelVersion>4.0.0</modelVersion>
+ <parent>
+ <groupId>org.opendaylight.controller</groupId>
+ <artifactId>commons.opendaylight</artifactId>
+ <version>1.5.0-SNAPSHOT</version>
+ <relativePath>../../opendaylight/commons/opendaylight</relativePath>
+ </parent>
+ <artifactId>features-extras</artifactId>
+ <groupId>org.opendaylight.controller</groupId>
+ <packaging>jar</packaging>
+ <properties>
+ <features.file>features.xml</features.file>
+ <!-- Optional TODO: Move these properties to your parent pom and possibly
+ DependencyManagement section of your parent pom -->
+ <branding.version>1.1.0-SNAPSHOT</branding.version>
+ <karaf.resources.version>1.5.0-SNAPSHOT</karaf.resources.version>
+ <karaf.version>3.0.1</karaf.version>
+ <feature.test.version>0.7.0-SNAPSHOT</feature.test.version>
+ <karaf.empty.version>1.5.0-SNAPSHOT</karaf.empty.version>
+ <surefire.version>2.16</surefire.version>
+ </properties>
+ <dependencies>
+ <dependency>
+ <groupId>org.jolokia</groupId>
+ <artifactId>jolokia-osgi</artifactId>
+ <version>${jolokia.version}</version>
+ </dependency>
+ <dependency>
+ <groupId>org.opendaylight.yangtools</groupId>
+ <artifactId>features-test</artifactId>
+ <version>${feature.test.version}</version>
+ <scope>test</scope>
+ </dependency>
+ <!-- dependency for opendaylight-karaf-empty for use by testing -->
+ <dependency>
+ <groupId>org.opendaylight.controller</groupId>
+ <artifactId>opendaylight-karaf-empty</artifactId>
+ <version>${karaf.empty.version}</version>
+ <type>zip</type>
+ </dependency>
+ </dependencies>
+ <build>
+ <resources>
+ <resource>
+ <directory>src/main/resources</directory>
+ <filtering>true</filtering>
+ </resource>
+ </resources>
+ <plugins>
+ <plugin>
+ <groupId>org.apache.maven.plugins</groupId>
+ <artifactId>maven-resources-plugin</artifactId>
+ <executions>
+ <execution>
+ <id>filter</id>
+ <phase>generate-resources</phase>
+ <goals>
+ <goal>resources</goal>
+ </goals>
+ </execution>
+ </executions>
+ </plugin>
+ <plugin>
+ <groupId>org.codehaus.mojo</groupId>
+ <artifactId>build-helper-maven-plugin</artifactId>
+ <executions>
+ <execution>
+ <id>attach-artifacts</id>
+ <phase>package</phase>
+ <goals>
+ <goal>attach-artifact</goal>
+ </goals>
+ <configuration>
+ <artifacts>
+ <artifact>
+ <file>${project.build.directory}/classes/${features.file}</file>
+ <type>xml</type>
+ <classifier>features</classifier>
+ </artifact>
+ </artifacts>
+ </configuration>
+ </execution>
+ </executions>
+ </plugin>
+ <plugin>
+ <groupId>org.apache.maven.plugins</groupId>
+ <artifactId>maven-surefire-plugin</artifactId>
+ <version>${surefire.version}</version>
+ <configuration>
+ <systemPropertyVariables>
+ <karaf.distro.groupId>org.opendaylight.controller</karaf.distro.groupId>
+ <karaf.distro.artifactId>opendaylight-karaf-empty</karaf.distro.artifactId>
+ <karaf.distro.version>${karaf.empty.version}</karaf.distro.version>
+ </systemPropertyVariables>
+ <dependenciesToScan>
+ <dependency>org.opendaylight.yangtools:features-test</dependency>
+ </dependenciesToScan>
+ </configuration>
+ </plugin>
+ </plugins>
+ </build>
+ <scm>
+ <connection>scm:git:ssh://git.opendaylight.org:29418/controller.git</connection>
+ <developerConnection>scm:git:ssh://git.opendaylight.org:29418/controller.git</developerConnection>
+ <tag>HEAD</tag>
+ <url>https://git.opendaylight.org/gerrit/gitweb?p=controller.git;a=summary</url>
+ </scm>
+</project>
--- /dev/null
+<?xml version="1.0" encoding="UTF-8"?>
+<!-- vi: set et smarttab sw=4 tabstop=4: -->
+<!--
+ 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
+-->
+
+<!--
+
+ This feature file is intended to contain only third party features that cannot be accommodated in any
+ other feature file. This is a good place to add features like jolokia which no other feature depends on
+ but which provides a utility.
+-->
+<features name="odl-extras-${project.version}" xmlns="http://karaf.apache.org/xmlns/features/v1.2.0"
+ xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
+ xsi:schemaLocation="http://karaf.apache.org/xmlns/features/v1.2.0 http://karaf.apache.org/xmlns/features/v1.2.0">
+ <feature name='odl-extras-all' version='${project.version}' description='OpenDaylight :: Extras :: All'>
+ <feature version="${project.version}">odl-jolokia</feature>
+ </feature>
+ <feature name="odl-jolokia" version="${project.version}" description="Jolokia JMX/HTTP bridge">
+ <feature>http</feature>
+ <bundle>mvn:org.jolokia/jolokia-osgi/${jolokia.version}</bundle>
+ </feature>
+</features>
<classifier>features</classifier>
<type>xml</type>
</dependency>
+
+ <dependency>
+ <groupId>org.opendaylight.controller.md</groupId>
+ <artifactId>statistics-manager-config</artifactId>
+ <version>${mdsal.version}</version>
+ <type>xml</type>
+ <classifier>config</classifier>
+ </dependency>
+
<dependency>
<groupId>org.opendaylight.controller.model</groupId>
<artifactId>model-flow-base</artifactId>
<bundle>mvn:org.opendaylight.controller.md/inventory-manager/${project.version}</bundle>
<bundle>mvn:org.opendaylight.controller.md/forwardingrules-manager/${project.version}</bundle>
<bundle>mvn:org.opendaylight.controller/liblldp/${sal.version}</bundle>
+ <configfile finalname="${config.configfile.directory}/${config.statistics.manager.configfile}">mvn:org.opendaylight.controller.md/statistics-manager-config/${mdsal.version}/xml/config</configfile>
</feature>
</features>
<module>akka</module>
<module>netconf-connector</module>
<module>restconf</module>
+ <module>extras</module>
</modules>
-</project>
\ No newline at end of file
+</project>
<controllermanager.northbound.version>0.1.0-SNAPSHOT</controllermanager.northbound.version>
<devices.web.version>0.5.0-SNAPSHOT</devices.web.version>
<dummy-console.version>1.2.0-SNAPSHOT</dummy-console.version>
+ <config.statistics.manager.configfile>30-statistics-manager.xml</config.statistics.manager.configfile>
<eclipse.persistence.version>2.5.0</eclipse.persistence.version>
<eclipse.jdt.core.compiler.batch.version>3.8.0.I20120518-2145</eclipse.jdt.core.compiler.batch.version>
<!-- enforcer version -->
<type>xml</type>
<scope>runtime</scope>
</dependency>
+ <dependency>
+ <groupId>org.opendaylight.controller</groupId>
+ <artifactId>features-extras</artifactId>
+ <version>${project.version}</version>
+ <classifier>features</classifier>
+ <type>xml</type>
+ <scope>runtime</scope>
+ </dependency>
<dependency>
<groupId>org.opendaylight.controller</groupId>
<artifactId>features-flow</artifactId>
<module>inventory-manager</module>
<module>statistics-manager</module>
+ <module>statistics-manager-config</module>
<module>topology-manager</module>
<module>forwardingrules-manager</module>
<module>topology-lldp-discovery</module>
package org.opendaylight.controller.cluster.example.messages;
import com.google.protobuf.GeneratedMessage;
-import org.opendaylight.controller.protobuff.messages.cluster.example.KeyValueMessages;
-import org.opendaylight.controller.cluster.raft.protobuff.client.messages.Payload;
-import org.opendaylight.controller.protobuff.messages.cluster.raft.AppendEntriesMessages;
-
import java.io.Serializable;
import java.util.HashMap;
import java.util.Map;
+import org.opendaylight.controller.cluster.raft.protobuff.client.messages.Payload;
+import org.opendaylight.controller.protobuff.messages.cluster.example.KeyValueMessages;
+import org.opendaylight.controller.protobuff.messages.cluster.raft.AppendEntriesMessages;
public class KeyValue extends Payload implements Serializable {
private static final long serialVersionUID = 1L;
return this;
}
+ @Override
+ public int size() {
+ return this.value.length() + this.key.length();
+ }
+
}
protected ArrayList<ReplicatedLogEntry> snapshottedJournal;
protected long previousSnapshotIndex = -1;
protected long previousSnapshotTerm = -1;
+ protected int dataSize = 0;
public AbstractReplicatedLogImpl(long snapshotIndex,
long snapshotTerm, List<ReplicatedLogEntry> unAppliedEntries) {
snapshottedJournal = null;
previousSnapshotIndex = -1;
previousSnapshotTerm = -1;
+ dataSize = 0;
}
@Override
*/
long getSnapshotBatchCount();
+ /**
+ * The percentage of total memory in the in-memory Raft log before a snapshot
+ * is to be taken
+ *
+ * @return int
+ */
+ int getSnapshotDataThresholdPercentage();
+
/**
* The interval at which a heart beat message will be sent to the remote
* RaftActor
*/
package org.opendaylight.controller.cluster.raft;
-import scala.concurrent.duration.FiniteDuration;
-
import java.util.concurrent.TimeUnit;
+import scala.concurrent.duration.FiniteDuration;
/**
* Default implementation of the ConfigParams
private FiniteDuration isolatedLeaderCheckInterval =
new FiniteDuration(HEART_BEAT_INTERVAL.length() * 1000, HEART_BEAT_INTERVAL.unit());
+ // 12 is just an arbitrary percentage. This is the amount of the total memory that a raft actor's
+ // in-memory journal can use before it needs to snapshot
+ private int snapshotDataThresholdPercentage = 12;
+
public void setHeartBeatInterval(FiniteDuration heartBeatInterval) {
this.heartBeatInterval = heartBeatInterval;
}
this.snapshotBatchCount = snapshotBatchCount;
}
+ public void setSnapshotDataThresholdPercentage(int snapshotDataThresholdPercentage){
+ this.snapshotDataThresholdPercentage = snapshotDataThresholdPercentage;
+ }
+
public void setJournalRecoveryLogBatchSize(int journalRecoveryLogBatchSize) {
this.journalRecoveryLogBatchSize = journalRecoveryLogBatchSize;
}
return snapshotBatchCount;
}
+ @Override
+ public int getSnapshotDataThresholdPercentage() {
+ return snapshotDataThresholdPercentage;
+ }
+
+
@Override
public FiniteDuration getHeartBeatInterval() {
return heartBeatInterval;
@Override public void apply(DeleteEntries param)
throws Exception {
//FIXME : Doing nothing for now
+ dataSize = 0;
+ for(ReplicatedLogEntry entry : journal){
+ dataSize += entry.size();
+ }
}
});
}
appendAndPersist(null, null, replicatedLogEntry);
}
+ @Override
+ public int dataSize() {
+ return dataSize;
+ }
+
public void appendAndPersist(final ActorRef clientActor,
final String identifier,
final ReplicatedLogEntry replicatedLogEntry) {
new Procedure<ReplicatedLogEntry>() {
@Override
public void apply(ReplicatedLogEntry evt) throws Exception {
+ dataSize += replicatedLogEntry.size();
+
+ long dataThreshold = Runtime.getRuntime().totalMemory() *
+ getRaftActorContext().getConfigParams().getSnapshotDataThresholdPercentage() / 100;
+
// when a snaphsot is being taken, captureSnapshot != null
if (hasSnapshotCaptureInitiated == false &&
- journal.size() % context.getConfigParams().getSnapshotBatchCount() == 0) {
+ ( journal.size() % context.getConfigParams().getSnapshotBatchCount() == 0 ||
+ dataSize > dataThreshold)) {
LOG.info("Initiating Snapshot Capture..");
long lastAppliedIndex = -1;
* Restores the replicated log to a state in the event of a save snapshot failure
*/
public void snapshotRollback();
+
+ /**
+ * Size of the data in the log (in bytes)
+ */
+ public int dataSize();
}
* @return
*/
long getIndex();
+
+ /**
+ * The size of the entry in bytes.
+ *
+ * An approximate number may be good enough.
+ *
+ * @return
+ */
+ int size();
}
package org.opendaylight.controller.cluster.raft;
-import org.opendaylight.controller.cluster.raft.protobuff.client.messages.Payload;
-
import java.io.Serializable;
+import org.opendaylight.controller.cluster.raft.protobuff.client.messages.Payload;
public class ReplicatedLogImplEntry implements ReplicatedLogEntry,
Serializable {
return index;
}
+ @Override
+ public int size() {
+ return getData().size();
+ }
+
@Override public String toString() {
return "Entry{" +
"index=" + index +
this.snapshotTerm = snapshotTerm;
}
+ @Override
+ public int dataSize() {
+ return -1;
+ }
+
public List<ReplicatedLogEntry> getEntriesTill(final int index) {
return journal.subList(0, index);
}
import akka.event.LoggingAdapter;
import com.google.common.base.Preconditions;
import com.google.protobuf.GeneratedMessage;
-import org.opendaylight.controller.cluster.raft.protobuff.client.messages.Payload;
-import org.opendaylight.controller.protobuff.messages.cluster.raft.AppendEntriesMessages;
-import org.opendaylight.controller.protobuff.messages.cluster.raft.test.MockPayloadMessages;
-
import java.io.Serializable;
import java.util.HashMap;
import java.util.Map;
+import org.opendaylight.controller.cluster.raft.protobuff.client.messages.Payload;
+import org.opendaylight.controller.protobuff.messages.cluster.raft.AppendEntriesMessages;
+import org.opendaylight.controller.protobuff.messages.cluster.raft.test.MockPayloadMessages;
public class MockRaftActorContext implements RaftActorContext {
append(replicatedLogEntry);
}
+ @Override
+ public int dataSize() {
+ return -1;
+ }
+
@Override public void removeFromAndPersist(long index) {
removeFrom(index);
}
return this;
}
+ @Override
+ public int size() {
+ return value.length();
+ }
+
@Override public String getClientPayloadClassName() {
return MockPayload.class.getName();
}
@Override public long getIndex() {
return index;
}
+
+ @Override
+ public int size() {
+ return getData().size();
+ }
}
public static class MockReplicatedLogBuilder {
import com.google.protobuf.GeneratedMessage;
import com.google.protobuf.InvalidProtocolBufferException;
import com.google.protobuf.UnknownFieldSet;
-import org.opendaylight.controller.protobuff.messages.cluster.raft.AppendEntriesMessages;
-import org.opendaylight.controller.protobuff.messages.persistent.PersistentMessages;
-
import java.io.Serializable;
import java.util.HashMap;
import java.util.Map;
+import org.opendaylight.controller.protobuff.messages.cluster.raft.AppendEntriesMessages;
+import org.opendaylight.controller.protobuff.messages.persistent.PersistentMessages;
public class CompositeModificationPayload extends Payload implements
Serializable {
public Object getModification(){
return this.modification;
}
+
+ public int size(){
+ return this.modification.getSerializedSize();
+ }
}
import com.google.protobuf.GeneratedMessage;
-import org.opendaylight.controller.protobuff.messages.cluster.raft.AppendEntriesMessages;
-
import java.util.Map;
+import org.opendaylight.controller.protobuff.messages.cluster.raft.AppendEntriesMessages;
/**
* An instance of a Payload class is meant to be used as the Payload for
public abstract Payload decode(
AppendEntriesMessages.AppendEntries.ReplicatedLogEntry.Payload payload);
+ public abstract int size();
+
}
import org.opendaylight.yangtools.yang.data.api.schema.MapEntryNode;
import org.opendaylight.yangtools.yang.data.api.schema.MapNode;
import org.opendaylight.yangtools.yang.data.api.schema.NormalizedNode;
+import org.opendaylight.yangtools.yang.data.api.schema.UnkeyedListEntryNode;
import org.opendaylight.yangtools.yang.data.impl.schema.Builders;
import org.opendaylight.yangtools.yang.data.impl.schema.ImmutableNodes;
import org.opendaylight.yangtools.yang.data.impl.schema.builder.api.CollectionNodeBuilder;
import java.io.InputStream;
import java.util.ArrayList;
+import java.util.HashMap;
import java.util.HashSet;
import java.util.List;
+import java.util.Map;
import java.util.Set;
import static org.opendaylight.yangtools.yang.data.impl.schema.ImmutableNodes.mapEntry;
private static final String TWO_ONE_NAME = "one";
private static final String TWO_TWO_NAME = "two";
private static final String DESC = "Hello there";
-
+ private static final Long LONG_ID = 1L;
+ private static final Boolean ENABLED = false;
+ private static final Short SHORT_ID = 1;
+ private static final Byte BYTE_ID = 1;
// Family specific constants
public static final QName FAMILY_QNAME =
QName
private static final String FIRST_GRAND_CHILD_NAME = "first grand child";
private static final String SECOND_GRAND_CHILD_NAME = "second grand child";
+
// first child
private static final YangInstanceIdentifier CHILDREN_1_PATH =
YangInstanceIdentifier.builder(CHILDREN_PATH)
QName.create(TEST_QNAME, "my-bits"))).withValue(
ImmutableSet.of("foo", "bar"));
+ // Create unkey list entry
+ UnkeyedListEntryNode binaryDataKey =
+ Builders.unkeyedListEntryBuilder().withNodeIdentifier(new YangInstanceIdentifier.NodeIdentifier(TEST_QNAME)).
+ withChild(ImmutableNodes.leafNode(SOME_BINARY_DATE_QNAME, DESC)).build();
+
+ Map<QName, Object> keyValues = new HashMap<>();
+ keyValues.put(CHILDREN_QNAME, FIRST_CHILD_NAME);
+
// Create the document
return ImmutableContainerNodeBuilder
.create()
.withNodeIdentifier(
- new YangInstanceIdentifier.NodeIdentifier(TEST_QNAME))
+ new YangInstanceIdentifier.NodeIdentifier(TEST_QNAME))
.withChild(myBits.build())
.withChild(ImmutableNodes.leafNode(DESC_QNAME, DESC))
- .withChild(ImmutableNodes.leafNode(POINTER_QNAME, "pointer"))
+ .withChild(ImmutableNodes.leafNode(POINTER_QNAME, ENABLED))
+ .withChild(ImmutableNodes.leafNode(POINTER_QNAME, SHORT_ID))
+ .withChild(ImmutableNodes.leafNode(POINTER_QNAME, BYTE_ID))
.withChild(
- ImmutableNodes.leafNode(SOME_REF_QNAME, YangInstanceIdentifier
- .builder().build()))
+ ImmutableNodes.leafNode(SOME_REF_QNAME, GRAND_CHILD_1_PATH))
.withChild(ImmutableNodes.leafNode(MYIDENTITY_QNAME, DESC_QNAME))
-
+ .withChild(Builders.unkeyedListBuilder().withNodeIdentifier(new YangInstanceIdentifier.NodeIdentifier(OUTER_LIST_QNAME))
+ .withChild(binaryDataKey).build())
+ .withChild(Builders.orderedMapBuilder()
+ .withNodeIdentifier(new YangInstanceIdentifier.NodeIdentifier(TEST_QNAME)).withChild(mapEntry).build())
+ .withChild(Builders.choiceBuilder().withNodeIdentifier(new YangInstanceIdentifier.NodeIdentifier(TEST_QNAME))
+ .withChild(ImmutableNodes.leafNode(DESC_QNAME, LONG_ID)).build())
// .withChild(augmentationNode)
.withChild(shoes)
.withChild(numbers)
.withChild(switchFeatures)
.withChild(
- mapNodeBuilder(AUGMENTED_LIST_QNAME).withChild(mapEntry).build())
+ mapNodeBuilder(AUGMENTED_LIST_QNAME).withChild(mapEntry).build())
.withChild(
- mapNodeBuilder(OUTER_LIST_QNAME)
- .withChild(mapEntry(OUTER_LIST_QNAME, ID_QNAME, ONE_ID))
- .withChild(BAR_NODE).build());
+ mapNodeBuilder(OUTER_LIST_QNAME)
+ .withChild(mapEntry(OUTER_LIST_QNAME, ID_QNAME, ONE_ID))
+ .withChild(BAR_NODE).build()
+ );
}
public static ContainerNode createTestContainer() {
package org.opendaylight.controller.cluster.datastore;
+import akka.util.Timeout;
+import java.util.concurrent.TimeUnit;
import org.opendaylight.controller.cluster.datastore.config.ConfigurationReader;
import org.opendaylight.controller.cluster.datastore.config.FileConfigurationReader;
import org.opendaylight.controller.cluster.raft.ConfigParams;
import org.opendaylight.controller.cluster.raft.DefaultConfigParamsImpl;
import org.opendaylight.controller.md.sal.dom.store.impl.InMemoryDOMDataStoreConfigProperties;
-import akka.util.Timeout;
import scala.concurrent.duration.Duration;
import scala.concurrent.duration.FiniteDuration;
-import java.util.concurrent.TimeUnit;
-
/**
* Contains contextual data for a data store.
*
private boolean persistent = true;
private ConfigurationReader configurationReader = new FileConfigurationReader();
private int shardIsolatedLeaderCheckIntervalInMillis = shardHeartbeatIntervalInMillis * 10;
+ private int shardSnapshotDataThresholdPercentage = 12;
public Builder shardTransactionIdleTimeout(Duration shardTransactionIdleTimeout) {
this.shardTransactionIdleTimeout = shardTransactionIdleTimeout;
return this;
}
+ public Builder shardSnapshotDataThresholdPercentage(int shardSnapshotDataThresholdPercentage) {
+ this.shardSnapshotDataThresholdPercentage = shardSnapshotDataThresholdPercentage;
+ return this;
+ }
+
+
public Builder shardHeartbeatIntervalInMillis(int shardHeartbeatIntervalInMillis) {
this.shardHeartbeatIntervalInMillis = shardHeartbeatIntervalInMillis;
return this;
return this;
}
+
public DatastoreContext build() {
DefaultConfigParamsImpl raftConfig = new DefaultConfigParamsImpl();
raftConfig.setHeartBeatInterval(new FiniteDuration(shardHeartbeatIntervalInMillis,
TimeUnit.MILLISECONDS));
raftConfig.setJournalRecoveryLogBatchSize(shardJournalRecoveryLogBatchSize);
raftConfig.setSnapshotBatchCount(shardSnapshotBatchCount);
+ raftConfig.setSnapshotDataThresholdPercentage(shardSnapshotDataThresholdPercentage);
raftConfig.setIsolatedLeaderCheckInterval(
new FiniteDuration(shardIsolatedLeaderCheckIntervalInMillis, TimeUnit.MILLISECONDS));
shardMBean.setCommitIndex(getCommitIndex());
shardMBean.setLastApplied(getLastApplied());
+ shardMBean.setDataSize(getRaftActorContext().getReplicatedLog().dataSize());
}
@Override
private QueuedNotificationManagerMXBeanImpl notificationManagerStatsBean;
+ private volatile long dataSize = 0;
+
private final SimpleDateFormat sdf =
new SimpleDateFormat("yyyy-MM-dd HH:mm:ss.SSS");
this.lastCommittedTransactionTime = lastCommittedTransactionTime;
}
+ public void setDataSize(long dataSize){
+ this.dataSize = dataSize;
+ }
+
+ @Override
+ public long getDataSize(){
+ return dataSize;
+ }
+
@Override
public ThreadExecutorStats getDataStoreExecutorStats() {
// FIXME: this particular thing does not work, as it really is DS-specific
int getMaxNotificationMgrListenerQueueSize();
void resetTransactionCounters();
+
+ long getDataSize();
}
}
}
+ typedef percentage {
+ type uint8 {
+ range "0..100";
+ }
+ }
+
grouping data-store-properties {
leaf max-shard-data-change-executor-queue-size {
default 1000;
leaf shard-snapshot-batch-count {
default 20000;
type non-zero-uint32-type;
- description "The minimum number of entries to be present in the in-memory journal log before a snapshot to be taken.";
+ description "The minimum number of entries to be present in the in-memory journal log before a snapshot is to be taken.";
}
+ leaf shard-snapshot-data-threshold-percentage {
+ default 12;
+ type percentage;
+ description "The percentage of Runtime.totalMemory() used by the in-memory journal log before a snapshot is to be taken";
+ }
+
+
leaf shard-hearbeat-interval-in-millis {
default 500;
type heartbeat-interval-type;
package org.opendaylight.controller.cluster.datastore;
+import java.io.File;
+import java.io.FileInputStream;
+import java.io.FileOutputStream;
+import java.io.IOException;
+import java.util.ArrayList;
+import java.util.List;
import org.junit.After;
import org.junit.Assert;
import org.junit.Test;
import org.opendaylight.controller.protobuff.messages.cluster.raft.AppendEntriesMessages;
import org.opendaylight.yangtools.yang.data.impl.schema.ImmutableNodes;
-import java.io.File;
-import java.io.FileInputStream;
-import java.io.FileOutputStream;
-import java.io.IOException;
-import java.util.ArrayList;
-import java.util.List;
-
public class CompositeModificationPayloadTest {
@Override public long getIndex() {
return 1;
}
+
+ @Override
+ public int size() {
+ return getData().size();
+ }
});
AppendEntries appendEntries =
import akka.actor.Props;
import akka.actor.UntypedActor;
import com.typesafe.config.ConfigFactory;
-import org.opendaylight.controller.cluster.raft.protobuff.client.messages.CompositeModificationPayload;
+import java.util.ArrayList;
+import java.util.List;
import org.opendaylight.controller.cluster.datastore.modification.MutableCompositeModification;
import org.opendaylight.controller.cluster.datastore.modification.WriteModification;
import org.opendaylight.controller.cluster.example.messages.KeyValue;
import org.opendaylight.controller.cluster.raft.ReplicatedLogEntry;
import org.opendaylight.controller.cluster.raft.messages.AppendEntries;
+import org.opendaylight.controller.cluster.raft.protobuff.client.messages.CompositeModificationPayload;
import org.opendaylight.controller.cluster.raft.protobuff.client.messages.Payload;
import org.opendaylight.controller.md.cluster.datastore.model.TestModel;
import org.opendaylight.yangtools.yang.data.impl.schema.ImmutableNodes;
-import java.util.ArrayList;
-import java.util.List;
-
public class Client {
private static ActorSystem actorSystem;
@Override public long getIndex() {
return 1;
}
+
+ @Override
+ public int size() {
+ return getData().size();
+ }
});
return new AppendEntries(1, "member-1", 0, 100, modification, 1);
@Override public long getIndex() {
return 1;
}
+
+ @Override
+ public int size() {
+ return getData().size();
+ }
});
return new AppendEntries(1, "member-1", 0, 100, modification, 1);
import akka.cluster.ClusterActorRefProvider;
import akka.event.Logging;
import akka.event.LoggingAdapter;
-import org.opendaylight.controller.cluster.common.actor.AbstractUntypedActorWithMetering;
-import org.opendaylight.controller.remote.rpc.RemoteRpcProviderConfig;
-import org.opendaylight.controller.utils.ConditionalProbe;
-
import java.util.HashMap;
import java.util.Map;
import java.util.Set;
import java.util.concurrent.ConcurrentHashMap;
import java.util.concurrent.ConcurrentMap;
-
-import static org.opendaylight.controller.remote.rpc.registry.gossip.Messages.BucketStoreMessages.GetAllBuckets;
-import static org.opendaylight.controller.remote.rpc.registry.gossip.Messages.BucketStoreMessages.GetAllBucketsReply;
-import static org.opendaylight.controller.remote.rpc.registry.gossip.Messages.BucketStoreMessages.GetBucketVersions;
-import static org.opendaylight.controller.remote.rpc.registry.gossip.Messages.BucketStoreMessages.GetBucketVersionsReply;
-import static org.opendaylight.controller.remote.rpc.registry.gossip.Messages.BucketStoreMessages.GetBucketsByMembers;
-import static org.opendaylight.controller.remote.rpc.registry.gossip.Messages.BucketStoreMessages.GetBucketsByMembersReply;
-import static org.opendaylight.controller.remote.rpc.registry.gossip.Messages.BucketStoreMessages.GetLocalBucket;
-import static org.opendaylight.controller.remote.rpc.registry.gossip.Messages.BucketStoreMessages.GetLocalBucketReply;
-import static org.opendaylight.controller.remote.rpc.registry.gossip.Messages.BucketStoreMessages.UpdateBucket;
-import static org.opendaylight.controller.remote.rpc.registry.gossip.Messages.BucketStoreMessages.UpdateRemoteBuckets;
+import org.opendaylight.controller.cluster.common.actor.AbstractUntypedActorWithMetering;
+import org.opendaylight.controller.remote.rpc.RemoteRpcProviderConfig;
+import org.opendaylight.controller.remote.rpc.registry.gossip.Messages.BucketStoreMessages.GetAllBuckets;
+import org.opendaylight.controller.remote.rpc.registry.gossip.Messages.BucketStoreMessages.GetAllBucketsReply;
+import org.opendaylight.controller.remote.rpc.registry.gossip.Messages.BucketStoreMessages.GetBucketVersions;
+import org.opendaylight.controller.remote.rpc.registry.gossip.Messages.BucketStoreMessages.GetBucketVersionsReply;
+import org.opendaylight.controller.remote.rpc.registry.gossip.Messages.BucketStoreMessages.GetBucketsByMembers;
+import org.opendaylight.controller.remote.rpc.registry.gossip.Messages.BucketStoreMessages.GetBucketsByMembersReply;
+import org.opendaylight.controller.remote.rpc.registry.gossip.Messages.BucketStoreMessages.GetLocalBucket;
+import org.opendaylight.controller.remote.rpc.registry.gossip.Messages.BucketStoreMessages.GetLocalBucketReply;
+import org.opendaylight.controller.remote.rpc.registry.gossip.Messages.BucketStoreMessages.UpdateBucket;
+import org.opendaylight.controller.remote.rpc.registry.gossip.Messages.BucketStoreMessages.UpdateRemoteBuckets;
+import org.opendaylight.controller.utils.ConditionalProbe;
/**
* A store that syncs its data across nodes in the cluster.
ActorRefProvider provider = getContext().provider();
selfAddress = provider.getDefaultAddress();
- if ( provider instanceof ClusterActorRefProvider)
+ if ( provider instanceof ClusterActorRefProvider) {
getContext().actorOf(Props.create(Gossiper.class).withMailbox(config.getMailBoxName()), "gossiper");
+ }
}
}
if (message instanceof ConditionalProbe) {
+ // The ConditionalProbe is only used for unit tests.
log.info("Received probe {} {}", getSelf(), message);
probe = (ConditionalProbe) message;
+ // Send back any message to tell the caller we got the probe.
+ getSender().tell("Got it", getSelf());
} else if (message instanceof UpdateBucket) {
receiveUpdateBucket(((UpdateBucket) message).getBucket());
} else if (message instanceof GetAllBuckets) {
Map<Address, Bucket> buckets = new HashMap<>();
//first add the local bucket if asked
- if (members.contains(selfAddress))
+ if (members.contains(selfAddress)) {
buckets.put(selfAddress, localBucket);
+ }
//then get buckets for requested remote nodes
for (Address address : members){
- if (remoteBuckets.containsKey(address))
+ if (remoteBuckets.containsKey(address)) {
buckets.put(address, remoteBuckets.get(address));
+ }
}
return buckets;
void receiveUpdateRemoteBuckets(Map<Address, Bucket> receivedBuckets){
if (receivedBuckets == null || receivedBuckets.isEmpty())
+ {
return; //nothing to do
+ }
//Remote cant update self's bucket
receivedBuckets.remove(selfAddress);
for (Map.Entry<Address, Bucket> entry : receivedBuckets.entrySet()){
Long localVersion = versions.get(entry.getKey());
- if (localVersion == null) localVersion = -1L;
+ if (localVersion == null) {
+ localVersion = -1L;
+ }
Bucket receivedBucket = entry.getValue();
- if (receivedBucket == null)
+ if (receivedBucket == null) {
continue;
+ }
Long remoteVersion = receivedBucket.getVersion();
- if (remoteVersion == null) remoteVersion = -1L;
+ if (remoteVersion == null) {
+ remoteVersion = -1L;
+ }
//update only if remote version is newer
if ( remoteVersion.longValue() > localVersion.longValue() ) {
package org.opendaylight.controller.remote.rpc.registry;
-
import akka.actor.ActorPath;
import akka.actor.ActorRef;
import akka.actor.ActorSelection;
import akka.actor.ActorSystem;
import akka.actor.ChildActorPath;
import akka.actor.Props;
+import akka.pattern.Patterns;
import akka.testkit.JavaTestKit;
+import akka.util.Timeout;
import com.google.common.base.Predicate;
+import java.net.URI;
+import java.net.URISyntaxException;
+import java.util.ArrayList;
+import java.util.List;
+import java.util.concurrent.TimeUnit;
+import java.util.concurrent.TimeoutException;
+import javax.annotation.Nullable;
import org.junit.After;
import org.junit.AfterClass;
import org.junit.Before;
import org.junit.Test;
import org.opendaylight.controller.remote.rpc.RemoteRpcProviderConfig;
import org.opendaylight.controller.remote.rpc.RouteIdentifierImpl;
+import org.opendaylight.controller.remote.rpc.registry.RpcRegistry.Messages.AddOrUpdateRoutes;
+import org.opendaylight.controller.remote.rpc.registry.RpcRegistry.Messages.RemoveRoutes;
+import org.opendaylight.controller.remote.rpc.registry.RpcRegistry.Messages.SetLocalRouter;
import org.opendaylight.controller.remote.rpc.registry.gossip.Messages;
import org.opendaylight.controller.sal.connector.api.RpcRouter;
import org.opendaylight.controller.utils.ConditionalProbe;
import org.opendaylight.yangtools.yang.common.QName;
+import scala.concurrent.Await;
+import scala.concurrent.Future;
+import scala.concurrent.duration.Duration;
import scala.concurrent.duration.FiniteDuration;
-import javax.annotation.Nullable;
-import java.net.URI;
-import java.net.URISyntaxException;
-import java.util.ArrayList;
-import java.util.List;
-import java.util.concurrent.TimeUnit;
-
-import static org.opendaylight.controller.remote.rpc.registry.RpcRegistry.Messages.AddOrUpdateRoutes;
-import static org.opendaylight.controller.remote.rpc.registry.RpcRegistry.Messages.RemoveRoutes;
-import static org.opendaylight.controller.remote.rpc.registry.RpcRegistry.Messages.SetLocalRouter;
-
public class RpcRegistryTest {
- private static ActorSystem node1;
- private static ActorSystem node2;
- private static ActorSystem node3;
-
- private ActorRef registry1;
- private ActorRef registry2;
- private ActorRef registry3;
-
- @BeforeClass
- public static void setup() throws InterruptedException {
- RemoteRpcProviderConfig config1 = new RemoteRpcProviderConfig.Builder("memberA").build();
- RemoteRpcProviderConfig config2 = new RemoteRpcProviderConfig.Builder("memberB").build();
- RemoteRpcProviderConfig config3 = new RemoteRpcProviderConfig.Builder("memberC").build();
- node1 = ActorSystem.create("opendaylight-rpc", config1.get());
- node2 = ActorSystem.create("opendaylight-rpc", config2.get());
- node3 = ActorSystem.create("opendaylight-rpc", config3.get());
- }
-
- @AfterClass
- public static void teardown() {
- JavaTestKit.shutdownActorSystem(node1);
- JavaTestKit.shutdownActorSystem(node2);
- JavaTestKit.shutdownActorSystem(node3);
- if (node1 != null)
- node1.shutdown();
- if (node2 != null)
- node2.shutdown();
- if (node3 != null)
- node3.shutdown();
-
- }
-
- @Before
- public void createRpcRegistry() throws InterruptedException {
- registry1 = node1.actorOf(Props.create(RpcRegistry.class));
- registry2 = node2.actorOf(Props.create(RpcRegistry.class));
- registry3 = node3.actorOf(Props.create(RpcRegistry.class));
- }
-
- @After
- public void stopRpcRegistry() throws InterruptedException {
- if (registry1 != null)
- node1.stop(registry1);
- if (registry2 != null)
- node2.stop(registry2);
- if (registry3 != null)
- node3.stop(registry3);
- }
-
- /**
- * One node cluster.
- * 1. Register rpc, ensure router can be found
- * 2. Then remove rpc, ensure its deleted
- *
- * @throws URISyntaxException
- * @throws InterruptedException
- */
- @Test
- public void testAddRemoveRpcOnSameNode() throws URISyntaxException, InterruptedException {
-
- final JavaTestKit mockBroker = new JavaTestKit(node1);
-
- final ActorPath bucketStorePath = new ChildActorPath(registry1.path(), "store");
-
- //install probe
- final JavaTestKit probe1 = createProbeForMessage(
- node1, bucketStorePath, Messages.BucketStoreMessages.UpdateBucket.class);
-
- //Add rpc on node 1
- registry1.tell(new SetLocalRouter(mockBroker.getRef()), mockBroker.getRef());
- registry1.tell(getAddRouteMessage(), mockBroker.getRef());
-
- //Bucket store should get an update bucket message. Updated bucket contains added rpc.
- probe1.expectMsgClass(
- FiniteDuration.apply(10, TimeUnit.SECONDS),
- Messages.BucketStoreMessages.UpdateBucket.class);
-
- //Now remove rpc
- registry1.tell(getRemoveRouteMessage(), mockBroker.getRef());
-
- //Bucket store should get an update bucket message. Rpc is removed in the updated bucket
- probe1.expectMsgClass(
- FiniteDuration.apply(10, TimeUnit.SECONDS),
- Messages.BucketStoreMessages.UpdateBucket.class);
-
-
- }
-
-
- /**
- * Three node cluster.
- * 1. Register rpc on 1 node, ensure 2nd node gets updated
- * 2. Remove rpc on 1 node, ensure 2nd node gets updated
- *
- * @throws URISyntaxException
- * @throws InterruptedException
- */
- @Test
- public void testRpcAddRemoveInCluster() throws URISyntaxException, InterruptedException {
-
- final JavaTestKit mockBroker1 = new JavaTestKit(node1);
-
- //install probe on node2's bucket store
- final ActorPath bucketStorePath = new ChildActorPath(registry2.path(), "store");
- final JavaTestKit probe2 = createProbeForMessage(
- node2, bucketStorePath, Messages.BucketStoreMessages.UpdateRemoteBuckets.class);
-
- //Add rpc on node 1
- registry1.tell(new SetLocalRouter(mockBroker1.getRef()), mockBroker1.getRef());
- registry1.tell(getAddRouteMessage(), mockBroker1.getRef());
-
- //Bucket store on node2 should get a message to update its local copy of remote buckets
- probe2.expectMsgClass(
- FiniteDuration.apply(10, TimeUnit.SECONDS),
- Messages.BucketStoreMessages.UpdateRemoteBuckets.class);
-
- //Now remove
- registry1.tell(getRemoveRouteMessage(), mockBroker1.getRef());
-
- //Bucket store on node2 should get a message to update its local copy of remote buckets
- probe2.expectMsgClass(
- FiniteDuration.apply(10, TimeUnit.SECONDS),
- Messages.BucketStoreMessages.UpdateRemoteBuckets.class);
-
- }
-
- /**
- * Three node cluster.
- * Register rpc on 2 nodes. Ensure 3rd gets updated.
- *
- * @throws Exception
- */
- @Test
- public void testRpcAddedOnMultiNodes() throws Exception {
-
- final JavaTestKit mockBroker1 = new JavaTestKit(node1);
- final JavaTestKit mockBroker2 = new JavaTestKit(node2);
- final JavaTestKit mockBroker3 = new JavaTestKit(node3);
-
- registry3.tell(new SetLocalRouter(mockBroker3.getRef()), mockBroker3.getRef());
-
- //install probe on node 3
- final ActorPath bucketStorePath = new ChildActorPath(registry3.path(), "store");
- final JavaTestKit probe3 = createProbeForMessage(
- node3, bucketStorePath, Messages.BucketStoreMessages.UpdateRemoteBuckets.class);
-
-
- //Add rpc on node 1
- registry1.tell(new SetLocalRouter(mockBroker1.getRef()), mockBroker1.getRef());
- registry1.tell(getAddRouteMessage(), mockBroker1.getRef());
-
- probe3.expectMsgClass(
- FiniteDuration.apply(10, TimeUnit.SECONDS),
- Messages.BucketStoreMessages.UpdateRemoteBuckets.class);
-
+ private static ActorSystem node1;
+ private static ActorSystem node2;
+ private static ActorSystem node3;
+
+ private ActorRef registry1;
+ private ActorRef registry2;
+ private ActorRef registry3;
+
+ @BeforeClass
+ public static void staticSetup() throws InterruptedException {
+ RemoteRpcProviderConfig config1 = new RemoteRpcProviderConfig.Builder("memberA").build();
+ RemoteRpcProviderConfig config2 = new RemoteRpcProviderConfig.Builder("memberB").build();
+ RemoteRpcProviderConfig config3 = new RemoteRpcProviderConfig.Builder("memberC").build();
+ node1 = ActorSystem.create("opendaylight-rpc", config1.get());
+ node2 = ActorSystem.create("opendaylight-rpc", config2.get());
+ node3 = ActorSystem.create("opendaylight-rpc", config3.get());
+ }
+
+ @AfterClass
+ public static void staticTeardown() {
+ JavaTestKit.shutdownActorSystem(node1);
+ JavaTestKit.shutdownActorSystem(node2);
+ JavaTestKit.shutdownActorSystem(node3);
+ }
+
+ @Before
+ public void setup() {
+ registry1 = node1.actorOf(Props.create(RpcRegistry.class));
+ registry2 = node2.actorOf(Props.create(RpcRegistry.class));
+ registry3 = node3.actorOf(Props.create(RpcRegistry.class));
+ }
+
+ @After
+ public void teardown() {
+ if (registry1 != null) {
+ node1.stop(registry1);
+ }
+ if (registry2 != null) {
+ node2.stop(registry2);
+ }
+ if (registry3 != null) {
+ node3.stop(registry3);
+ }
+ }
+
+ /**
+ * One node cluster. 1. Register rpc, ensure router can be found 2. Then remove rpc, ensure its
+ * deleted
+ *
+ * @throws URISyntaxException
+ * @throws InterruptedException
+ */
+ @Test
+ public void testAddRemoveRpcOnSameNode() throws Exception {
+
+ System.out.println("testAddRemoveRpcOnSameNode starting");
+
+ final JavaTestKit mockBroker = new JavaTestKit(node1);
+
+ final ActorPath bucketStorePath = new ChildActorPath(registry1.path(), "store");
+
+ // Add rpc on node 1
+ registry1.tell(new SetLocalRouter(mockBroker.getRef()), mockBroker.getRef());
+
+ // install probe
+ final JavaTestKit probe1 = createProbeForMessage(node1, bucketStorePath,
+ Messages.BucketStoreMessages.UpdateBucket.class);
+
+ registry1.tell(getAddRouteMessage(), mockBroker.getRef());
+
+ // Bucket store should get an update bucket message. Updated bucket contains added rpc.
+ probe1.expectMsgClass(FiniteDuration.apply(10, TimeUnit.SECONDS),
+ Messages.BucketStoreMessages.UpdateBucket.class);
+
+ // Now remove rpc
+ registry1.tell(getRemoveRouteMessage(), mockBroker.getRef());
+
+ // Bucket store should get an update bucket message. Rpc is removed in the updated bucket
+ probe1.expectMsgClass(FiniteDuration.apply(10, TimeUnit.SECONDS),
+ Messages.BucketStoreMessages.UpdateBucket.class);
+
+ System.out.println("testAddRemoveRpcOnSameNode ending");
+
+ }
+
+ /**
+ * Three node cluster. 1. Register rpc on 1 node, ensure 2nd node gets updated 2. Remove rpc on
+ * 1 node, ensure 2nd node gets updated
+ *
+ * @throws URISyntaxException
+ * @throws InterruptedException
+ */
+ @Test
+ public void testRpcAddRemoveInCluster() throws Exception {
+
+ System.out.println("testRpcAddRemoveInCluster starting");
+
+ final JavaTestKit mockBroker1 = new JavaTestKit(node1);
+
+ // install probe on node2's bucket store
+ final ActorPath bucketStorePath = new ChildActorPath(registry2.path(), "store");
+ final JavaTestKit probe2 = createProbeForMessage(node2, bucketStorePath,
+ Messages.BucketStoreMessages.UpdateRemoteBuckets.class);
+
+ // Add rpc on node 1
+ registry1.tell(new SetLocalRouter(mockBroker1.getRef()), mockBroker1.getRef());
+ registry1.tell(getAddRouteMessage(), mockBroker1.getRef());
+
+ // Bucket store on node2 should get a message to update its local copy of remote buckets
+ probe2.expectMsgClass(FiniteDuration.apply(10, TimeUnit.SECONDS),
+ Messages.BucketStoreMessages.UpdateRemoteBuckets.class);
+
+ // Now remove
+ registry1.tell(getRemoveRouteMessage(), mockBroker1.getRef());
+
+ // Bucket store on node2 should get a message to update its local copy of remote buckets
+ probe2.expectMsgClass(FiniteDuration.apply(10, TimeUnit.SECONDS),
+ Messages.BucketStoreMessages.UpdateRemoteBuckets.class);
+
+ System.out.println("testRpcAddRemoveInCluster ending");
+ }
+
+ /**
+ * Three node cluster. Register rpc on 2 nodes. Ensure 3rd gets updated.
+ *
+ * @throws Exception
+ */
+ @Test
+ public void testRpcAddedOnMultiNodes() throws Exception {
+
+ final JavaTestKit mockBroker1 = new JavaTestKit(node1);
+ final JavaTestKit mockBroker2 = new JavaTestKit(node2);
+ final JavaTestKit mockBroker3 = new JavaTestKit(node3);
+
+ registry3.tell(new SetLocalRouter(mockBroker3.getRef()), mockBroker3.getRef());
+
+ // install probe on node 3
+ final ActorPath bucketStorePath = new ChildActorPath(registry3.path(), "store");
+ final JavaTestKit probe3 = createProbeForMessage(node3, bucketStorePath,
+ Messages.BucketStoreMessages.UpdateRemoteBuckets.class);
+
+ // Add rpc on node 1
+ registry1.tell(new SetLocalRouter(mockBroker1.getRef()), mockBroker1.getRef());
+ registry1.tell(getAddRouteMessage(), mockBroker1.getRef());
- //Add same rpc on node 2
- registry2.tell(new SetLocalRouter(mockBroker2.getRef()), mockBroker2.getRef());
- registry2.tell(getAddRouteMessage(), mockBroker2.getRef());
+ probe3.expectMsgClass(FiniteDuration.apply(10, TimeUnit.SECONDS),
+ Messages.BucketStoreMessages.UpdateRemoteBuckets.class);
- probe3.expectMsgClass(
- FiniteDuration.apply(10, TimeUnit.SECONDS),
- Messages.BucketStoreMessages.UpdateRemoteBuckets.class);
- }
-
- private JavaTestKit createProbeForMessage(ActorSystem node, ActorPath subjectPath, final Class<?> clazz) {
- final JavaTestKit probe = new JavaTestKit(node);
+ // Add same rpc on node 2
+ registry2.tell(new SetLocalRouter(mockBroker2.getRef()), mockBroker2.getRef());
+ registry2.tell(getAddRouteMessage(), mockBroker2.getRef());
- ConditionalProbe conditionalProbe =
- new ConditionalProbe(probe.getRef(), new Predicate<Object>() {
- @Override
- public boolean apply(@Nullable Object input) {
- if (input != null)
- return clazz.equals(input.getClass());
- else
- return false;
- }
- });
-
- ActorSelection subject = node.actorSelection(subjectPath);
- subject.tell(conditionalProbe, ActorRef.noSender());
-
- return probe;
+ probe3.expectMsgClass(FiniteDuration.apply(10, TimeUnit.SECONDS),
+ Messages.BucketStoreMessages.UpdateRemoteBuckets.class);
+ }
- }
+ private JavaTestKit createProbeForMessage(ActorSystem node, ActorPath subjectPath, final Class<?> clazz)
+ throws Exception {
+ final JavaTestKit probe = new JavaTestKit(node);
- private AddOrUpdateRoutes getAddRouteMessage() throws URISyntaxException {
- return new AddOrUpdateRoutes(createRouteIds());
- }
-
- private RemoveRoutes getRemoveRouteMessage() throws URISyntaxException {
- return new RemoveRoutes(createRouteIds());
- }
+ ConditionalProbe conditionalProbe = new ConditionalProbe(probe.getRef(), new Predicate<Object>() {
+ @Override
+ public boolean apply(@Nullable Object input) {
+ if (input != null) {
+ return clazz.equals(input.getClass());
+ } else {
+ return false;
+ }
+ }
+ });
- private List<RpcRouter.RouteIdentifier<?, ?, ?>> createRouteIds() throws URISyntaxException {
- QName type = new QName(new URI("/mockrpc"), "mockrpc");
- List<RpcRouter.RouteIdentifier<?, ?, ?>> routeIds = new ArrayList<>();
- routeIds.add(new RouteIdentifierImpl(null, type, null));
- return routeIds;
- }
+ FiniteDuration duration = Duration.create(3, TimeUnit.SECONDS);
+ Timeout timeout = new Timeout(duration);
+ int maxTries = 30;
+ int i = 0;
+ while(true) {
+ ActorSelection subject = node.actorSelection(subjectPath);
+ Future<Object> future = Patterns.ask(subject, conditionalProbe, timeout);
+
+ try {
+ Await.ready(future, duration);
+ break;
+ } catch (TimeoutException | InterruptedException e) {
+ if(++i > maxTries) {
+ throw e;
+ }
+ }
+ }
+
+ return probe;
+
+ }
+
+ private AddOrUpdateRoutes getAddRouteMessage() throws URISyntaxException {
+ return new AddOrUpdateRoutes(createRouteIds());
+ }
+
+ private RemoveRoutes getRemoveRouteMessage() throws URISyntaxException {
+ return new RemoveRoutes(createRouteIds());
+ }
+
+ private List<RpcRouter.RouteIdentifier<?, ?, ?>> createRouteIds() throws URISyntaxException {
+ QName type = new QName(new URI("/mockrpc"), "mockrpc");
+ List<RpcRouter.RouteIdentifier<?, ?, ?>> routeIds = new ArrayList<>();
+ routeIds.add(new RouteIdentifierImpl(null, type, null));
+ return routeIds;
+ }
}
--- /dev/null
+<?xml version="1.0" encoding="UTF-8"?>
+<!--
+ 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
+-->
+<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
+
+ <modelVersion>4.0.0</modelVersion>
+ <parent>
+ <groupId>org.opendaylight.controller</groupId>
+ <artifactId>sal-parent</artifactId>
+ <version>1.2.0-SNAPSHOT</version>
+ </parent>
+
+ <groupId>org.opendaylight.controller.md</groupId>
+ <artifactId>statistics-manager-config</artifactId>
+ <description>Configuration files for statistics manager</description>
+ <packaging>jar</packaging>
+
+ <build>
+ <plugins>
+ <plugin>
+ <groupId>org.codehaus.mojo</groupId>
+ <artifactId>build-helper-maven-plugin</artifactId>
+ <executions>
+ <execution>
+ <id>attach-artifacts</id>
+ <goals>
+ <goal>attach-artifact</goal>
+ </goals>
+ <phase>package</phase>
+ <configuration>
+ <artifacts>
+ <artifact>
+ <file>${project.build.directory}/classes/initial/30-statistics-manager.xml</file>
+ <type>xml</type>
+ <classifier>config</classifier>
+ </artifact>
+ </artifacts>
+ </configuration>
+ </execution>
+ </executions>
+ </plugin>
+ </plugins>
+ </build>
+</project>
--- /dev/null
+<?xml version="1.0" encoding="UTF-8"?>
+<!-- vi: set et smarttab sw=4 tabstop=4: -->
+<!--
+ 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
+-->
+<snapshot>
+ <configuration>
+ <data xmlns="urn:ietf:params:xml:ns:netconf:base:1.0">
+ <modules xmlns="urn:opendaylight:params:xml:ns:yang:controller:config">
+ <module>
+ <type xmlns:statsmanager="urn:opendaylight:params:xml:ns:yang:controller:md:sal:statistics-manager">
+ statsmanager:statistics-manager
+ </type>
+ <name>statistics-manager</name>
+
+ <rpc-registry>
+ <type xmlns:binding="urn:opendaylight:params:xml:ns:yang:controller:md:sal:binding">binding:binding-rpc-registry</type>
+ <name>binding-rpc-broker</name>
+ </rpc-registry>
+
+ <data-broker>
+ <type xmlns:binding="urn:opendaylight:params:xml:ns:yang:controller:md:sal:binding">binding:binding-async-data-broker</type>
+ <name>binding-data-broker</name>
+ </data-broker>
+
+ <notification-service>
+ <type xmlns:binding="urn:opendaylight:params:xml:ns:yang:controller:md:sal:binding">
+ binding:binding-notification-service
+ </type>
+ <name>binding-notification-broker</name>
+ </notification-service>
+
+ <statistics-manager-settings>
+ <min-request-net-monitor-interval>3000</min-request-net-monitor-interval>
+ <max-nodes-for-collector>16</max-nodes-for-collector>
+ </statistics-manager-settings>
+
+ </module>
+ </modules>
+ </data>
+ </configuration>
+
+ <required-capabilities>
+ <capability>urn:opendaylight:params:xml:ns:yang:controller:md:sal:statistics-manager?module=statistics-manager&revision=2014-09-25</capability>
+ </required-capabilities>
+
+</snapshot>
+
<artifactId>org.osgi.core</artifactId>
<scope>provided</scope>
</dependency>
+ <dependency>
+ <groupId>org.opendaylight.controller</groupId>
+ <artifactId>sal-binding-config</artifactId>
+ </dependency>
+ <dependency>
+ <groupId>org.opendaylight.controller</groupId>
+ <artifactId>config-api</artifactId>
+ </dependency>
<dependency>
<groupId>org.slf4j</groupId>
<artifactId>slf4j-log4j12</artifactId>
<build>
<plugins>
- <plugin>
- <groupId>org.apache.felix</groupId>
- <artifactId>maven-bundle-plugin</artifactId>
- <configuration>
- <instructions>
- <Bundle-Activator>org.opendaylight.controller.md.statistics.manager.StatisticsManagerActivator</Bundle-Activator>
- </instructions>
- </configuration>
- </plugin>
+ <plugin>
+ <groupId>org.apache.felix</groupId>
+ <artifactId>maven-bundle-plugin</artifactId>
+ <configuration>
+ <instructions>
+ <Import-Package>*</Import-Package>
+ </instructions>
+ </configuration>
+ </plugin>
+ <plugin>
+ <groupId>org.opendaylight.yangtools</groupId>
+ <artifactId>yang-maven-plugin</artifactId>
+ <executions>
+ <execution>
+ <id>config</id>
+ <goals>
+ <goal>generate-sources</goal>
+ </goals>
+ <configuration>
+ <codeGenerators>
+ <generator>
+ <codeGeneratorClass>org.opendaylight.controller.config.yangjmxgenerator.plugin.JMXGenerator</codeGeneratorClass>
+ <outputBaseDir>${jmxGeneratorPath}</outputBaseDir>
+ <additionalConfiguration>
+ <namespaceToPackage1>urn:opendaylight:params:xml:ns:yang:controller==org.opendaylight.controller.config.yang</namespaceToPackage1>
+ </additionalConfiguration>
+ </generator>
+ <generator>
+ <codeGeneratorClass>org.opendaylight.yangtools.maven.sal.api.gen.plugin.CodeGeneratorImpl</codeGeneratorClass>
+ <outputBaseDir>${salGeneratorPath}</outputBaseDir>
+ </generator>
+ </codeGenerators>
+ <inspectDependencies>true</inspectDependencies>
+ </configuration>
+ </execution>
+ </executions>
+ </plugin>
</plugins>
</build>
<scm>
--- /dev/null
+package org.opendaylight.controller.config.yang.md.sal.statistics_manager;
+
+import org.opendaylight.controller.md.statistics.manager.StatisticsManager;
+import org.opendaylight.controller.md.statistics.manager.impl.StatisticsManagerConfig;
+import org.opendaylight.controller.md.statistics.manager.impl.StatisticsManagerImpl;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+public class StatisticsManagerModule extends org.opendaylight.controller.config.yang.md.sal.statistics_manager.AbstractStatisticsManagerModule {
+ private final static Logger LOG = LoggerFactory.getLogger(StatisticsManagerModule.class);
+
+ private final static int MAX_NODES_FOR_COLLECTOR_DEFAULT = 16;
+ private final static int MIN_REQUEST_NET_MONITOR_INTERVAL_DEFAULT = 3000;
+
+ private StatisticsManager statisticsManagerProvider;
+
+ public StatisticsManagerModule(final org.opendaylight.controller.config.api.ModuleIdentifier identifier, final org.opendaylight.controller.config.api.DependencyResolver dependencyResolver) {
+ super(identifier, dependencyResolver);
+ }
+
+ public StatisticsManagerModule(final org.opendaylight.controller.config.api.ModuleIdentifier identifier, final org.opendaylight.controller.config.api.DependencyResolver dependencyResolver, final StatisticsManagerModule oldModule, final java.lang.AutoCloseable oldInstance) {
+ super(identifier, dependencyResolver, oldModule, oldInstance);
+ }
+
+ @Override
+ public void customValidation() {
+ // add custom validation form module attributes here.
+ }
+
+ @Override
+ public java.lang.AutoCloseable createInstance() {
+ LOG.info("StatisticsManager module initialization.");
+ final StatisticsManagerConfig config = createConfig();
+ statisticsManagerProvider = new StatisticsManagerImpl(getDataBrokerDependency(), config);
+ statisticsManagerProvider.start(getNotificationServiceDependency(), getRpcRegistryDependency());
+ LOG.info("StatisticsManager started successfully.");
+ return new AutoCloseable() {
+ @Override
+ public void close() throws Exception {
+ try {
+ statisticsManagerProvider.close();
+ }
+ catch (final Exception e) {
+ LOG.error("Unexpected error by stopping StatisticsManager module", e);
+ }
+ LOG.info("StatisticsManager module stopped.");
+ }
+ };
+ }
+
+ public StatisticsManagerConfig createConfig() {
+ final StatisticsManagerConfig.StatisticsManagerConfigBuilder builder = StatisticsManagerConfig.builder();
+ if (getStatisticsManagerSettings() != null && getStatisticsManagerSettings().getMaxNodesForCollector() != null) {
+ builder.setMaxNodesForCollector(getStatisticsManagerSettings().getMaxNodesForCollector());
+ } else {
+ LOG.warn("Load the xml ConfigSubsystem input value fail! MaxNodesForCollector value is set to {} ",
+ MAX_NODES_FOR_COLLECTOR_DEFAULT);
+ builder.setMaxNodesForCollector(MAX_NODES_FOR_COLLECTOR_DEFAULT);
+ }
+ if (getStatisticsManagerSettings() != null &&
+ getStatisticsManagerSettings().getMinRequestNetMonitorInterval() != null) {
+ builder.setMinRequestNetMonitorInterval(getStatisticsManagerSettings().getMinRequestNetMonitorInterval());
+ } else {
+ LOG.warn("Load the xml CofnigSubsystem input value fail! MinRequestNetMonitorInterval value is set to {} ",
+ MIN_REQUEST_NET_MONITOR_INTERVAL_DEFAULT);
+ builder.setMinRequestNetMonitorInterval(MIN_REQUEST_NET_MONITOR_INTERVAL_DEFAULT);
+ }
+ return builder.build();
+ }
+
+}
--- /dev/null
+/*
+* Generated file
+*
+* Generated from: yang module name: statistics-manager yang module local name: statistics-manager
+* Generated by: org.opendaylight.controller.config.yangjmxgenerator.plugin.JMXGenerator
+* Generated at: Tue Oct 07 14:09:47 CEST 2014
+*
+* Do not modify this file unless it is present under src/main directory
+*/
+package org.opendaylight.controller.config.yang.md.sal.statistics_manager;
+public class StatisticsManagerModuleFactory extends org.opendaylight.controller.config.yang.md.sal.statistics_manager.AbstractStatisticsManagerModuleFactory {
+
+}
import org.opendaylight.controller.md.sal.binding.api.ReadWriteTransaction;
import org.opendaylight.controller.md.sal.common.api.data.TransactionChainListener;
import org.opendaylight.controller.md.statistics.manager.StatPermCollector.StatCapabTypes;
+import org.opendaylight.controller.md.statistics.manager.impl.StatisticsManagerConfig;
import org.opendaylight.controller.sal.binding.api.NotificationProviderService;
import org.opendaylight.controller.sal.binding.api.RpcConsumerRegistry;
import org.opendaylight.yang.gen.v1.urn.opendaylight.flow.inventory.rev130819.meters.Meter;
* @param minReqNetMonitInt
*/
void start(final NotificationProviderService notifService,
- final RpcConsumerRegistry rpcRegistry, final long minReqNetMonitInt);
+ final RpcConsumerRegistry rpcRegistry);
/**
* Method provides read/write DataStore functionality cross applyOperation
*/
StatNotifyCommiter<OpendaylightPortStatisticsListener> getPortNotifyCommit();
+ StatisticsManagerConfig getConfiguration();
+
}
+++ /dev/null
-/*
- * Copyright IBM Corporation, 2013. 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.md.statistics.manager;
-
-import org.opendaylight.controller.md.sal.binding.api.DataBroker;
-import org.opendaylight.controller.md.statistics.manager.impl.StatisticsManagerImpl;
-import org.opendaylight.controller.sal.binding.api.AbstractBindingAwareProvider;
-import org.opendaylight.controller.sal.binding.api.BindingAwareBroker.ProviderContext;
-import org.opendaylight.controller.sal.binding.api.NotificationProviderService;
-import org.osgi.framework.BundleContext;
-import org.slf4j.Logger;
-import org.slf4j.LoggerFactory;
-
-import com.google.common.annotations.VisibleForTesting;
-
-/**
- * Statistics Manager Activator
- *
- * OSGi bundle activator
- *
- */
-public class StatisticsManagerActivator extends AbstractBindingAwareProvider {
-
- private final static Logger LOG = LoggerFactory.getLogger(StatisticsManagerActivator.class);
-
- /* TODO move it to ConfigSubsystem */
- private static final long DEFAULT_MIN_REQUEST_NET_MONITOR_INTERVAL = 3000L;
- private static final int MAX_NODES_FOR_COLLECTOR = 16;
-
- private StatisticsManager statsProvider;
-
- @Override
- public void onSessionInitiated(final ProviderContext session) {
- LOG.info("StatisticsManagerActivator initialization.");
- try {
- final DataBroker dataBroker = session.getSALService(DataBroker.class);
- final NotificationProviderService notifService =
- session.getSALService(NotificationProviderService.class);
- statsProvider = new StatisticsManagerImpl(dataBroker, MAX_NODES_FOR_COLLECTOR);
- statsProvider.start(notifService, session, DEFAULT_MIN_REQUEST_NET_MONITOR_INTERVAL);
- LOG.info("StatisticsManagerActivator started successfully.");
- }
- catch (final Exception e) {
- LOG.error("Unexpected error by initialization of StatisticsManagerActivator", e);
- stopImpl(null);
- }
- }
-
- @VisibleForTesting
- StatisticsManager getStatisticManager() {
- return statsProvider;
- }
-
- @Override
- protected void stopImpl(final BundleContext context) {
- if (statsProvider != null) {
- try {
- statsProvider.close();
- }
- catch (final Exception e) {
- LOG.error("Unexpected error by stopping StatisticsManagerActivator", e);
- }
- statsProvider = null;
- }
- LOG.info("StatisticsManagerActivator stoped.");
- }
-}
--- /dev/null
+package org.opendaylight.controller.md.statistics.manager.impl;
+
+public class StatisticsManagerConfig {
+ private final int maxNodesForCollector;
+ private final int minRequestNetMonitorInterval;
+
+ private StatisticsManagerConfig(StatisticsManagerConfigBuilder builder) {
+ this.maxNodesForCollector = builder.getMaxNodesForCollector();
+ this.minRequestNetMonitorInterval = builder.getMinRequestNetMonitorInterval();
+ }
+
+ public int getMaxNodesForCollector() {
+ return maxNodesForCollector;
+ }
+
+ public int getMinRequestNetMonitorInterval() {
+ return minRequestNetMonitorInterval;
+ }
+
+ public static StatisticsManagerConfigBuilder builder() {
+ return new StatisticsManagerConfigBuilder();
+ }
+
+ public static class StatisticsManagerConfigBuilder {
+ private int maxNodesForCollector;
+ private int minRequestNetMonitorInterval;
+
+ public int getMaxNodesForCollector() {
+ return maxNodesForCollector;
+ }
+
+ public void setMaxNodesForCollector(int maxNodesForCollector) {
+ this.maxNodesForCollector = maxNodesForCollector;
+ }
+
+ public int getMinRequestNetMonitorInterval() {
+ return minRequestNetMonitorInterval;
+ }
+
+ public void setMinRequestNetMonitorInterval(int minRequestNetMonitorInterval) {
+ this.minRequestNetMonitorInterval = minRequestNetMonitorInterval;
+ }
+
+ public StatisticsManagerConfig build() {
+ return new StatisticsManagerConfig(this);
+ }
+ }
+}
package org.opendaylight.controller.md.statistics.manager.impl;
-import java.util.ArrayList;
-import java.util.Collections;
-import java.util.List;
-import java.util.concurrent.BlockingQueue;
-import java.util.concurrent.ExecutorService;
-import java.util.concurrent.Executors;
-import java.util.concurrent.LinkedBlockingDeque;
-import java.util.concurrent.ThreadFactory;
-
+import com.google.common.base.Preconditions;
+import com.google.common.util.concurrent.ThreadFactoryBuilder;
import org.opendaylight.controller.md.sal.binding.api.BindingTransactionChain;
import org.opendaylight.controller.md.sal.binding.api.DataBroker;
import org.opendaylight.controller.md.sal.binding.api.ReadWriteTransaction;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
-import com.google.common.base.Preconditions;
-import com.google.common.util.concurrent.ThreadFactoryBuilder;
+import java.util.ArrayList;
+import java.util.Collections;
+import java.util.List;
+import java.util.concurrent.BlockingQueue;
+import java.util.concurrent.ExecutorService;
+import java.util.concurrent.Executors;
+import java.util.concurrent.LinkedBlockingDeque;
+import java.util.concurrent.ThreadFactory;
/**
* statistics-manager
private final BlockingQueue<StatDataStoreOperation> dataStoreOperQueue = new LinkedBlockingDeque<>(QUEUE_DEPTH);
private final DataBroker dataBroker;
- private final int maxNodesForCollectors;
- private long minReqNetMonitInt;
private final ExecutorService statRpcMsgManagerExecutor;
private final ExecutorService statDataStoreOperationServ;
private StatRpcMsgManager rpcMsgManager;
private StatNotifyCommiter<OpendaylightFlowTableStatisticsListener> tableNotifCommiter;
private StatNotifyCommiter<OpendaylightPortStatisticsListener> portNotifyCommiter;
- public StatisticsManagerImpl (final DataBroker dataBroker, final int maxNodesForCollector) {
+ private final StatisticsManagerConfig statManagerConfig;
+
+ public StatisticsManagerImpl (final DataBroker dataBroker, StatisticsManagerConfig statManagerconfig) {
+ this.statManagerConfig = Preconditions.checkNotNull(statManagerconfig);
this.dataBroker = Preconditions.checkNotNull(dataBroker, "DataBroker can not be null!");
ThreadFactory threadFact;
threadFact = new ThreadFactoryBuilder().setNameFormat("odl-stat-rpc-oper-thread-%d").build();
statRpcMsgManagerExecutor = Executors.newSingleThreadExecutor(threadFact);
threadFact = new ThreadFactoryBuilder().setNameFormat("odl-stat-ds-oper-thread-%d").build();
statDataStoreOperationServ = Executors.newSingleThreadExecutor(threadFact);
- maxNodesForCollectors = maxNodesForCollector;
txChain = dataBroker.createTransactionChain(this);
}
@Override
public void start(final NotificationProviderService notifService,
- final RpcConsumerRegistry rpcRegistry, final long minReqNetMonitInt) {
+ final RpcConsumerRegistry rpcRegistry) {
Preconditions.checkArgument(rpcRegistry != null, "RpcConsumerRegistry can not be null !");
- this.minReqNetMonitInt = minReqNetMonitInt;
- rpcMsgManager = new StatRpcMsgManagerImpl(this, rpcRegistry, minReqNetMonitInt);
+ rpcMsgManager = new StatRpcMsgManagerImpl(this, rpcRegistry, statManagerConfig.getMinRequestNetMonitorInterval());
statCollectors = Collections.emptyList();
nodeRegistrator = new StatNodeRegistrationImpl(this, dataBroker, notifService);
flowListeningCommiter = new StatListenCommitFlow(this, dataBroker, notifService);
}
}
final StatPermCollectorImpl newCollector = new StatPermCollectorImpl(this,
- minReqNetMonitInt, statCollectors.size() + 1, maxNodesForCollectors);
+ statManagerConfig.getMinRequestNetMonitorInterval(), statCollectors.size() + 1,
+ statManagerConfig.getMaxNodesForCollector());
final List<StatPermCollector> statCollectorsNew = new ArrayList<>(statCollectors);
newCollector.connectedNodeRegistration(nodeIdent, statTypes, nrOfSwitchTables);
statCollectorsNew.add(newCollector);
public StatNotifyCommiter<OpendaylightPortStatisticsListener> getPortNotifyCommit() {
return portNotifyCommiter;
}
+
+ @Override
+ public StatisticsManagerConfig getConfiguration() {
+ return statManagerConfig;
+ }
}
--- /dev/null
+module statistics-manager {
+
+ yang-version 1;
+ namespace "urn:opendaylight:params:xml:ns:yang:controller:md:sal:statistics-manager";
+ prefix "statistics-manager";
+
+ import config { prefix config; revision-date 2013-04-05; }
+ import opendaylight-md-sal-binding { prefix mdsal; revision-date 2013-10-28; }
+
+ description
+ "This module contains the base YANG definitions for
+ statitics-manager implementation.";
+
+ revision "2014-09-25" {
+ description
+ "Initial revision.";
+ }
+
+ identity statistics-manager {
+ base config:module-type;
+ config:java-name-prefix StatisticsManager;
+ }
+
+ augment "/config:modules/config:module/config:configuration" {
+ case statistics-manager {
+ when "/config:modules/config:module/config:type = 'statistics-manager'";
+
+ container rpc-registry {
+ uses config:service-ref {
+ refine type {
+ mandatory true;
+ config:required-identity mdsal:binding-rpc-registry;
+ }
+ }
+ }
+
+ container notification-service {
+ uses config:service-ref {
+ refine type {
+ mandatory true;
+ config:required-identity mdsal:binding-notification-service;
+ }
+ }
+ }
+
+ container data-broker {
+ uses config:service-ref {
+ refine type {
+ mandatory false;
+ config:required-identity mdsal:binding-async-data-broker;
+ }
+ }
+ }
+
+ container statistics-manager-settings {
+ leaf min-request-net-monitor-interval {
+ type int32;
+ }
+ leaf max-nodes-for-collector {
+ type int32;
+ }
+ }
+ }
+ }
+
+}
+++ /dev/null
-/**
- * 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.md.statistics.manager;
-
-/**
- * statistics-manager
- * org.opendaylight.controller.md.statistics.manager
- *
- *
- *
- * @author <a href="mailto:vdemcak@cisco.com">Vaclav Demcak</a>
- *
- * Created: Sep 6, 2014
- */
-public class StatisticsManagerProvider {
-
- private final StatisticsManagerActivator activator;
-
- public StatisticsManagerProvider(final StatisticsManagerActivator activator) {
- this.activator = activator;
- }
-
- /**
- * Method provides Initialized {@link StatisticsManager}
- * from {@link StatisticsManagerActivator} for all tests
- * suites;
- *
- * @return
- */
- public StatisticsManager getStatisticsManager() {
- return activator.getStatisticManager();
- }
-}
+++ /dev/null
-package test.mock;
-
-import static org.junit.Assert.assertEquals;
-import static org.junit.Assert.assertFalse;
-import static org.junit.Assert.assertTrue;
-
-import java.util.Collections;
-import java.util.concurrent.ExecutionException;
-
-import org.opendaylight.controller.md.sal.binding.api.DataChangeListener;
-import org.opendaylight.controller.md.sal.binding.api.ReadOnlyTransaction;
-import org.opendaylight.controller.md.sal.binding.api.WriteTransaction;
-import org.opendaylight.controller.md.sal.common.api.data.AsyncDataBroker;
-import org.opendaylight.controller.md.sal.common.api.data.AsyncDataChangeEvent;
-import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType;
-import org.opendaylight.controller.md.sal.common.api.data.ReadFailedException;
-import org.opendaylight.controller.md.statistics.manager.StatisticsManagerActivator;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.flow.inventory.rev130819.FlowCapableNode;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.flow.inventory.rev130819.FlowFeatureCapabilityFlowStats;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.flow.inventory.rev130819.tables.Table;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.flow.inventory.rev130819.tables.TableBuilder;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.flow.inventory.rev130819.tables.TableKey;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.flow.inventory.rev130819.tables.table.Flow;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.flow.statistics.rev130819.FlowStatisticsData;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.inventory.rev130819.Nodes;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.inventory.rev130819.nodes.Node;
-import org.opendaylight.yangtools.yang.binding.DataObject;
-import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
-
-import test.mock.util.StatisticsManagerTest;
-
-import com.google.common.base.Optional;
-
-public class FlowStatisticsTest extends StatisticsManagerTest {
- private final Object waitObject = new Object();
-
-// @Test(timeout = 5000)
- public void addedFlowOnDemandStatsTest() throws ExecutionException, InterruptedException, ReadFailedException {
- final StatisticsManagerActivator activator = new StatisticsManagerActivator();
- activator.onSessionInitiated(providerContext);
-
- addFlowCapableNode(s1Key);
-
- final Flow flow = getFlow();
-
- final InstanceIdentifier<Flow> flowII = InstanceIdentifier.create(Nodes.class).child(Node.class, s1Key)
- .augmentation(FlowCapableNode.class).child(Table.class, new TableKey(flow.getTableId()))
- .child(Flow.class, flow.getKey());
- final InstanceIdentifier<Table> tableII = InstanceIdentifier.create(Nodes.class).child(Node.class, s1Key)
- .augmentation(FlowCapableNode.class).child(Table.class, new TableKey(flow.getTableId()));
- final Table table = new TableBuilder().setKey(new TableKey(flow.getTableId())).setFlow(Collections.<Flow>emptyList()).build();
-
- final WriteTransaction writeTx = getDataBroker().newWriteOnlyTransaction();
- writeTx.put(LogicalDatastoreType.CONFIGURATION, tableII, table);
- writeTx.put(LogicalDatastoreType.CONFIGURATION, flowII, flow);
- writeTx.put(LogicalDatastoreType.OPERATIONAL, tableII, table);
- writeTx.put(LogicalDatastoreType.OPERATIONAL, flowII, flow);
- assertCommit(writeTx.submit());
-
- getDataBroker().registerDataChangeListener(LogicalDatastoreType.OPERATIONAL,
- flowII.augmentation(FlowStatisticsData.class), new ChangeListener(), AsyncDataBroker.DataChangeScope.BASE);
-
- synchronized (waitObject) {
- waitObject.wait();
- }
-
- final ReadOnlyTransaction readTx = getDataBroker().newReadOnlyTransaction();
- final Optional<FlowStatisticsData> flowStatDataOptional = readTx.read(LogicalDatastoreType.OPERATIONAL, flowII.augmentation(FlowStatisticsData.class))
- .checkedGet();
- assertTrue(flowStatDataOptional.isPresent());
- assertEquals(COUNTER_64_TEST_VALUE, flowStatDataOptional.get().getFlowStatistics().getByteCount());
-
- }
-
-// @Test(timeout = 5000)
- public void deletedFlowStatsRemovalTest() throws ExecutionException, InterruptedException, ReadFailedException {
- final StatisticsManagerActivator activator = new StatisticsManagerActivator();
- activator.onSessionInitiated(providerContext);
-
- addFlowCapableNode(s1Key);
-
- final Flow flow = getFlow();
-
- final InstanceIdentifier<Flow> flowII = InstanceIdentifier.create(Nodes.class).child(Node.class, s1Key)
- .augmentation(FlowCapableNode.class).child(Table.class, new TableKey(flow.getTableId()))
- .child(Flow.class, flow.getKey());
- final InstanceIdentifier<Table> tableII = InstanceIdentifier.create(Nodes.class).child(Node.class, s1Key)
- .augmentation(FlowCapableNode.class).child(Table.class, new TableKey(flow.getTableId()));
- final Table table = new TableBuilder().setKey(new TableKey(flow.getTableId())).setFlow(Collections.<Flow>emptyList()).build();
-
- WriteTransaction writeTx = getDataBroker().newWriteOnlyTransaction();
- writeTx.put(LogicalDatastoreType.CONFIGURATION, tableII, table);
- writeTx.put(LogicalDatastoreType.CONFIGURATION, flowII, flow);
- writeTx.put(LogicalDatastoreType.OPERATIONAL, tableII, table);
- writeTx.put(LogicalDatastoreType.OPERATIONAL, flowII, flow);
-
- getDataBroker().registerDataChangeListener(LogicalDatastoreType.OPERATIONAL,
- flowII.augmentation(FlowStatisticsData.class), new ChangeListener(), AsyncDataBroker.DataChangeScope.BASE);
-
- assertCommit(writeTx.submit());
-
- synchronized (waitObject) {
- waitObject.wait();
- }
-
- ReadOnlyTransaction readTx = getDataBroker().newReadOnlyTransaction();
- Optional<Flow> flowStatDataOptional = readTx.read(LogicalDatastoreType.OPERATIONAL, flowII).checkedGet();
- assertTrue(flowStatDataOptional.isPresent());
-// assertEquals(COUNTER_64_TEST_VALUE, flowStatDataOptional.get().getFlowStatistics().getByteCount());
-
- writeTx = getDataBroker().newWriteOnlyTransaction();
- writeTx.delete(LogicalDatastoreType.CONFIGURATION, flowII);
- assertCommit(writeTx.submit());
-
- readTx = getDataBroker().newReadOnlyTransaction();
- flowStatDataOptional = readTx.read(LogicalDatastoreType.OPERATIONAL, flowII).checkedGet();
- assertFalse(flowStatDataOptional.isPresent());
- }
-
-// @Test(timeout = 23000)
- public void getAllStatsWhenNodeIsConnectedTest() throws ExecutionException, InterruptedException, ReadFailedException {
- final StatisticsManagerActivator activator = new StatisticsManagerActivator();
- activator.onSessionInitiated(providerContext);
-
- addFlowCapableNodeWithFeatures(s1Key, false, FlowFeatureCapabilityFlowStats.class);
-
- final Flow flow = getFlow();
-
- final InstanceIdentifier<Table> tableII = InstanceIdentifier.create(Nodes.class).child(Node.class, s1Key)
- .augmentation(FlowCapableNode.class).child(Table.class, new TableKey(flow.getTableId()));
-
- getDataBroker().registerDataChangeListener(LogicalDatastoreType.OPERATIONAL,
- tableII.child(Flow.class), new ChangeListener(), AsyncDataBroker.DataChangeScope.BASE);
-
- synchronized (waitObject) {
- waitObject.wait();
- }
-
- final ReadOnlyTransaction readTx = getDataBroker().newReadOnlyTransaction();
- final Optional<Table> tableOptional = readTx.read(LogicalDatastoreType.OPERATIONAL, InstanceIdentifier.create(Nodes.class)
- .child(Node.class, s1Key).augmentation(FlowCapableNode.class)
- .child(Table.class, new TableKey(flow.getTableId()))).checkedGet();
- assertTrue(tableOptional.isPresent());
- final FlowStatisticsData flowStats = tableOptional.get().getFlow().get(0).getAugmentation(FlowStatisticsData.class);
- assertTrue(flowStats != null);
- assertEquals(COUNTER_64_TEST_VALUE, flowStats.getFlowStatistics().getByteCount());
- }
-
- public class ChangeListener implements DataChangeListener {
-
- @Override
- public void onDataChanged(final AsyncDataChangeEvent<InstanceIdentifier<?>, DataObject> change) {
- synchronized (waitObject) {
- waitObject.notify();
- }
- }
- }
-}
-
+++ /dev/null
-package test.mock;
-
-import static org.junit.Assert.assertEquals;
-import static org.junit.Assert.assertFalse;
-import static org.junit.Assert.assertTrue;
-
-import java.util.concurrent.ExecutionException;
-
-import org.opendaylight.controller.md.sal.binding.api.DataChangeListener;
-import org.opendaylight.controller.md.sal.binding.api.ReadOnlyTransaction;
-import org.opendaylight.controller.md.sal.binding.api.WriteTransaction;
-import org.opendaylight.controller.md.sal.common.api.data.AsyncDataBroker;
-import org.opendaylight.controller.md.sal.common.api.data.AsyncDataChangeEvent;
-import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType;
-import org.opendaylight.controller.md.sal.common.api.data.ReadFailedException;
-import org.opendaylight.controller.md.statistics.manager.StatisticsManagerActivator;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.flow.inventory.rev130819.FlowCapableNode;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.flow.inventory.rev130819.FlowFeatureCapabilityGroupStats;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.group.statistics.rev131111.NodeGroupDescStats;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.group.statistics.rev131111.NodeGroupFeatures;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.group.statistics.rev131111.NodeGroupStatistics;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.group.statistics.rev131111.group.features.GroupFeatures;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.group.types.rev131018.groups.Group;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.inventory.rev130819.Nodes;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.inventory.rev130819.nodes.Node;
-import org.opendaylight.yangtools.yang.binding.DataObject;
-import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
-
-import test.mock.util.StatisticsManagerTest;
-
-import com.google.common.base.Optional;
-
-public class GroupStatisticsTest extends StatisticsManagerTest {
- private final Object waitObject = new Object();
-
-// @Test(timeout = 5000)
- public void addedGroupOnDemandStatsTest() throws ExecutionException, InterruptedException, ReadFailedException {
- final StatisticsManagerActivator activator = new StatisticsManagerActivator();
- activator.onSessionInitiated(providerContext);
-
- addFlowCapableNode(s1Key);
-
- final Group group = getGroup();
-
- final InstanceIdentifier<Group> groupII = InstanceIdentifier.create(Nodes.class).child(Node.class, s1Key)
- .augmentation(FlowCapableNode.class).child(Group.class, group.getKey());
-
- final WriteTransaction writeTx = getDataBroker().newWriteOnlyTransaction();
- writeTx.put(LogicalDatastoreType.CONFIGURATION, groupII, group);
- writeTx.put(LogicalDatastoreType.OPERATIONAL, groupII, group);
- assertCommit(writeTx.submit());
-
- getDataBroker().registerDataChangeListener(LogicalDatastoreType.OPERATIONAL,
- groupII.augmentation(NodeGroupStatistics.class), new ChangeListener(), AsyncDataBroker.DataChangeScope.BASE);
-
- synchronized (waitObject) {
- waitObject.wait();
- }
-
- final ReadOnlyTransaction readTx = getDataBroker().newReadOnlyTransaction();
- final Optional<NodeGroupStatistics> groupOptional = readTx.read(LogicalDatastoreType.OPERATIONAL, groupII.augmentation(NodeGroupStatistics.class)).checkedGet();
- assertTrue(groupOptional.isPresent());
- assertEquals(COUNTER_64_TEST_VALUE, groupOptional.get().getGroupStatistics().getByteCount());
- }
-
-// @Test(timeout = 5000)
- public void deletedGroupStasRemovalTest() throws ExecutionException, InterruptedException, ReadFailedException {
- final StatisticsManagerActivator activator = new StatisticsManagerActivator();
- activator.onSessionInitiated(providerContext);
-
- addFlowCapableNode(s1Key);
-
- final Group group = getGroup();
- final InstanceIdentifier<Group> groupII = InstanceIdentifier.create(Nodes.class).child(Node.class, s1Key)
- .augmentation(FlowCapableNode.class).child(Group.class, group.getKey());
-
- WriteTransaction writeTx = getDataBroker().newWriteOnlyTransaction();
- writeTx.put(LogicalDatastoreType.CONFIGURATION, groupII, group);
- writeTx.put(LogicalDatastoreType.OPERATIONAL, groupII, group);
- assertCommit(writeTx.submit());
-
- getDataBroker().registerDataChangeListener(LogicalDatastoreType.OPERATIONAL,
- groupII.augmentation(NodeGroupStatistics.class), new ChangeListener(), AsyncDataBroker.DataChangeScope.BASE);
-
- synchronized (waitObject) {
- waitObject.wait();
- }
-
- ReadOnlyTransaction readTx = getDataBroker().newReadOnlyTransaction();
- Optional<NodeGroupStatistics> groupOptional = readTx.read(LogicalDatastoreType.OPERATIONAL,
- groupII.augmentation(NodeGroupStatistics.class)).checkedGet();
- assertTrue(groupOptional.isPresent());
- assertEquals(COUNTER_64_TEST_VALUE, groupOptional.get().getGroupStatistics().getByteCount());
-
- writeTx = getDataBroker().newWriteOnlyTransaction();
- writeTx.delete(LogicalDatastoreType.CONFIGURATION, groupII);
- assertCommit(writeTx.submit());
-
- readTx = getDataBroker().newReadOnlyTransaction();
- groupOptional = readTx.read(LogicalDatastoreType.OPERATIONAL,
- groupII.augmentation(NodeGroupStatistics.class)).checkedGet();
- assertFalse(groupOptional.isPresent());
-
- }
-
-// @Test(timeout = 23000)
- public void getAllStatsFromConnectedNodeTest() throws ExecutionException, InterruptedException {
- final StatisticsManagerActivator activator = new StatisticsManagerActivator();
- activator.onSessionInitiated(providerContext);
-
- addFlowCapableNodeWithFeatures(s1Key, false, FlowFeatureCapabilityGroupStats.class);
-
- final InstanceIdentifier<Group> groupII = InstanceIdentifier.create(Nodes.class).child(Node.class, s1Key)
- .augmentation(FlowCapableNode.class).child(Group.class, getGroup().getKey());
- getDataBroker().registerDataChangeListener(LogicalDatastoreType.OPERATIONAL,
- groupII.augmentation(NodeGroupStatistics.class), new ChangeListener(), AsyncDataBroker.DataChangeScope.BASE);
-
- synchronized (waitObject) {
- waitObject.wait();
- }
-
- ReadOnlyTransaction readTx = getDataBroker().newReadOnlyTransaction();
- final Optional<Group> optionalGroup = readTx.read(LogicalDatastoreType.OPERATIONAL, InstanceIdentifier.create(Nodes.class)
- .child(Node.class, s1Key).augmentation(FlowCapableNode.class)
- .child(Group.class, getGroup().getKey())).get();
-
- assertTrue(optionalGroup.isPresent());
- assertTrue(optionalGroup.get().getAugmentation(NodeGroupDescStats.class) != null);
- final NodeGroupStatistics groupStats = optionalGroup.get().getAugmentation(NodeGroupStatistics.class);
- assertTrue(groupStats != null);
- assertEquals(COUNTER_64_TEST_VALUE, groupStats.getGroupStatistics().getByteCount());
-
- readTx = getDataBroker().newReadOnlyTransaction();
- final Optional<GroupFeatures> optionalGroupFeatures = readTx.read(LogicalDatastoreType.OPERATIONAL, InstanceIdentifier.create(Nodes.class)
- .child(Node.class, s1Key).augmentation(NodeGroupFeatures.class).child(GroupFeatures.class)).get();
- assertTrue(optionalGroupFeatures.isPresent());
- assertEquals(1, optionalGroupFeatures.get().getMaxGroups().size());
- assertEquals(MAX_GROUPS_TEST_VALUE, optionalGroupFeatures.get().getMaxGroups().get(0));
- }
-
- private class ChangeListener implements DataChangeListener {
-
- @Override
- public void onDataChanged(final AsyncDataChangeEvent<InstanceIdentifier<?>, DataObject> change) {
- synchronized (waitObject) {
- waitObject.notify();
- }
- }
- }
-}
-
+++ /dev/null
-package test.mock;
-
-import static org.junit.Assert.assertEquals;
-import static org.junit.Assert.assertFalse;
-import static org.junit.Assert.assertTrue;
-
-import java.util.concurrent.ExecutionException;
-
-import org.opendaylight.controller.md.sal.binding.api.DataChangeListener;
-import org.opendaylight.controller.md.sal.binding.api.ReadOnlyTransaction;
-import org.opendaylight.controller.md.sal.binding.api.WriteTransaction;
-import org.opendaylight.controller.md.sal.common.api.data.AsyncDataBroker;
-import org.opendaylight.controller.md.sal.common.api.data.AsyncDataChangeEvent;
-import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType;
-import org.opendaylight.controller.md.sal.common.api.data.ReadFailedException;
-import org.opendaylight.controller.md.statistics.manager.StatisticsManagerActivator;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.flow.inventory.rev130819.FlowCapableNode;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.flow.inventory.rev130819.meters.Meter;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.inventory.rev130819.Nodes;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.inventory.rev130819.nodes.Node;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.meter.statistics.rev131111.NodeMeterConfigStats;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.meter.statistics.rev131111.NodeMeterFeatures;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.meter.statistics.rev131111.NodeMeterStatistics;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.meter.statistics.rev131111.nodes.node.MeterFeatures;
-import org.opendaylight.yangtools.yang.binding.DataObject;
-import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
-
-import test.mock.util.StatisticsManagerTest;
-
-import com.google.common.base.Optional;
-
-public class MeterStatisticsTest extends StatisticsManagerTest {
- private final Object waitObject = new Object();
-
-// @Test(timeout = 5000)
- public void addedMeterOnDemandStatsTest() throws ExecutionException, InterruptedException, ReadFailedException {
- final StatisticsManagerActivator activator = new StatisticsManagerActivator();
- activator.onSessionInitiated(providerContext);
-
- addFlowCapableNode(s1Key);
-
- final Meter meter = getMeter();
- final InstanceIdentifier<Meter> meterII = InstanceIdentifier.create(Nodes.class).child(Node.class, s1Key)
- .augmentation(FlowCapableNode.class).child(Meter.class, meter.getKey());
-
- final WriteTransaction writeTx = getDataBroker().newWriteOnlyTransaction();
- writeTx.put(LogicalDatastoreType.CONFIGURATION, meterII, meter);
- writeTx.put(LogicalDatastoreType.OPERATIONAL, meterII, meter);
- assertCommit(writeTx.submit());
-
- getDataBroker().registerDataChangeListener(LogicalDatastoreType.OPERATIONAL,
- meterII.augmentation(NodeMeterStatistics.class), new ChangeListener(), AsyncDataBroker.DataChangeScope.BASE);
-
- synchronized (waitObject) {
- waitObject.wait();
- }
-
- final ReadOnlyTransaction readTx = getDataBroker().newReadOnlyTransaction();
- final Optional<NodeMeterStatistics> meterStatsOptional = readTx.read(LogicalDatastoreType.OPERATIONAL,
- meterII.augmentation(NodeMeterStatistics.class)).checkedGet();
- assertTrue(meterStatsOptional.isPresent());
- assertEquals(COUNTER_64_TEST_VALUE, meterStatsOptional.get().getMeterStatistics().getByteInCount());
- assertEquals(COUNTER_64_TEST_VALUE, meterStatsOptional.get().getMeterStatistics().getPacketInCount());
- }
-
-// @Test(timeout = 5000)
- public void deletedMeterStatsRemovalTest() throws ExecutionException, InterruptedException, ReadFailedException {
- final StatisticsManagerActivator activator = new StatisticsManagerActivator();
- activator.onSessionInitiated(providerContext);
-
- addFlowCapableNode(s1Key);
-
- final Meter meter = getMeter();
- final InstanceIdentifier<Meter> meterII = InstanceIdentifier.create(Nodes.class).child(Node.class, s1Key)
- .augmentation(FlowCapableNode.class).child(Meter.class, meter.getKey());
-
- WriteTransaction writeTx = getDataBroker().newWriteOnlyTransaction();
- writeTx.put(LogicalDatastoreType.CONFIGURATION, meterII, meter);
- writeTx.put(LogicalDatastoreType.OPERATIONAL, meterII, meter);
- assertCommit(writeTx.submit());
-
- getDataBroker().registerDataChangeListener(LogicalDatastoreType.OPERATIONAL,
- meterII.augmentation(NodeMeterStatistics.class), new ChangeListener(), AsyncDataBroker.DataChangeScope.BASE);
-
- synchronized (waitObject) {
- waitObject.wait();
- }
-
- ReadOnlyTransaction readTx = getDataBroker().newReadOnlyTransaction();
- final Optional<NodeMeterStatistics> meterStatsOptional = readTx.read(LogicalDatastoreType.OPERATIONAL,
- meterII.augmentation(NodeMeterStatistics.class)).checkedGet();
- assertTrue(meterStatsOptional.isPresent());
- assertEquals(COUNTER_64_TEST_VALUE, meterStatsOptional.get().getMeterStatistics().getByteInCount());
- assertEquals(COUNTER_64_TEST_VALUE, meterStatsOptional.get().getMeterStatistics().getPacketInCount());
-
- writeTx = getDataBroker().newWriteOnlyTransaction();
- writeTx.delete(LogicalDatastoreType.CONFIGURATION, meterII);
- assertCommit(writeTx.submit());
-
- readTx = getDataBroker().newReadOnlyTransaction();
- final Optional<Meter> meterOptional = readTx.read(LogicalDatastoreType.OPERATIONAL, meterII).checkedGet();
- assertFalse(meterOptional.isPresent());
- }
-
-// @Test(timeout = 23000)
- public void getAllStatsFromConnectedNodeTest() throws ExecutionException, InterruptedException {
- final StatisticsManagerActivator activator = new StatisticsManagerActivator();
- activator.onSessionInitiated(providerContext);
-
- addFlowCapableNodeWithFeatures(s1Key, true);
-
- final InstanceIdentifier<Meter> meterII = InstanceIdentifier.create(Nodes.class).child(Node.class, s1Key)
- .augmentation(FlowCapableNode.class).child(Meter.class, getMeter().getKey());
- getDataBroker().registerDataChangeListener(LogicalDatastoreType.OPERATIONAL,
- meterII.augmentation(NodeMeterStatistics.class), new ChangeListener(), AsyncDataBroker.DataChangeScope.BASE);
-
- synchronized (waitObject) {
- waitObject.wait();
- }
-
- ReadOnlyTransaction readTx = getDataBroker().newReadOnlyTransaction();
- final Optional<Meter> optionalMeter = readTx.read(LogicalDatastoreType.OPERATIONAL, InstanceIdentifier.create(Nodes.class)
- .child(Node.class, s1Key).augmentation(FlowCapableNode.class)
- .child(Meter.class, getMeter().getKey())).get();
-
- assertTrue(optionalMeter.isPresent());
- assertTrue(optionalMeter.get().getAugmentation(NodeMeterConfigStats.class) != null);
- final NodeMeterStatistics meterStats = optionalMeter.get().getAugmentation(NodeMeterStatistics.class);
- assertTrue(meterStats != null);
- assertEquals(COUNTER_64_TEST_VALUE, meterStats.getMeterStatistics().getByteInCount());
- assertEquals(COUNTER_64_TEST_VALUE, meterStats.getMeterStatistics().getPacketInCount());
-
- readTx = getDataBroker().newReadOnlyTransaction();
- final Optional<MeterFeatures> optionalMeterFeautures = readTx.read(LogicalDatastoreType.OPERATIONAL, InstanceIdentifier.create(Nodes.class)
- .child(Node.class, s1Key).augmentation(NodeMeterFeatures.class).child(MeterFeatures.class)).get();
- assertTrue(optionalMeterFeautures.isPresent());
- assertEquals(COUNTER_32_TEST_VALUE, optionalMeterFeautures.get().getMaxMeter());
- }
-
- private class ChangeListener implements DataChangeListener {
-
- @Override
- public void onDataChanged(final AsyncDataChangeEvent<InstanceIdentifier<?>, DataObject> change) {
- synchronized (waitObject) {
- waitObject.notify();
- }
- }
- }
-}
-
package test.mock;
-import static org.junit.Assert.assertFalse;
-import static org.junit.Assert.assertTrue;
-
-import java.util.concurrent.ExecutionException;
-
-import org.opendaylight.controller.md.statistics.manager.StatisticsManagerActivator;
-import org.opendaylight.controller.md.statistics.manager.StatisticsManagerProvider;
+import org.junit.Test;
+import org.opendaylight.controller.md.statistics.manager.StatisticsManager;
import org.opendaylight.yang.gen.v1.urn.opendaylight.inventory.rev130819.Nodes;
import org.opendaylight.yang.gen.v1.urn.opendaylight.inventory.rev130819.nodes.Node;
import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
-
import test.mock.util.StatisticsManagerTest;
+import java.util.concurrent.ExecutionException;
+
+import static org.junit.Assert.assertFalse;
+import static org.junit.Assert.assertTrue;
+
public class NodeRegistrationTest extends StatisticsManagerTest {
-// @Test
+ @Test
public void nodeRegistrationTest() throws ExecutionException, InterruptedException {
- final StatisticsManagerActivator activator = new StatisticsManagerActivator();
- final StatisticsManagerProvider statisticsManagerProvider = new StatisticsManagerProvider(activator);
- activator.onSessionInitiated(providerContext);
+ StatisticsManager statisticsManager = setupStatisticsManager();
addFlowCapableNode(s1Key);
- Thread.sleep(1000);
+ Thread.sleep(2000);
final InstanceIdentifier<Node> nodeII = InstanceIdentifier.create(Nodes.class).child(Node.class, s1Key);
- assertTrue(statisticsManagerProvider.getStatisticsManager().isProvidedFlowNodeActive(nodeII));
+ assertTrue(statisticsManager.isProvidedFlowNodeActive(nodeII));
}
-// @Test
+ @Test
public void nodeUnregistrationTest() throws ExecutionException, InterruptedException {
- final StatisticsManagerActivator activator = new StatisticsManagerActivator();
- final StatisticsManagerProvider statisticsManagerProvider = new StatisticsManagerProvider(activator);
- activator.onSessionInitiated(providerContext);
+ StatisticsManager statisticsManager = setupStatisticsManager();
addFlowCapableNode(s1Key);
- Thread.sleep(1000);
+ Thread.sleep(2000);
final InstanceIdentifier<Node> nodeII = InstanceIdentifier.create(Nodes.class).child(Node.class, s1Key);
- assertTrue(statisticsManagerProvider.getStatisticsManager().isProvidedFlowNodeActive(nodeII));
+ assertTrue(statisticsManager.isProvidedFlowNodeActive(nodeII));
removeNode(s1Key);
- Thread.sleep(1000);
- assertFalse(statisticsManagerProvider.getStatisticsManager().isProvidedFlowNodeActive(nodeII));
+ Thread.sleep(2000);
+ assertFalse(statisticsManager.isProvidedFlowNodeActive(nodeII));
}
}
+++ /dev/null
-package test.mock;
-
-import static org.junit.Assert.assertEquals;
-import static org.junit.Assert.assertTrue;
-
-import java.util.concurrent.ExecutionException;
-
-import org.opendaylight.controller.md.sal.binding.api.DataChangeListener;
-import org.opendaylight.controller.md.sal.binding.api.ReadOnlyTransaction;
-import org.opendaylight.controller.md.sal.common.api.data.AsyncDataBroker;
-import org.opendaylight.controller.md.sal.common.api.data.AsyncDataChangeEvent;
-import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType;
-import org.opendaylight.controller.md.sal.common.api.data.ReadFailedException;
-import org.opendaylight.controller.md.statistics.manager.StatisticsManagerActivator;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.flow.inventory.rev130819.FlowFeatureCapabilityPortStats;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.inventory.rev130819.Nodes;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.inventory.rev130819.node.NodeConnector;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.inventory.rev130819.node.NodeConnectorKey;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.inventory.rev130819.nodes.Node;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.port.statistics.rev131214.FlowCapableNodeConnectorStatisticsData;
-import org.opendaylight.yangtools.yang.binding.DataObject;
-import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
-
-import test.mock.util.StatisticsManagerTest;
-
-import com.google.common.base.Optional;
-
-public class PortStatisticsTest extends StatisticsManagerTest {
- private final Object waitObject = new Object();
-
-// @Test(timeout = 23000)
- public void getPortStatisticsTest() throws ExecutionException, InterruptedException, ReadFailedException {
- final StatisticsManagerActivator activator = new StatisticsManagerActivator();
- activator.onSessionInitiated(providerContext);
-
- addFlowCapableNodeWithFeatures(s1Key, false, FlowFeatureCapabilityPortStats.class);
-
- final InstanceIdentifier<NodeConnector> nodeConnectorII = InstanceIdentifier.create(Nodes.class)
- .child(Node.class, s1Key).child(NodeConnector.class, new NodeConnectorKey(getNodeConnectorId()));
-
-
- getDataBroker().registerDataChangeListener(LogicalDatastoreType.OPERATIONAL,
- nodeConnectorII.augmentation(FlowCapableNodeConnectorStatisticsData.class),
- new ChangeListener(), AsyncDataBroker.DataChangeScope.BASE);
-
- synchronized (waitObject) {
- waitObject.wait();
- }
-
- final ReadOnlyTransaction readTx = getDataBroker().newReadOnlyTransaction();
- final Optional<FlowCapableNodeConnectorStatisticsData> flowCapableNodeConnectorStatisticsDataOptional =
- readTx.read(LogicalDatastoreType.OPERATIONAL,
- nodeConnectorII.augmentation(FlowCapableNodeConnectorStatisticsData.class)).checkedGet();
- assertTrue(flowCapableNodeConnectorStatisticsDataOptional.isPresent());
- assertEquals(BIG_INTEGER_TEST_VALUE,
- flowCapableNodeConnectorStatisticsDataOptional.get().getFlowCapableNodeConnectorStatistics()
- .getReceiveDrops());
- assertEquals(BIG_INTEGER_TEST_VALUE,
- flowCapableNodeConnectorStatisticsDataOptional.get().getFlowCapableNodeConnectorStatistics()
- .getCollisionCount());
- }
-
- private class ChangeListener implements DataChangeListener {
-
- @Override
- public void onDataChanged(final AsyncDataChangeEvent<InstanceIdentifier<?>, DataObject> change) {
- synchronized (waitObject) {
- waitObject.notify();
- }
- }
- }
-}
-
+++ /dev/null
-package test.mock;
-
-import static org.junit.Assert.assertEquals;
-import static org.junit.Assert.assertFalse;
-import static org.junit.Assert.assertTrue;
-
-import java.util.Collections;
-import java.util.concurrent.ExecutionException;
-
-import org.opendaylight.controller.md.sal.binding.api.DataChangeListener;
-import org.opendaylight.controller.md.sal.binding.api.ReadOnlyTransaction;
-import org.opendaylight.controller.md.sal.binding.api.WriteTransaction;
-import org.opendaylight.controller.md.sal.common.api.data.AsyncDataBroker;
-import org.opendaylight.controller.md.sal.common.api.data.AsyncDataChangeEvent;
-import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType;
-import org.opendaylight.controller.md.sal.common.api.data.ReadFailedException;
-import org.opendaylight.controller.md.statistics.manager.StatisticsManagerActivator;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.flow.inventory.rev130819.FlowCapableNodeConnector;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.flow.inventory.rev130819.FlowCapableNodeConnectorBuilder;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.flow.inventory.rev130819.FlowFeatureCapabilityQueueStats;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.flow.types.port.rev130925.port.mod.port.Port;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.flow.types.port.rev130925.queues.Queue;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.flow.types.port.rev130925.queues.QueueBuilder;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.inventory.rev130819.NodeConnectorId;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.inventory.rev130819.Nodes;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.inventory.rev130819.node.NodeConnector;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.inventory.rev130819.node.NodeConnectorBuilder;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.inventory.rev130819.node.NodeConnectorKey;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.inventory.rev130819.nodes.Node;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.queue.statistics.rev131216.FlowCapableNodeConnectorQueueStatisticsData;
-import org.opendaylight.yangtools.yang.binding.DataObject;
-import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
-
-import test.mock.util.StatisticsManagerTest;
-
-import com.google.common.base.Optional;
-
-
-public class QueueStatisticsTest extends StatisticsManagerTest {
- private final Object waitObject = new Object();
-
-// @Test(timeout = 5000)
- public void addedQueueOnDemandStatsTest() throws ExecutionException, InterruptedException, ReadFailedException {
- final StatisticsManagerActivator activator = new StatisticsManagerActivator();
- activator.onSessionInitiated(providerContext);
-
- addFlowCapableNode(s1Key);
-
- final Port port = getPort();
-
- final NodeConnectorBuilder ncBuilder = new NodeConnectorBuilder();
- final FlowCapableNodeConnectorBuilder fcncBuilder = new FlowCapableNodeConnectorBuilder();
- fcncBuilder.setConfiguration(port.getConfiguration());
- fcncBuilder.setPortNumber(port.getPortNumber());
- fcncBuilder.setQueue(Collections.<Queue>emptyList());
- ncBuilder.setKey(new NodeConnectorKey(new NodeConnectorId("connector.1")));
- ncBuilder.addAugmentation(FlowCapableNodeConnector.class, fcncBuilder.build());
-
-
- final Queue queue = getQueue();
- final InstanceIdentifier<Queue> queueII = InstanceIdentifier.create(Nodes.class).child(Node.class, s1Key)
- .child(NodeConnector.class, ncBuilder.getKey()).augmentation(FlowCapableNodeConnector.class)
- .child(Queue.class, queue.getKey());
- final InstanceIdentifier<NodeConnector> nodeConnectorII = InstanceIdentifier.create(Nodes.class)
- .child(Node.class, s1Key).child(NodeConnector.class, ncBuilder.getKey());
-
- final WriteTransaction writeTx = getDataBroker().newWriteOnlyTransaction();
- writeTx.put(LogicalDatastoreType.CONFIGURATION, nodeConnectorII, ncBuilder.build());
- writeTx.put(LogicalDatastoreType.CONFIGURATION, queueII, queue);
- writeTx.put(LogicalDatastoreType.OPERATIONAL, nodeConnectorII, ncBuilder.build());
- writeTx.put(LogicalDatastoreType.OPERATIONAL, queueII, queue);
- assertCommit(writeTx.submit());
-
- getDataBroker().registerDataChangeListener(LogicalDatastoreType.OPERATIONAL,
- queueII.augmentation(FlowCapableNodeConnectorQueueStatisticsData.class), new ChangeListener(), AsyncDataBroker.DataChangeScope.BASE);
-
- synchronized (waitObject) {
- waitObject.wait();
- }
-
- final ReadOnlyTransaction readTx = getDataBroker().newReadOnlyTransaction();
- final Optional<FlowCapableNodeConnectorQueueStatisticsData> queueStatsOptional = readTx.read(LogicalDatastoreType.OPERATIONAL,
- queueII.augmentation(FlowCapableNodeConnectorQueueStatisticsData.class)).checkedGet();
- assertTrue(queueStatsOptional.isPresent());
- assertEquals(COUNTER_64_TEST_VALUE,
- queueStatsOptional.get().getFlowCapableNodeConnectorQueueStatistics().getTransmittedBytes());
- }
-
-// @Test(timeout = 5000)
- public void deletedQueueStatsRemovalTest() throws ExecutionException, InterruptedException, ReadFailedException {
- final StatisticsManagerActivator activator = new StatisticsManagerActivator();
- activator.onSessionInitiated(providerContext);
-
- addFlowCapableNode(s1Key);
-
- final Port port = getPort();
-
- final NodeConnectorBuilder ncBuilder = new NodeConnectorBuilder();
- final FlowCapableNodeConnectorBuilder fcncBuilder = new FlowCapableNodeConnectorBuilder();
- fcncBuilder.setConfiguration(port.getConfiguration());
- fcncBuilder.setPortNumber(port.getPortNumber());
- fcncBuilder.setQueue(Collections.<Queue>emptyList());
- ncBuilder.setKey(new NodeConnectorKey(new NodeConnectorId("connector.1")));
- ncBuilder.addAugmentation(FlowCapableNodeConnector.class, fcncBuilder.build());
-
-
- final Queue queue = getQueue();
- final InstanceIdentifier<Queue> queueII = InstanceIdentifier.create(Nodes.class).child(Node.class, s1Key)
- .child(NodeConnector.class, ncBuilder.getKey()).augmentation(FlowCapableNodeConnector.class)
- .child(Queue.class, queue.getKey());
- final InstanceIdentifier<NodeConnector> nodeConnectorII = InstanceIdentifier.create(Nodes.class)
- .child(Node.class, s1Key).child(NodeConnector.class, ncBuilder.getKey());
-
- WriteTransaction writeTx = getDataBroker().newWriteOnlyTransaction();
- writeTx.put(LogicalDatastoreType.CONFIGURATION, nodeConnectorII, ncBuilder.build());
- writeTx.put(LogicalDatastoreType.CONFIGURATION, queueII, queue);
- writeTx.put(LogicalDatastoreType.OPERATIONAL, nodeConnectorII, ncBuilder.build());
- writeTx.put(LogicalDatastoreType.OPERATIONAL, queueII, queue);
- assertCommit(writeTx.submit());
-
- getDataBroker().registerDataChangeListener(LogicalDatastoreType.OPERATIONAL,
- queueII.augmentation(FlowCapableNodeConnectorQueueStatisticsData.class),
- new ChangeListener(), AsyncDataBroker.DataChangeScope.BASE);
-
- synchronized (waitObject) {
- waitObject.wait();
- }
-
- ReadOnlyTransaction readTx = getDataBroker().newReadOnlyTransaction();
- Optional<FlowCapableNodeConnectorQueueStatisticsData> queueStatsOptional = readTx.read(LogicalDatastoreType.OPERATIONAL,
- queueII.augmentation(FlowCapableNodeConnectorQueueStatisticsData.class)).checkedGet();
- assertTrue(queueStatsOptional.isPresent());
- assertEquals(COUNTER_64_TEST_VALUE,
- queueStatsOptional.get().getFlowCapableNodeConnectorQueueStatistics().getTransmittedBytes());
-
- writeTx = getDataBroker().newWriteOnlyTransaction();
- writeTx.delete(LogicalDatastoreType.CONFIGURATION, queueII);
- assertCommit(writeTx.submit());
-
- readTx = getDataBroker().newReadOnlyTransaction();
- queueStatsOptional = readTx.read(LogicalDatastoreType.OPERATIONAL,
- queueII.augmentation(FlowCapableNodeConnectorQueueStatisticsData.class)).checkedGet();
- assertFalse(queueStatsOptional.isPresent());
- }
-
-// @Test(timeout = 23000)
- public void getAllStatsFromConnectedNodeTest() throws ExecutionException, InterruptedException, ReadFailedException {
- final StatisticsManagerActivator activator = new StatisticsManagerActivator();
- activator.onSessionInitiated(providerContext);
-
- addFlowCapableNodeWithFeatures(s1Key, false, FlowFeatureCapabilityQueueStats.class);
-
- final NodeConnectorBuilder ncBuilder = new NodeConnectorBuilder();
- final FlowCapableNodeConnectorBuilder fcncBuilder = new FlowCapableNodeConnectorBuilder();
- ncBuilder.setKey(new NodeConnectorKey(getNodeConnectorId()));
- ncBuilder.addAugmentation(FlowCapableNodeConnector.class, fcncBuilder.build());
-
- final InstanceIdentifier<NodeConnector> nodeConnectorII = InstanceIdentifier.create(Nodes.class)
- .child(Node.class, s1Key)
- .child(NodeConnector.class, ncBuilder.getKey());
-
- final WriteTransaction writeTx = getDataBroker().newWriteOnlyTransaction();
- writeTx.put(LogicalDatastoreType.OPERATIONAL, nodeConnectorII, ncBuilder.build());
- final InstanceIdentifier<Queue> queueII = nodeConnectorII.augmentation(FlowCapableNodeConnector.class)
- .child(Queue.class, getQueue().getKey());
- final QueueBuilder qBuilder = new QueueBuilder(getQueue());
- writeTx.put(LogicalDatastoreType.OPERATIONAL, queueII, qBuilder.build());
- assertCommit(writeTx.submit());
-
- getDataBroker().registerDataChangeListener(LogicalDatastoreType.OPERATIONAL,
- queueII.augmentation(FlowCapableNodeConnectorQueueStatisticsData.class), new ChangeListener(), AsyncDataBroker.DataChangeScope.BASE);
-
- synchronized (waitObject) {
- waitObject.wait();
- }
-
- final ReadOnlyTransaction readTx = getDataBroker().newReadOnlyTransaction();
- final Optional<Queue> queueOptional = readTx.read(LogicalDatastoreType.OPERATIONAL, queueII).checkedGet();
- assertTrue(queueOptional.isPresent());
- final FlowCapableNodeConnectorQueueStatisticsData queueStats =
- queueOptional.get().getAugmentation(FlowCapableNodeConnectorQueueStatisticsData.class);
- assertTrue(queueStats != null);
- assertEquals(COUNTER_64_TEST_VALUE,
- queueStats.getFlowCapableNodeConnectorQueueStatistics().getTransmittedBytes());
- }
-
- private class ChangeListener implements DataChangeListener {
-
- @Override
- public void onDataChanged(final AsyncDataChangeEvent<InstanceIdentifier<?>, DataObject> change) {
- synchronized (waitObject) {
- waitObject.notify();
- }
- }
- }
-}
-
--- /dev/null
+package test.mock;
+
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertTrue;
+
+import com.google.common.base.Optional;
+import java.util.concurrent.ExecutionException;
+import org.junit.Test;
+import org.opendaylight.controller.md.sal.binding.api.DataChangeListener;
+import org.opendaylight.controller.md.sal.binding.api.ReadOnlyTransaction;
+import org.opendaylight.controller.md.sal.binding.api.WriteTransaction;
+import org.opendaylight.controller.md.sal.common.api.data.AsyncDataBroker;
+import org.opendaylight.controller.md.sal.common.api.data.AsyncDataChangeEvent;
+import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType;
+import org.opendaylight.controller.md.sal.common.api.data.ReadFailedException;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.flow.inventory.rev130819.FlowCapableNode;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.flow.inventory.rev130819.FlowCapableNodeConnector;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.flow.inventory.rev130819.FlowCapableNodeConnectorBuilder;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.flow.inventory.rev130819.FlowFeatureCapabilityFlowStats;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.flow.inventory.rev130819.FlowFeatureCapabilityGroupStats;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.flow.inventory.rev130819.FlowFeatureCapabilityPortStats;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.flow.inventory.rev130819.FlowFeatureCapabilityQueueStats;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.flow.inventory.rev130819.FlowFeatureCapabilityTableStats;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.flow.inventory.rev130819.meters.Meter;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.flow.inventory.rev130819.tables.Table;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.flow.inventory.rev130819.tables.TableKey;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.flow.inventory.rev130819.tables.table.Flow;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.flow.statistics.rev130819.FlowStatisticsData;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.flow.table.statistics.rev131215.FlowTableStatisticsData;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.flow.types.port.rev130925.queues.Queue;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.flow.types.port.rev130925.queues.QueueBuilder;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.group.statistics.rev131111.NodeGroupDescStats;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.group.statistics.rev131111.NodeGroupFeatures;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.group.statistics.rev131111.NodeGroupStatistics;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.group.statistics.rev131111.group.features.GroupFeatures;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.group.types.rev131018.groups.Group;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.inventory.rev130819.Nodes;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.inventory.rev130819.node.NodeConnector;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.inventory.rev130819.node.NodeConnectorBuilder;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.inventory.rev130819.node.NodeConnectorKey;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.inventory.rev130819.nodes.Node;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.meter.statistics.rev131111.NodeMeterConfigStats;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.meter.statistics.rev131111.NodeMeterFeatures;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.meter.statistics.rev131111.NodeMeterStatistics;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.meter.statistics.rev131111.nodes.node.MeterFeatures;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.port.statistics.rev131214.FlowCapableNodeConnectorStatisticsData;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.queue.statistics.rev131216.FlowCapableNodeConnectorQueueStatisticsData;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.table.types.rev131026.TableId;
+import org.opendaylight.yangtools.yang.binding.DataObject;
+import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
+import test.mock.util.StatisticsManagerTest;
+
+public class StatCollectorTest extends StatisticsManagerTest {
+ private final Object waitObject = new Object();
+
+ @Test(timeout = 200000)
+ public void getAllFlowStatsTest() throws ExecutionException, InterruptedException, ReadFailedException {
+ setupStatisticsManager();
+
+ addFlowCapableNodeWithFeatures(s1Key, false, FlowFeatureCapabilityFlowStats.class);
+
+ final Flow flow = getFlow();
+
+ final InstanceIdentifier<Table> tableII = InstanceIdentifier.create(Nodes.class).child(Node.class, s1Key)
+ .augmentation(FlowCapableNode.class).child(Table.class, new TableKey(flow.getTableId()));
+
+ getDataBroker().registerDataChangeListener(LogicalDatastoreType.OPERATIONAL,
+ tableII.child(Flow.class), new ChangeListener(), AsyncDataBroker.DataChangeScope.BASE);
+
+ synchronized (waitObject) {
+ waitObject.wait();
+ }
+
+ final ReadOnlyTransaction readTx = getDataBroker().newReadOnlyTransaction();
+ final Optional<Table> tableOptional = readTx.read(LogicalDatastoreType.OPERATIONAL, InstanceIdentifier.create(Nodes.class)
+ .child(Node.class, s1Key).augmentation(FlowCapableNode.class)
+ .child(Table.class, new TableKey(flow.getTableId()))).checkedGet();
+ assertTrue(tableOptional.isPresent());
+ final FlowStatisticsData flowStats = tableOptional.get().getFlow().get(0).getAugmentation(FlowStatisticsData.class);
+ assertTrue(flowStats != null);
+ assertEquals(COUNTER_64_TEST_VALUE, flowStats.getFlowStatistics().getByteCount());
+ }
+
+ @Test(timeout = 200000)
+ public void getAllGroupStatsFeatureNotAdvertisedTest() throws ExecutionException, InterruptedException {
+ setupStatisticsManager();
+
+ addFlowCapableNodeWithFeatures(s1Key, true);
+
+ final InstanceIdentifier<Group> groupII = InstanceIdentifier.create(Nodes.class).child(Node.class, s1Key)
+ .augmentation(FlowCapableNode.class).child(Group.class, getGroup().getKey());
+ getDataBroker().registerDataChangeListener(LogicalDatastoreType.OPERATIONAL,
+ groupII.augmentation(NodeGroupStatistics.class), new ChangeListener(), AsyncDataBroker.DataChangeScope.BASE);
+
+ synchronized (waitObject) {
+ waitObject.wait();
+ }
+
+ ReadOnlyTransaction readTx = getDataBroker().newReadOnlyTransaction();
+ final Optional<Group> optionalGroup = readTx.read(LogicalDatastoreType.OPERATIONAL, InstanceIdentifier.create(Nodes.class)
+ .child(Node.class, s1Key).augmentation(FlowCapableNode.class)
+ .child(Group.class, getGroup().getKey())).get();
+
+ assertTrue(optionalGroup.isPresent());
+ assertTrue(optionalGroup.get().getAugmentation(NodeGroupDescStats.class) != null);
+ final NodeGroupStatistics groupStats = optionalGroup.get().getAugmentation(NodeGroupStatistics.class);
+ assertTrue(groupStats != null);
+ assertEquals(COUNTER_64_TEST_VALUE, groupStats.getGroupStatistics().getByteCount());
+
+ readTx = getDataBroker().newReadOnlyTransaction();
+ final Optional<GroupFeatures> optionalGroupFeatures = readTx.read(LogicalDatastoreType.OPERATIONAL, InstanceIdentifier.create(Nodes.class)
+ .child(Node.class, s1Key).augmentation(NodeGroupFeatures.class).child(GroupFeatures.class)).get();
+ assertTrue(optionalGroupFeatures.isPresent());
+ assertEquals(1, optionalGroupFeatures.get().getMaxGroups().size());
+ assertEquals(MAX_GROUPS_TEST_VALUE, optionalGroupFeatures.get().getMaxGroups().get(0));
+ }
+
+ @Test(timeout = 200000)
+ public void getAllGroupStatsFeatureAdvertisedTest() throws ExecutionException, InterruptedException {
+ setupStatisticsManager();
+
+ addFlowCapableNodeWithFeatures(s1Key, false, FlowFeatureCapabilityGroupStats.class);
+
+ final InstanceIdentifier<Group> groupII = InstanceIdentifier.create(Nodes.class).child(Node.class, s1Key)
+ .augmentation(FlowCapableNode.class).child(Group.class, getGroup().getKey());
+ getDataBroker().registerDataChangeListener(LogicalDatastoreType.OPERATIONAL,
+ groupII.augmentation(NodeGroupStatistics.class), new ChangeListener(), AsyncDataBroker.DataChangeScope.BASE);
+
+ synchronized (waitObject) {
+ waitObject.wait();
+ }
+
+ ReadOnlyTransaction readTx = getDataBroker().newReadOnlyTransaction();
+ final Optional<Group> optionalGroup = readTx.read(LogicalDatastoreType.OPERATIONAL, InstanceIdentifier.create(Nodes.class)
+ .child(Node.class, s1Key).augmentation(FlowCapableNode.class)
+ .child(Group.class, getGroup().getKey())).get();
+
+ assertTrue(optionalGroup.isPresent());
+ assertTrue(optionalGroup.get().getAugmentation(NodeGroupDescStats.class) != null);
+ final NodeGroupStatistics groupStats = optionalGroup.get().getAugmentation(NodeGroupStatistics.class);
+ assertTrue(groupStats != null);
+ assertEquals(COUNTER_64_TEST_VALUE, groupStats.getGroupStatistics().getByteCount());
+
+ readTx = getDataBroker().newReadOnlyTransaction();
+ final Optional<GroupFeatures> optionalGroupFeatures = readTx.read(LogicalDatastoreType.OPERATIONAL, InstanceIdentifier.create(Nodes.class)
+ .child(Node.class, s1Key).augmentation(NodeGroupFeatures.class).child(GroupFeatures.class)).get();
+ assertTrue(optionalGroupFeatures.isPresent());
+ assertEquals(1, optionalGroupFeatures.get().getMaxGroups().size());
+ assertEquals(MAX_GROUPS_TEST_VALUE, optionalGroupFeatures.get().getMaxGroups().get(0));
+ }
+
+ @Test(timeout = 200000)
+ public void getAllMeterStatsTest() throws ExecutionException, InterruptedException {
+ setupStatisticsManager();
+
+ addFlowCapableNodeWithFeatures(s1Key, true);
+
+ final InstanceIdentifier<Meter> meterII = InstanceIdentifier.create(Nodes.class).child(Node.class, s1Key)
+ .augmentation(FlowCapableNode.class).child(Meter.class, getMeter().getKey());
+ getDataBroker().registerDataChangeListener(LogicalDatastoreType.OPERATIONAL,
+ meterII.augmentation(NodeMeterStatistics.class), new ChangeListener(), AsyncDataBroker.DataChangeScope.BASE);
+
+ synchronized (waitObject) {
+ waitObject.wait();
+ }
+
+ ReadOnlyTransaction readTx = getDataBroker().newReadOnlyTransaction();
+ final Optional<Meter> optionalMeter = readTx.read(LogicalDatastoreType.OPERATIONAL, InstanceIdentifier.create(Nodes.class)
+ .child(Node.class, s1Key).augmentation(FlowCapableNode.class)
+ .child(Meter.class, getMeter().getKey())).get();
+
+ assertTrue(optionalMeter.isPresent());
+ assertTrue(optionalMeter.get().getAugmentation(NodeMeterConfigStats.class) != null);
+ final NodeMeterStatistics meterStats = optionalMeter.get().getAugmentation(NodeMeterStatistics.class);
+ assertTrue(meterStats != null);
+ assertEquals(COUNTER_64_TEST_VALUE, meterStats.getMeterStatistics().getByteInCount());
+ assertEquals(COUNTER_64_TEST_VALUE, meterStats.getMeterStatistics().getPacketInCount());
+
+ readTx = getDataBroker().newReadOnlyTransaction();
+ final Optional<MeterFeatures> optionalMeterFeautures = readTx.read(LogicalDatastoreType.OPERATIONAL, InstanceIdentifier.create(Nodes.class)
+ .child(Node.class, s1Key).augmentation(NodeMeterFeatures.class).child(MeterFeatures.class)).get();
+ assertTrue(optionalMeterFeautures.isPresent());
+ assertEquals(COUNTER_32_TEST_VALUE, optionalMeterFeautures.get().getMaxMeter());
+ }
+
+ @Test(timeout = 200000)
+ public void getAllQueueStatsTest() throws ExecutionException, InterruptedException, ReadFailedException {
+ setupStatisticsManager();
+
+ addFlowCapableNodeWithFeatures(s1Key, false, FlowFeatureCapabilityQueueStats.class);
+
+ final NodeConnectorBuilder ncBuilder = new NodeConnectorBuilder();
+ final FlowCapableNodeConnectorBuilder fcncBuilder = new FlowCapableNodeConnectorBuilder();
+ ncBuilder.setKey(new NodeConnectorKey(getNodeConnectorId()));
+ ncBuilder.addAugmentation(FlowCapableNodeConnector.class, fcncBuilder.build());
+
+ final InstanceIdentifier<NodeConnector> nodeConnectorII = InstanceIdentifier.create(Nodes.class)
+ .child(Node.class, s1Key)
+ .child(NodeConnector.class, ncBuilder.getKey());
+
+ final WriteTransaction writeTx = getDataBroker().newWriteOnlyTransaction();
+ writeTx.put(LogicalDatastoreType.OPERATIONAL, nodeConnectorII, ncBuilder.build());
+ final InstanceIdentifier<Queue> queueII = nodeConnectorII.augmentation(FlowCapableNodeConnector.class)
+ .child(Queue.class, getQueue().getKey());
+ final QueueBuilder qBuilder = new QueueBuilder(getQueue());
+ writeTx.put(LogicalDatastoreType.OPERATIONAL, queueII, qBuilder.build());
+ assertCommit(writeTx.submit());
+
+ getDataBroker().registerDataChangeListener(LogicalDatastoreType.OPERATIONAL,
+ queueII.augmentation(FlowCapableNodeConnectorQueueStatisticsData.class), new ChangeListener(), AsyncDataBroker.DataChangeScope.BASE);
+
+ synchronized (waitObject) {
+ waitObject.wait();
+ }
+
+ final ReadOnlyTransaction readTx = getDataBroker().newReadOnlyTransaction();
+ final Optional<Queue> queueOptional = readTx.read(LogicalDatastoreType.OPERATIONAL, queueII).checkedGet();
+ assertTrue(queueOptional.isPresent());
+ final FlowCapableNodeConnectorQueueStatisticsData queueStats =
+ queueOptional.get().getAugmentation(FlowCapableNodeConnectorQueueStatisticsData.class);
+ assertTrue(queueStats != null);
+ assertEquals(COUNTER_64_TEST_VALUE,
+ queueStats.getFlowCapableNodeConnectorQueueStatistics().getTransmittedBytes());
+ }
+
+ @Test(timeout = 200000)
+ public void getAllPortStatsTest() throws ExecutionException, InterruptedException, ReadFailedException {
+ setupStatisticsManager();
+
+ addFlowCapableNodeWithFeatures(s1Key, false, FlowFeatureCapabilityPortStats.class);
+
+ final InstanceIdentifier<NodeConnector> nodeConnectorII = InstanceIdentifier.create(Nodes.class)
+ .child(Node.class, s1Key).child(NodeConnector.class, new NodeConnectorKey(getNodeConnectorId()));
+
+ NodeConnectorBuilder ncBuilder = new NodeConnectorBuilder();
+ ncBuilder.setKey(new NodeConnectorKey(getNodeConnectorId()));
+ WriteTransaction writeTx = getDataBroker().newWriteOnlyTransaction();
+ writeTx.put(LogicalDatastoreType.OPERATIONAL, nodeConnectorII, ncBuilder.build());
+ assertCommit(writeTx.submit());
+
+ getDataBroker().registerDataChangeListener(LogicalDatastoreType.OPERATIONAL,
+ nodeConnectorII.augmentation(FlowCapableNodeConnectorStatisticsData.class),
+ new ChangeListener(), AsyncDataBroker.DataChangeScope.BASE);
+
+ synchronized (waitObject) {
+ waitObject.wait();
+ }
+
+ final ReadOnlyTransaction readTx = getDataBroker().newReadOnlyTransaction();
+ final Optional<FlowCapableNodeConnectorStatisticsData> flowCapableNodeConnectorStatisticsDataOptional =
+ readTx.read(LogicalDatastoreType.OPERATIONAL,
+ nodeConnectorII.augmentation(FlowCapableNodeConnectorStatisticsData.class)).checkedGet();
+ assertTrue(flowCapableNodeConnectorStatisticsDataOptional.isPresent());
+ assertEquals(BIG_INTEGER_TEST_VALUE,
+ flowCapableNodeConnectorStatisticsDataOptional.get().getFlowCapableNodeConnectorStatistics()
+ .getReceiveDrops());
+ assertEquals(BIG_INTEGER_TEST_VALUE,
+ flowCapableNodeConnectorStatisticsDataOptional.get().getFlowCapableNodeConnectorStatistics()
+ .getCollisionCount());
+ }
+
+ @Test(timeout = 200000)
+ public void getAllTableStatsTest() throws ExecutionException, InterruptedException, ReadFailedException {
+ setupStatisticsManager();
+
+ addFlowCapableNodeWithFeatures(s1Key, false, FlowFeatureCapabilityTableStats.class);
+
+ final TableId tableId = getTableId();
+ final InstanceIdentifier<Table> tableII = InstanceIdentifier.create(Nodes.class).child(Node.class, s1Key)
+ .augmentation(FlowCapableNode.class).child(Table.class, new TableKey(tableId.getValue()));
+
+ getDataBroker().registerDataChangeListener(LogicalDatastoreType.OPERATIONAL,
+ tableII.augmentation(FlowTableStatisticsData.class), new ChangeListener(), AsyncDataBroker.DataChangeScope.BASE);
+
+ synchronized (waitObject) {
+ waitObject.wait();
+ }
+
+ final ReadOnlyTransaction readTx = getDataBroker().newReadOnlyTransaction();
+ final Optional<FlowTableStatisticsData> flowTableStatisticsDataOptional = readTx.read(
+ LogicalDatastoreType.OPERATIONAL, tableII.augmentation(FlowTableStatisticsData.class)).checkedGet();
+ assertTrue(flowTableStatisticsDataOptional.isPresent());
+ assertEquals(COUNTER_32_TEST_VALUE,
+ flowTableStatisticsDataOptional.get().getFlowTableStatistics().getActiveFlows());
+ assertEquals(COUNTER_64_TEST_VALUE,
+ flowTableStatisticsDataOptional.get().getFlowTableStatistics().getPacketsLookedUp());
+ }
+
+ public class ChangeListener implements DataChangeListener {
+
+ @Override
+ public void onDataChanged(final AsyncDataChangeEvent<InstanceIdentifier<?>, DataObject> change) {
+ synchronized (waitObject) {
+ waitObject.notify();
+ }
+ }
+ }
+}
+++ /dev/null
-package test.mock;
-
-import static org.junit.Assert.assertEquals;
-import static org.junit.Assert.assertTrue;
-
-import java.util.concurrent.ExecutionException;
-
-import org.opendaylight.controller.md.sal.binding.api.DataChangeListener;
-import org.opendaylight.controller.md.sal.binding.api.ReadOnlyTransaction;
-import org.opendaylight.controller.md.sal.common.api.data.AsyncDataBroker;
-import org.opendaylight.controller.md.sal.common.api.data.AsyncDataChangeEvent;
-import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType;
-import org.opendaylight.controller.md.sal.common.api.data.ReadFailedException;
-import org.opendaylight.controller.md.statistics.manager.StatisticsManagerActivator;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.flow.inventory.rev130819.FlowCapableNode;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.flow.inventory.rev130819.FlowFeatureCapabilityTableStats;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.flow.inventory.rev130819.tables.Table;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.flow.inventory.rev130819.tables.TableKey;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.flow.table.statistics.rev131215.FlowTableStatisticsData;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.inventory.rev130819.Nodes;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.inventory.rev130819.nodes.Node;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.table.types.rev131026.TableId;
-import org.opendaylight.yangtools.yang.binding.DataObject;
-import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
-
-import test.mock.util.StatisticsManagerTest;
-
-import com.google.common.base.Optional;
-
-public class TableStatisticsTest extends StatisticsManagerTest {
- private final Object waitObject = new Object();
-
-// @Test(timeout = 23000)
- public void getTableStatisticsTest() throws ExecutionException, InterruptedException, ReadFailedException {
- final StatisticsManagerActivator activator = new StatisticsManagerActivator();
- activator.onSessionInitiated(providerContext);
-
- addFlowCapableNodeWithFeatures(s1Key, false, FlowFeatureCapabilityTableStats.class);
-
- final TableId tableId = getTableId();
- final InstanceIdentifier<Table> tableII = InstanceIdentifier.create(Nodes.class).child(Node.class, s1Key)
- .augmentation(FlowCapableNode.class).child(Table.class, new TableKey(tableId.getValue()));
-
- getDataBroker().registerDataChangeListener(LogicalDatastoreType.OPERATIONAL,
- tableII.augmentation(FlowTableStatisticsData.class), new ChangeListener(), AsyncDataBroker.DataChangeScope.BASE);
-
- synchronized (waitObject) {
- waitObject.wait();
- }
-
- final ReadOnlyTransaction readTx = getDataBroker().newReadOnlyTransaction();
- final Optional<FlowTableStatisticsData> flowTableStatisticsDataOptional = readTx.read(
- LogicalDatastoreType.OPERATIONAL, tableII.augmentation(FlowTableStatisticsData.class)).checkedGet();
- assertTrue(flowTableStatisticsDataOptional.isPresent());
- assertEquals(COUNTER_32_TEST_VALUE,
- flowTableStatisticsDataOptional.get().getFlowTableStatistics().getActiveFlows());
- assertEquals(COUNTER_64_TEST_VALUE,
- flowTableStatisticsDataOptional.get().getFlowTableStatistics().getPacketsLookedUp());
- }
-
- private class ChangeListener implements DataChangeListener {
-
- @Override
- public void onDataChanged(final AsyncDataChangeEvent<InstanceIdentifier<?>, DataObject> change) {
- synchronized (waitObject) {
- waitObject.notify();
- }
- }
- }
-}
-
package test.mock.util;
import com.google.common.util.concurrent.Futures;
+import java.math.BigInteger;
+import java.util.ArrayList;
+import java.util.List;
+import java.util.concurrent.Future;
import org.opendaylight.yang.gen.v1.urn.opendaylight.flow.statistics.rev130819.AggregateFlowStatisticsUpdateBuilder;
import org.opendaylight.yang.gen.v1.urn.opendaylight.flow.statistics.rev130819.FlowsStatisticsUpdateBuilder;
import org.opendaylight.yang.gen.v1.urn.opendaylight.flow.statistics.rev130819.GetAggregateFlowStatisticsFromFlowTableForAllFlowsInput;
import org.opendaylight.yangtools.yang.common.RpcResult;
import org.opendaylight.yangtools.yang.common.RpcResultBuilder;
-import java.math.BigInteger;
-import java.util.ArrayList;
-import java.util.List;
-import java.util.concurrent.Future;
-import java.util.concurrent.atomic.AtomicLong;
-
public class OpendaylightFlowStatisticsServiceMock implements OpendaylightFlowStatisticsService {
NotificationProviderServiceHelper notifService;
- AtomicLong transNum = new AtomicLong();
public OpendaylightFlowStatisticsServiceMock(NotificationProviderServiceHelper notifService) {
this.notifService = notifService;
@Override
public Future<RpcResult<GetAggregateFlowStatisticsFromFlowTableForAllFlowsOutput>> getAggregateFlowStatisticsFromFlowTableForAllFlows(GetAggregateFlowStatisticsFromFlowTableForAllFlowsInput input) {
GetAggregateFlowStatisticsFromFlowTableForAllFlowsOutputBuilder builder = new GetAggregateFlowStatisticsFromFlowTableForAllFlowsOutputBuilder();
- TransactionId transId = new TransactionId(BigInteger.valueOf(transNum.incrementAndGet()));
+ TransactionId transId = new TransactionId(BigInteger.valueOf(TestUtils.getNewTransactionId()));
builder.setTransactionId(transId);
return Futures.immediateFuture(RpcResultBuilder.success(builder.build()).build());
}
@Override
public Future<RpcResult<GetAggregateFlowStatisticsFromFlowTableForGivenMatchOutput>> getAggregateFlowStatisticsFromFlowTableForGivenMatch(GetAggregateFlowStatisticsFromFlowTableForGivenMatchInput input) {
GetAggregateFlowStatisticsFromFlowTableForGivenMatchOutputBuilder builder = new GetAggregateFlowStatisticsFromFlowTableForGivenMatchOutputBuilder();
- TransactionId transId = new TransactionId(BigInteger.valueOf(transNum.incrementAndGet()));
+ TransactionId transId = new TransactionId(BigInteger.valueOf(TestUtils.getNewTransactionId()));
builder.setTransactionId(transId);
AggregateFlowStatisticsUpdateBuilder afsuBuilder = new AggregateFlowStatisticsUpdateBuilder();
afsuBuilder.setMoreReplies(false);
@Override
public Future<RpcResult<GetAllFlowStatisticsFromFlowTableOutput>> getAllFlowStatisticsFromFlowTable(GetAllFlowStatisticsFromFlowTableInput input) {
GetAllFlowStatisticsFromFlowTableOutputBuilder builder = new GetAllFlowStatisticsFromFlowTableOutputBuilder();
- TransactionId transId = new TransactionId(BigInteger.valueOf(transNum.incrementAndGet()));
+ TransactionId transId = new TransactionId(BigInteger.valueOf(TestUtils.getNewTransactionId()));
builder.setTransactionId(transId);
return Futures.immediateFuture(RpcResultBuilder.success(builder.build()).build());
}
@Override
public Future<RpcResult<GetAllFlowsStatisticsFromAllFlowTablesOutput>> getAllFlowsStatisticsFromAllFlowTables(GetAllFlowsStatisticsFromAllFlowTablesInput input) {
GetAllFlowsStatisticsFromAllFlowTablesOutputBuilder builder = new GetAllFlowsStatisticsFromAllFlowTablesOutputBuilder();
- TransactionId transId = new TransactionId(BigInteger.valueOf(transNum.incrementAndGet()));
+ TransactionId transId = new TransactionId(BigInteger.valueOf(TestUtils.getNewTransactionId()));
builder.setTransactionId(transId);
List<FlowAndStatisticsMapList> flowAndStatisticsMapLists = new ArrayList<>();
FlowsStatisticsUpdateBuilder flowsStatisticsUpdateBuilder = new FlowsStatisticsUpdateBuilder();
@Override
public Future<RpcResult<GetFlowStatisticsFromFlowTableOutput>> getFlowStatisticsFromFlowTable(GetFlowStatisticsFromFlowTableInput input) {
GetFlowStatisticsFromFlowTableOutputBuilder builder = new GetFlowStatisticsFromFlowTableOutputBuilder();
- TransactionId transId = new TransactionId(BigInteger.valueOf(transNum.incrementAndGet()));
+ TransactionId transId = new TransactionId(BigInteger.valueOf(TestUtils.getNewTransactionId()));
builder.setTransactionId(transId);
List<FlowAndStatisticsMapList> flowAndStatisticsMapLists = new ArrayList<>();
FlowsStatisticsUpdateBuilder flowsStatisticsUpdateBuilder = new FlowsStatisticsUpdateBuilder();
package test.mock.util;
import com.google.common.util.concurrent.Futures;
+import java.math.BigInteger;
+import java.util.ArrayList;
+import java.util.List;
+import java.util.concurrent.Future;
import org.opendaylight.yang.gen.v1.urn.opendaylight.flow.table.statistics.rev131215.FlowTableStatisticsUpdateBuilder;
import org.opendaylight.yang.gen.v1.urn.opendaylight.flow.table.statistics.rev131215.GetFlowTablesStatisticsInput;
import org.opendaylight.yang.gen.v1.urn.opendaylight.flow.table.statistics.rev131215.GetFlowTablesStatisticsOutput;
import org.opendaylight.yangtools.yang.common.RpcResult;
import org.opendaylight.yangtools.yang.common.RpcResultBuilder;
-import java.math.BigInteger;
-import java.util.ArrayList;
-import java.util.List;
-import java.util.concurrent.Future;
-import java.util.concurrent.atomic.AtomicLong;
-
public class OpendaylightFlowTableStatisticsServiceMock implements OpendaylightFlowTableStatisticsService {
NotificationProviderServiceHelper notifService;
- AtomicLong transNum = new AtomicLong();
public OpendaylightFlowTableStatisticsServiceMock(NotificationProviderServiceHelper notifService) {
this.notifService = notifService;
@Override
public Future<RpcResult<GetFlowTablesStatisticsOutput>> getFlowTablesStatistics(GetFlowTablesStatisticsInput input) {
GetFlowTablesStatisticsOutputBuilder builder = new GetFlowTablesStatisticsOutputBuilder();
- TransactionId transId = new TransactionId(BigInteger.valueOf(transNum.incrementAndGet()));
+ TransactionId transId = new TransactionId(BigInteger.valueOf(TestUtils.getNewTransactionId()));
builder.setTransactionId(transId);
FlowTableStatisticsUpdateBuilder ftsBuilder = new FlowTableStatisticsUpdateBuilder();
FlowTableAndStatisticsMapBuilder ftasmBuilder = new FlowTableAndStatisticsMapBuilder();
package test.mock.util;
import com.google.common.util.concurrent.Futures;
+import java.math.BigInteger;
+import java.util.ArrayList;
+import java.util.List;
+import java.util.concurrent.Future;
import org.opendaylight.yang.gen.v1.urn.opendaylight.flow.transaction.rev131103.TransactionId;
import org.opendaylight.yang.gen.v1.urn.opendaylight.group.statistics.rev131111.GetAllGroupStatisticsInput;
import org.opendaylight.yang.gen.v1.urn.opendaylight.group.statistics.rev131111.GetAllGroupStatisticsOutput;
import org.opendaylight.yangtools.yang.common.RpcResult;
import org.opendaylight.yangtools.yang.common.RpcResultBuilder;
-import java.math.BigInteger;
-import java.util.ArrayList;
-import java.util.List;
-import java.util.concurrent.Future;
-import java.util.concurrent.atomic.AtomicLong;
-
public class OpendaylightGroupStatisticsServiceMock implements OpendaylightGroupStatisticsService {
NotificationProviderServiceHelper notifService;
- AtomicLong transNum = new AtomicLong();
public OpendaylightGroupStatisticsServiceMock(NotificationProviderServiceHelper notifService) {
this.notifService = notifService;
@Override
public Future<RpcResult<GetAllGroupStatisticsOutput>> getAllGroupStatistics(GetAllGroupStatisticsInput input) {
GetAllGroupStatisticsOutputBuilder builder = new GetAllGroupStatisticsOutputBuilder();
- TransactionId transId = new TransactionId(BigInteger.valueOf(transNum.incrementAndGet()));
+ TransactionId transId = new TransactionId(BigInteger.valueOf(TestUtils.getNewTransactionId()));
builder.setTransactionId(transId);
List<GroupStats> groupStats = new ArrayList<>();
GroupStatsBuilder gsBuilder = new GroupStatsBuilder();
@Override
public Future<RpcResult<GetGroupDescriptionOutput>> getGroupDescription(GetGroupDescriptionInput input) {
GetGroupDescriptionOutputBuilder builder = new GetGroupDescriptionOutputBuilder();
- TransactionId transId = new TransactionId(BigInteger.valueOf(transNum.incrementAndGet()));
+ TransactionId transId = new TransactionId(BigInteger.valueOf(TestUtils.getNewTransactionId()));
builder.setTransactionId(transId);
List<GroupDescStats> groupDescStats = new ArrayList<>();
GroupDescStatsUpdatedBuilder gdsuBuilder = new GroupDescStatsUpdatedBuilder();
@Override
public Future<RpcResult<GetGroupFeaturesOutput>> getGroupFeatures(GetGroupFeaturesInput input) {
GetGroupFeaturesOutputBuilder builder = new GetGroupFeaturesOutputBuilder();
- TransactionId transId = new TransactionId(BigInteger.valueOf(transNum.incrementAndGet()));
+ TransactionId transId = new TransactionId(BigInteger.valueOf(TestUtils.getNewTransactionId()));
builder.setTransactionId(transId);
GroupFeaturesUpdatedBuilder gfuBuilder = new GroupFeaturesUpdatedBuilder();
gfuBuilder.setTransactionId(transId);
@Override
public Future<RpcResult<GetGroupStatisticsOutput>> getGroupStatistics(GetGroupStatisticsInput input) {
GetGroupStatisticsOutputBuilder builder = new GetGroupStatisticsOutputBuilder();
- TransactionId transId = new TransactionId(BigInteger.valueOf(transNum.incrementAndGet()));
+ TransactionId transId = new TransactionId(BigInteger.valueOf(TestUtils.getNewTransactionId()));
builder.setTransactionId(transId);
GroupStatsBuilder gsBuilder = new GroupStatsBuilder();
List<GroupStats> groupStats = new ArrayList<>();
package test.mock.util;
import com.google.common.util.concurrent.Futures;
+import java.math.BigInteger;
+import java.util.ArrayList;
+import java.util.List;
+import java.util.concurrent.Future;
import org.opendaylight.yang.gen.v1.urn.opendaylight.flow.transaction.rev131103.TransactionId;
import org.opendaylight.yang.gen.v1.urn.opendaylight.inventory.rev130819.nodes.Node;
import org.opendaylight.yang.gen.v1.urn.opendaylight.inventory.rev130819.nodes.NodeKey;
import org.opendaylight.yangtools.yang.common.RpcResult;
import org.opendaylight.yangtools.yang.common.RpcResultBuilder;
-import java.math.BigInteger;
-import java.util.ArrayList;
-import java.util.List;
-import java.util.concurrent.Future;
-import java.util.concurrent.atomic.AtomicLong;
-
public class OpendaylightMeterStatisticsServiceMock implements OpendaylightMeterStatisticsService {
NotificationProviderServiceHelper notifService;
- AtomicLong transNum = new AtomicLong();
public OpendaylightMeterStatisticsServiceMock(NotificationProviderServiceHelper notifService) {
this.notifService = notifService;
@Override
public Future<RpcResult<GetAllMeterConfigStatisticsOutput>> getAllMeterConfigStatistics(GetAllMeterConfigStatisticsInput input) {
GetAllMeterConfigStatisticsOutputBuilder builder = new GetAllMeterConfigStatisticsOutputBuilder();
- TransactionId transId = new TransactionId(BigInteger.valueOf(transNum.incrementAndGet()));
+ TransactionId transId = new TransactionId(BigInteger.valueOf(TestUtils.getNewTransactionId()));
builder.setTransactionId(transId);
List<MeterConfigStats> meterConfigStats = new ArrayList<>();
MeterConfigStatsBuilder mcsBuilder = new MeterConfigStatsBuilder();
@Override
public Future<RpcResult<GetAllMeterStatisticsOutput>> getAllMeterStatistics(GetAllMeterStatisticsInput input) {
GetAllMeterStatisticsOutputBuilder builder = new GetAllMeterStatisticsOutputBuilder();
- TransactionId transId = new TransactionId(BigInteger.valueOf(transNum.incrementAndGet()));
+ TransactionId transId = new TransactionId(BigInteger.valueOf(TestUtils.getNewTransactionId()));
builder.setTransactionId(transId);
MeterStatsBuilder msBuilder = new MeterStatsBuilder();
msBuilder.setByteInCount(StatisticsManagerTest.COUNTER_64_TEST_VALUE);
@Override
public Future<RpcResult<GetMeterFeaturesOutput>> getMeterFeatures(GetMeterFeaturesInput input) {
GetMeterFeaturesOutputBuilder builder = new GetMeterFeaturesOutputBuilder();
- TransactionId transId = new TransactionId(BigInteger.valueOf(transNum.incrementAndGet()));
+ TransactionId transId = new TransactionId(BigInteger.valueOf(TestUtils.getNewTransactionId()));
builder.setTransactionId(transId);
MeterFeaturesUpdatedBuilder mfuBuilder = new MeterFeaturesUpdatedBuilder();
mfuBuilder.setTransactionId(transId);
@Override
public Future<RpcResult<GetMeterStatisticsOutput>> getMeterStatistics(GetMeterStatisticsInput input) {
GetMeterStatisticsOutputBuilder builder = new GetMeterStatisticsOutputBuilder();
- TransactionId transId = new TransactionId(BigInteger.valueOf(transNum.incrementAndGet()));
+ TransactionId transId = new TransactionId(BigInteger.valueOf(TestUtils.getNewTransactionId()));
builder.setTransactionId(transId);
MeterStatsBuilder msBuilder = new MeterStatsBuilder();
msBuilder.setKey(new MeterStatsKey(input.getMeterId()));
package test.mock.util;
import com.google.common.util.concurrent.Futures;
+import java.math.BigInteger;
+import java.util.ArrayList;
+import java.util.List;
+import java.util.concurrent.Future;
import org.opendaylight.yang.gen.v1.urn.opendaylight.flow.transaction.rev131103.TransactionId;
import org.opendaylight.yang.gen.v1.urn.opendaylight.inventory.rev130819.nodes.Node;
import org.opendaylight.yang.gen.v1.urn.opendaylight.inventory.rev130819.nodes.NodeKey;
import org.opendaylight.yangtools.yang.common.RpcResult;
import org.opendaylight.yangtools.yang.common.RpcResultBuilder;
-import java.math.BigInteger;
-import java.util.ArrayList;
-import java.util.List;
-import java.util.concurrent.Future;
-import java.util.concurrent.atomic.AtomicLong;
-
public class OpendaylightPortStatisticsServiceMock implements OpendaylightPortStatisticsService {
NotificationProviderServiceHelper notifService;
- AtomicLong transNum = new AtomicLong();
public OpendaylightPortStatisticsServiceMock(NotificationProviderServiceHelper notifService) {
this.notifService = notifService;
@Override
public Future<RpcResult<GetAllNodeConnectorsStatisticsOutput>> getAllNodeConnectorsStatistics(GetAllNodeConnectorsStatisticsInput input) {
GetAllNodeConnectorsStatisticsOutputBuilder builder = new GetAllNodeConnectorsStatisticsOutputBuilder();
- TransactionId transId = new TransactionId(BigInteger.valueOf(transNum.incrementAndGet()));
+ TransactionId transId = new TransactionId(BigInteger.valueOf(TestUtils.getNewTransactionId()));
builder.setTransactionId(transId);
NodeConnectorStatisticsUpdateBuilder ncsuBuilder = new NodeConnectorStatisticsUpdateBuilder();
NodeConnectorStatisticsAndPortNumberMapBuilder ncsapnmBuilder = new NodeConnectorStatisticsAndPortNumberMapBuilder();
ncsapnmBuilder.setKey(new NodeConnectorStatisticsAndPortNumberMapKey(StatisticsManagerTest.getNodeConnectorId()));
ncsapnmBuilder.setReceiveDrops(StatisticsManagerTest.BIG_INTEGER_TEST_VALUE);
nodeConnectorStatisticsAndPortNumberMaps.add(ncsapnmBuilder.build());
- ncsuBuilder.setTransactionId(new TransactionId(BigInteger.valueOf(1)));
+ ncsuBuilder.setTransactionId(transId);
ncsuBuilder.setId(input.getNode().getValue().firstKeyOf(Node.class, NodeKey.class).getId());
ncsuBuilder.setNodeConnectorStatisticsAndPortNumberMap(nodeConnectorStatisticsAndPortNumberMaps);
ncsuBuilder.setMoreReplies(true);
@Override
public Future<RpcResult<GetNodeConnectorStatisticsOutput>> getNodeConnectorStatistics(GetNodeConnectorStatisticsInput input) {
GetNodeConnectorStatisticsOutputBuilder builder = new GetNodeConnectorStatisticsOutputBuilder();
- TransactionId transId = new TransactionId(BigInteger.valueOf(transNum.incrementAndGet()));
+ TransactionId transId = new TransactionId(BigInteger.valueOf(TestUtils.getNewTransactionId()));
builder.setTransactionId(transId);
return Futures.immediateFuture(RpcResultBuilder.success(builder.build()).build());
}
@Override
public Future<RpcResult<GetAllQueuesStatisticsFromAllPortsOutput>> getAllQueuesStatisticsFromAllPorts(GetAllQueuesStatisticsFromAllPortsInput input) {
GetAllQueuesStatisticsFromAllPortsOutputBuilder builder = new GetAllQueuesStatisticsFromAllPortsOutputBuilder();
- TransactionId transId = new TransactionId(BigInteger.valueOf(transNum.incrementAndGet()));
+ TransactionId transId = new TransactionId(BigInteger.valueOf(TestUtils.getNewTransactionId()));
builder.setTransactionId(transId);
QueueStatisticsUpdateBuilder qsuBuilder = new QueueStatisticsUpdateBuilder();
QueueIdAndStatisticsMapBuilder qiasmBuilder = new QueueIdAndStatisticsMapBuilder();
@Override
public Future<RpcResult<GetAllQueuesStatisticsFromGivenPortOutput>> getAllQueuesStatisticsFromGivenPort(GetAllQueuesStatisticsFromGivenPortInput input) {
GetAllQueuesStatisticsFromGivenPortOutputBuilder builder = new GetAllQueuesStatisticsFromGivenPortOutputBuilder();
- TransactionId transId = new TransactionId(BigInteger.valueOf(transNum.incrementAndGet()));
+ TransactionId transId = new TransactionId(BigInteger.valueOf(TestUtils.getNewTransactionId()));
builder.setTransactionId(transId);
return Futures.immediateFuture(RpcResultBuilder.success(builder.build()).build());
}
@Override
public Future<RpcResult<GetQueueStatisticsFromGivenPortOutput>> getQueueStatisticsFromGivenPort(GetQueueStatisticsFromGivenPortInput input) {
GetQueueStatisticsFromGivenPortOutputBuilder builder = new GetQueueStatisticsFromGivenPortOutputBuilder();
- TransactionId transId = new TransactionId(BigInteger.valueOf(transNum.incrementAndGet()));
+ TransactionId transId = new TransactionId(BigInteger.valueOf(TestUtils.getNewTransactionId()));
builder.setTransactionId(transId);
QueueIdAndStatisticsMapBuilder qiasmBuilder = new QueueIdAndStatisticsMapBuilder();
List<QueueIdAndStatisticsMap> queueIdAndStatisticsMaps = new ArrayList<>();
+++ /dev/null
-package test.mock.util;
-
-import org.opendaylight.controller.md.sal.binding.api.DataBroker;
-import org.opendaylight.controller.md.sal.common.api.routing.RouteChangeListener;
-import org.opendaylight.controller.sal.binding.api.BindingAwareBroker;
-import org.opendaylight.controller.sal.binding.api.BindingAwareProvider;
-import org.opendaylight.controller.sal.binding.api.BindingAwareService;
-import org.opendaylight.controller.sal.binding.api.NotificationProviderService;
-import org.opendaylight.controller.sal.binding.api.RpcProviderRegistry;
-import org.opendaylight.controller.sal.binding.api.rpc.RpcContextIdentifier;
-import org.opendaylight.yangtools.concepts.ListenerRegistration;
-import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
-import org.opendaylight.yangtools.yang.binding.RpcService;
-
-public class ProviderContextMock implements BindingAwareBroker.ProviderContext {
-
- RpcProviderRegistry rpcProviderMock;
- NotificationProviderService notificationProviderService;
- DataBroker dataBroker;
-
- public ProviderContextMock(RpcProviderRegistry rpcProviderMock, DataBroker dataBroker,
- NotificationProviderService notificationProviderServiceMock) {
- this.rpcProviderMock = rpcProviderMock;
- this.dataBroker = dataBroker;
- this.notificationProviderService = notificationProviderServiceMock;
- }
-
- @Override
- public void registerFunctionality(BindingAwareProvider.ProviderFunctionality functionality) {
-
- }
-
- @Override
- public void unregisterFunctionality(BindingAwareProvider.ProviderFunctionality functionality) {
-
- }
-
- @SuppressWarnings("unchecked")
- @Override
- public <T extends BindingAwareService> T getSALService(Class<T> service) {
- if (service.equals(DataBroker.class)) {
- return (T) dataBroker;
- }
- else if (service.equals(NotificationProviderService.class)) {
- return (T) notificationProviderService;
- }
- return null;
- }
-
- @Override
- public <T extends RpcService> BindingAwareBroker.RpcRegistration<T> addRpcImplementation(Class<T> serviceInterface, T implementation) throws IllegalStateException {
- return null;
- }
-
- @Override
- public <T extends RpcService> BindingAwareBroker.RoutedRpcRegistration<T> addRoutedRpcImplementation(Class<T> serviceInterface, T implementation) throws IllegalStateException {
- return null;
- }
-
- @Override
- public <L extends RouteChangeListener<RpcContextIdentifier, InstanceIdentifier<?>>> ListenerRegistration<L> registerRouteChangeListener(L listener) {
- return null;
- }
-
- @Override
- public <T extends RpcService> T getRpcService(Class<T> serviceInterface) {
- return rpcProviderMock.getRpcService(serviceInterface);
- }
-}
package test.mock.util;
+import java.math.BigInteger;
+import java.util.ArrayList;
+import java.util.Collections;
+import java.util.List;
+import java.util.concurrent.ExecutionException;
import org.junit.Before;
import org.junit.BeforeClass;
import org.opendaylight.controller.md.sal.binding.api.WriteTransaction;
import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType;
+import org.opendaylight.controller.md.statistics.manager.StatisticsManager;
+import org.opendaylight.controller.md.statistics.manager.impl.StatisticsManagerConfig;
+import org.opendaylight.controller.md.statistics.manager.impl.StatisticsManagerImpl;
import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.yang.types.rev100924.Counter32;
import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.yang.types.rev100924.Counter64;
import org.opendaylight.yang.gen.v1.urn.opendaylight.flow.inventory.rev130819.FeatureCapability;
import org.opendaylight.yang.gen.v1.urn.opendaylight.table.types.rev131026.TableId;
import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
-import java.math.BigInteger;
-import java.util.ArrayList;
-import java.util.Collections;
-import java.util.List;
-import java.util.concurrent.ExecutionException;
-
public abstract class StatisticsManagerTest extends AbstractDataBrokerTest {
public static final Counter64 COUNTER_64_TEST_VALUE = new Counter64(BigInteger.valueOf(128));
public static final Long MAX_GROUPS_TEST_VALUE = 2000L;
public static final BigInteger BIG_INTEGER_TEST_VALUE = BigInteger.valueOf(1000);
+ private static final int DEFAULT_MIN_REQUEST_NET_MONITOR_INTERVAL = 5000;
+ private static final int MAX_NODES_FOR_COLLECTOR = 16;
+
private static Flow flow;
private static Group group;
private static Meter meter;
private final NotificationProviderServiceHelper notificationMock = new NotificationProviderServiceHelper();
protected final NodeKey s1Key = new NodeKey(new NodeId("S1"));
protected RpcProviderRegistryMock rpcRegistry;
- protected ProviderContextMock providerContext;
@BeforeClass
public static void setupTests() {
@Before
public void init() {
rpcRegistry = new RpcProviderRegistryMock(notificationMock);
- providerContext = new ProviderContextMock(rpcRegistry, getDataBroker(), notificationMock.getNotifBroker());
}
// node with statistics capabilities will enable cyclic statistics collection
capabilitiyList.add(capability);
}
sfBuilder.setCapabilities(capabilitiyList);
- sfBuilder.setMaxTables((short) 2);
+ sfBuilder.setMaxTables((short) 255);
final NodeBuilder nodeBuilder = new NodeBuilder();
nodeBuilder.setKey(nodeKey);
fcnBuilder.setSwitchFeatures(sfBuilder.build());
final FlowCapableNodeBuilder fcnBuilder = new FlowCapableNodeBuilder();
final NodeBuilder nodeBuilder = new NodeBuilder();
nodeBuilder.setKey(nodeKey);
+ final SwitchFeaturesBuilder sfBuilder = new SwitchFeaturesBuilder();
+ sfBuilder.setMaxTables((short) 255);
+ fcnBuilder.setSwitchFeatures(sfBuilder.build());
final FlowCapableNode flowCapableNode = fcnBuilder.build();
nodeBuilder.addAugmentation(FlowCapableNode.class, flowCapableNode);
final Node node = nodeBuilder.build();
notificationMock.pushNotification(nrBuilder.build());
}
+ public StatisticsManager setupStatisticsManager() {
+ StatisticsManagerConfig.StatisticsManagerConfigBuilder confBuilder = StatisticsManagerConfig.builder();
+ confBuilder.setMaxNodesForCollector(MAX_NODES_FOR_COLLECTOR);
+ confBuilder.setMinRequestNetMonitorInterval(DEFAULT_MIN_REQUEST_NET_MONITOR_INTERVAL);
+ StatisticsManager statsProvider = new StatisticsManagerImpl(getDataBroker(), confBuilder.build());
+ statsProvider.start(notificationMock.getNotifBroker(), rpcRegistry);
+ return statsProvider;
+ }
+
public static Flow getFlow() {
return flow;
}
package test.mock.util;
import java.util.Random;
+import java.util.concurrent.atomic.AtomicLong;
public class TestUtils {
+
+ private static AtomicLong transId = new AtomicLong();
+
private static Random rnd = new Random();
public static long nextLong(long RangeBottom, long rangeTop) {
return RangeBottom + ((long)(rnd.nextDouble()*(rangeTop - RangeBottom)));
}
+
+ public static long getNewTransactionId() {
+ return transId.incrementAndGet();
+ }
}
void validate() {
checkArgument(deviceCount > 0, "Device count has to be > 0");
- checkArgument(startingPort > 1024, "Starting port has to be > 1024");
+ checkArgument(startingPort > 1023, "Starting port has to be > 1023");
if(schemasDir != null) {
checkArgument(schemasDir.exists(), "Schemas dir has to exist");
final NetconfDeviceSimulator netconfDeviceSimulator = new NetconfDeviceSimulator();
try {
final List<Integer> openDevices = netconfDeviceSimulator.start(params);
+ if (openDevices.size() == 0) {
+ LOG.error("Failed to start any simulated devices, exiting...");
+ System.exit(1);
+ }
if(params.distroFolder != null) {
final ConfigGenerator configGenerator = new ConfigGenerator(params.distroFolder, openDevices);
final List<File> generated = configGenerator.generate(params.ssh, params.generateConfigBatchSize, params.generateConfigsTimeout, params.generateConfigsAddress);
final PEMGeneratorHostKeyProvider keyPairProvider = getPemGeneratorHostKeyProvider();
for (int i = 0; i < params.deviceCount; i++) {
+ if (currentPort > 65535) {
+ LOG.warn("Port cannot be greater than 65535, stopping further attempts.");
+ break;
+ }
final InetSocketAddress address = getAddress(currentPort);
final ChannelFuture server;
if(openDevices.size() == params.deviceCount) {
LOG.info("All simulated devices started successfully from port {} to {}", params.startingPort, currentPort - 1);
+ } else if (openDevices.size() == 0) {
+ LOG.warn("No simulated devices started.");
} else {
LOG.warn("Not all simulated devices started successfully. Started devices ar on ports {}", openDevices);
}