Aaron Kruglikov
Committed by Gerrit Code Review

Creating persistence service.

Change-Id: Ib78b4001a24c71b4096e5a2a446dbd5009aa1090
......@@ -19,7 +19,6 @@
<command>
<action class="org.onosproject.cli.SummaryCommand"/>
</command>
<command>
<action class="org.onosproject.cli.security.ReviewCommand"/>
<completers>
......
......@@ -63,6 +63,11 @@
<artifactId>onlab-rest</artifactId>
<version>${project.version}</version>
</dependency>
<dependency>
<groupId>org.mapdb</groupId>
<artifactId>mapdb</artifactId>
<version>1.0.8</version>
</dependency>
</dependencies>
</project>
......
/*
* Copyright 2015 Open Networking Laboratory
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package org.onosproject.persistence;
/**
* Service that allows for the creation of local disk backed map for instance specific values that persist across
* restarts. Empty maps and sets are deleted on shutdown.
*/
public interface PersistenceService {
/**
* A builder for the creation of local persistent maps backed by disk.
*
* @param <K> the type of keys in this map
* @param <V> the type of values in this map
* @return a persistent map builder
*/
<K, V> PersistentMapBuilder<K, V> persistentMapBuilder();
/**
* A builder for the creation of local persistent sets backed by disk.
*
* @param <E> the type of the elements
* @return a persistent set builder
*/
<E> PersistentSetBuilder<E> persistentSetBuilder();
}
\ No newline at end of file
/*
* Copyright 2015 Open Networking Laboratory
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package org.onosproject.persistence;
import org.onosproject.store.service.Serializer;
import java.util.Map;
/**
* The interface for a persistent map builder for use with mapDB.
*/
public interface PersistentMapBuilder<K, V> {
/**
* Sets the name of this map.
* @param name the string name of this map
* @return a persistent map builder with the name option now set
*/
PersistentMapBuilder<K, V> withName(String name);
/**
* Sets the key serializer to be used to serialize this map, this is a required parameter.
* @param serializer the serializer to be used for keys
* @return a persistent map builder with the key serializer set
*/
PersistentMapBuilder<K, V> withSerializer(Serializer serializer);
/**
* Validates the map settings and then builds this map in the database. Throws an exception if invalid settings
* are found.
* @return The map that was created
*/
Map<K, V> build();
}
\ No newline at end of file
/*
* Copyright 2015 Open Networking Laboratory
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package org.onosproject.persistence;
import org.onosproject.store.service.Serializer;
import java.util.Set;
/**
* The default interface for the persistent set builder for use with mapDB.
*/
public interface PersistentSetBuilder<E> {
/**
* Sets the name of this set.
* @param name the string name of this set
* @return a persistent set builder with the name option now set
*/
PersistentSetBuilder<E> withName(String name);
/**
* Sets the serializer to be used to serialize this set, this is a required parameter.
* @param serializer the serializer to be used
* @return a persistent set builder with the serializer set
*/
PersistentSetBuilder<E> withSerializer(Serializer serializer);
/**
* Validates the set settings and then builds this map in the database. Throws an exception if invalid settings
* are found.
* @return The set that was created
*/
Set<E> build();
}
\ No newline at end of file
......@@ -71,7 +71,7 @@
<dependency>
<groupId>org.mapdb</groupId>
<artifactId>mapdb</artifactId>
<version>1.0.7</version>
<version>1.0.8</version>
</dependency>
<dependency>
......
<?xml version="1.0" encoding="UTF-8"?>
<!--
~ Copyright 2015 Open Networking Laboratory
~
~ Licensed under the Apache License, Version 2.0 (the "License");
~ you may not use this file except in compliance with the License.
~ You may obtain a copy of the License at
~
~ http://www.apache.org/licenses/LICENSE-2.0
~
~ Unless required by applicable law or agreed to in writing, software
~ distributed under the License is distributed on an "AS IS" BASIS,
~ WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
~ See the License for the specific language governing permissions and
~ limitations under the License.
-->
<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/maven-v4_0_0.xsd">
<modelVersion>4.0.0</modelVersion>
<repositories>
<repository>
<id>repository.springsource.com.release</id>
<name>SpringSource OBR - Release</name>
<url>http://repository.springsource.com/maven/bundles/release</url>
</repository>
<repository>
<id>repository.springsource.com.external</id>
<name>SpringSource OBR - External</name>
<url>http://repository.springsource.com/maven/bundles/external</url>
</repository>
</repositories>
<parent>
<groupId>org.onosproject</groupId>
<artifactId>onos-core-store</artifactId>
<version>1.4.0-SNAPSHOT</version>
<relativePath>../pom.xml</relativePath>
</parent>
<artifactId>onos-core-persistence</artifactId>
<packaging>bundle</packaging>
<description>ONOS Core persistent local store subsystem</description>
<dependencies>
<dependency>
<groupId>org.onosproject</groupId>
<artifactId>onos-api</artifactId>
</dependency>
<dependency>
<groupId>org.mapdb</groupId>
<artifactId>mapdb</artifactId>
<version>1.0.8</version>
</dependency>
<dependency>
<groupId>org.junit</groupId>
<artifactId>com.springsource.org.junit</artifactId>
<version>4.11.0</version>
</dependency>
</dependencies>
</project>
/*
* Copyright 2015 Open Networking Laboratory
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package org.onosproject.persistence.impl;
import org.mapdb.DB;
import org.onosproject.persistence.PersistentMapBuilder;
import org.onosproject.store.service.Serializer;
import java.util.Map;
import static com.google.common.base.Preconditions.checkArgument;
import static com.google.common.base.Preconditions.checkNotNull;
/**
* Default builder for persistent maps stored in the mapDB local database via the persistence service.
*/
public class DefaultPersistentMapBuilder<K, V> implements PersistentMapBuilder<K, V> {
private final DB localDB;
private String name = null;
private Serializer serializer = null;
public DefaultPersistentMapBuilder(DB localDB) {
checkNotNull(localDB, "The local database cannot be null.");
this.localDB = localDB;
}
public PersistentMapBuilder<K, V> withName(String name) {
this.name = PersistenceManager.MAP_PREFIX + checkNotNull(name);
return this;
}
public PersistentMapBuilder<K, V> withSerializer(Serializer serializer) {
checkArgument(this.serializer == null);
checkNotNull(serializer);
this.serializer = serializer;
return this;
}
public Map<K, V> build() {
checkNotNull(name, "The name must be assigned.");
checkNotNull(serializer, "The key serializer must be assigned.");
return new PersistentMap<K, V>(serializer, localDB, name);
}
}
\ No newline at end of file
/*
* Copyright 2015 Open Networking Laboratory
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package org.onosproject.persistence.impl;
import org.mapdb.DB;
import org.onosproject.persistence.PersistentSetBuilder;
import org.onosproject.store.service.Serializer;
import static com.google.common.base.Preconditions.checkArgument;
import static com.google.common.base.Preconditions.checkNotNull;
/**
* Default builder for persistent sets stored in the mapDB local database via the persistence service..
*/
public class DefaultPersistentSetBuilder<E> implements PersistentSetBuilder<E> {
private final DB localDB;
private String name = null;
private Serializer serializer = null;
public DefaultPersistentSetBuilder(DB localDB) {
this.localDB = checkNotNull(localDB, "The local database cannot be null.");
}
public PersistentSetBuilder<E> withName(String name) {
this.name = PersistenceManager.SET_PREFIX + checkNotNull(name);
return this;
}
public PersistentSetBuilder<E> withSerializer(Serializer serializer) {
checkArgument(this.serializer == null);
checkNotNull(serializer);
this.serializer = serializer;
return this;
}
public PersistentSet<E> build() {
checkNotNull(name, "The name must be assigned.");
checkNotNull(serializer, "The serializer must be assigned.");
return new PersistentSet<E>(serializer, localDB, name);
}
}
\ No newline at end of file
/*
* Copyright 2015 Open Networking Laboratory
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package org.onosproject.persistence.impl;
/**
* An exception defined for failures of the local persistent store system.
*/
/**
* Throws an exception with the specified message.
*/
public class PersistenceException extends RuntimeException {
public PersistenceException(String s) {
super(s);
}
}
/*
* Copyright 2015 Open Networking Laboratory
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package org.onosproject.persistence.impl;
import org.apache.felix.scr.annotations.Activate;
import org.apache.felix.scr.annotations.Component;
import org.apache.felix.scr.annotations.Deactivate;
import org.apache.felix.scr.annotations.Service;
import org.mapdb.DB;
import org.mapdb.DBMaker;
import org.onosproject.persistence.PersistenceService;
import org.onosproject.persistence.PersistentMapBuilder;
import org.onosproject.persistence.PersistentSetBuilder;
import org.slf4j.Logger;
import java.io.IOException;
import java.nio.file.Files;
import java.nio.file.Path;
import java.nio.file.Paths;
import java.util.Map;
import java.util.Set;
import java.util.Timer;
import java.util.TimerTask;
import static org.slf4j.LoggerFactory.getLogger;
/**
* Service that maintains local disk backed maps and sets. This implementation automatically deletes empty structures
* on shutdown.
*/
@Component(immediate = true)
@Service
public class PersistenceManager implements PersistenceService {
private static final String DATABASE_PATH = "../data/localDB";
private static final String ENCLOSING_FOLDER = "../data";
static final String MAP_PREFIX = "map:";
static final String SET_PREFIX = "set:";
private final Logger log = getLogger(getClass());
private DB localDB = null;
private static final int FLUSH_FREQUENCY_MILLIS = 3000;
private final Timer timer = new Timer();
private final CommitTask commitTask = new CommitTask();
@Activate
public void activate() {
Path dbPath = Paths.get(DATABASE_PATH);
Path dbFolderPath = Paths.get(ENCLOSING_FOLDER);
//Make sure the directory exists, if it does not, make it.
if (!dbFolderPath.toFile().isDirectory()) {
log.info("The specified folder location for the database did not exist and will be created.");
try {
Files.createDirectories(dbFolderPath);
} catch (IOException e) {
log.error("Could not create the required folder for the database.");
throw new PersistenceException("Database folder could not be created.");
}
}
//Notify if the database file does not exist.
boolean dbFound = Files.exists(dbPath);
if (!dbFound) {
log.info("The database file could not be located, a new database will be constructed.");
} else {
log.info("A previous database file has been found.");
}
localDB = DBMaker.newFileDB(dbPath.toFile())
.asyncWriteEnable()
.closeOnJvmShutdown()
.make();
timer.schedule(commitTask, FLUSH_FREQUENCY_MILLIS, FLUSH_FREQUENCY_MILLIS);
log.info("Started");
}
@Deactivate
public void deactivate() {
for (Map.Entry<String, Object> entry : localDB.getAll().entrySet()) {
String key = entry.getKey();
Object value = entry.getValue();
//This is a map implementation to be handled as such
if (value instanceof Map) {
Map asMap = (Map) value;
if (asMap.isEmpty()) {
//the map is empty and may be deleted
localDB.delete(key);
}
//This is a set implementation and can be handled as such
} else if (value instanceof Set) {
Set asSet = (Set) value;
if (asSet.isEmpty()) {
//the set is empty and may be deleted
localDB.delete(key);
}
}
}
localDB.commit();
localDB.close();
log.info("Stopped");
}
public <K, V> PersistentMapBuilder<K, V> persistentMapBuilder() {
return new DefaultPersistentMapBuilder<>(localDB);
}
public <E> PersistentSetBuilder<E> persistentSetBuilder() {
return new DefaultPersistentSetBuilder<>(localDB);
}
private class CommitTask extends TimerTask {
@Override
public void run() {
localDB.commit();
}
}
}
\ No newline at end of file
/*
* Copyright 2015 Open Networking Laboratory
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package org.onosproject.persistence.impl;
import com.google.common.collect.Maps;
import com.google.common.collect.Sets;
import org.mapdb.DB;
import org.mapdb.Hasher;
import org.onosproject.store.service.Serializer;
import java.util.Collection;
import java.util.Map;
import java.util.Set;
import static com.google.common.base.Preconditions.checkNotNull;
/**
* A map implementation that stores and receives all data from a serialized internal map.
*/
public class PersistentMap<K, V> implements Map<K, V> {
private final Serializer serializer;
private final org.mapdb.DB database;
private final Map<byte[], byte[]> items;
private final String name;
public PersistentMap(Serializer serializer, DB database, String name) {
this.serializer = checkNotNull(serializer);
this.database = checkNotNull(database);
this.name = checkNotNull(name);
items = database
.createHashMap(name)
.keySerializer(org.mapdb.Serializer.BYTE_ARRAY)
.valueSerializer(org.mapdb.Serializer.BYTE_ARRAY)
.hasher(Hasher.BYTE_ARRAY)
.makeOrGet();
}
/**
* Reads this set in deserialized form into the provided map.
*
* @param items the map to be populated
*/
public void readInto(Map<K, V> items) {
this.items.forEach((keyBytes, valueBytes) ->
items.put(serializer.decode(keyBytes),
serializer.decode(valueBytes)));
}
@Override
public V remove(Object key) {
checkNotNull(key, "Key can not be null.");
V removed = get(key);
items.remove(serializer.encode(key));
return removed;
}
@Override
public int size() {
return items.size();
}
@Override
public boolean isEmpty() {
return items.isEmpty();
}
@Override
public boolean containsKey(Object key) {
checkNotNull(key, "Key cannot be null.");
return items.containsKey(serializer.encode(key));
}
@Override
public boolean containsValue(Object value) {
checkNotNull(value, "Value cannot be null.");
byte[] serialized = serializer.encode(value);
for (byte[] compareValue : items.values()) {
boolean same = true;
if (compareValue == null) {
same = false;
} else if (compareValue.length != serialized.length) {
same = false;
} else {
for (int i = 0; i < serialized.length; i++) {
if (serialized[i] != compareValue[i]) {
same = false;
break;
}
}
}
if (same) {
return true;
}
}
return false;
}
@Override
public V get(Object key) {
checkNotNull(key, "Key cannot be null.");
return serializer.decode(items.get(serializer.encode(key)));
}
@Override
public V put(K key, V value) {
checkNotNull(key, "Key cannot be null.");
checkNotNull(value, "Value cannot be null.");
byte[] prevVal = items.put(serializer.encode(key), serializer.encode(value));
if (prevVal == null) {
return null;
}
return serializer.decode(prevVal);
}
@Override
public void putAll(Map<? extends K, ? extends V> m) {
checkNotNull(m, "The passed in map cannot be null.");
m.forEach((k, v) -> items.put(serializer.encode(k), serializer.encode(v)));
}
@Override
public void clear() {
items.clear();
}
@Override
public Set<K> keySet() {
Set<K> keys = Sets.newHashSet();
items.keySet().forEach(k -> keys.add(serializer.decode(k)));
return keys;
}
@Override
public Collection<V> values() {
Collection<V> values = Sets.newHashSet();
items.values().forEach(v -> values.add(serializer.decode(v)));
return values;
}
@Override
public Set<Entry<K, V>> entrySet() {
Set<Entry<K, V>> entries = Sets.newHashSet();
items.entrySet().
forEach(e -> entries.add(Maps.immutableEntry(serializer.decode(e.getKey()),
serializer.decode(e.getValue()))));
return entries;
}
@Override
public boolean equals(Object map) {
//This is not threadsafe and on larger maps incurs a significant processing cost
if (!(map instanceof Map)) {
return false;
}
Map asMap = (Map) map;
if (this.size() != asMap.size()) {
return false;
}
for (Entry entry : this.entrySet()) {
Object key = entry.getKey();
if (!asMap.containsKey(key) || !asMap.get(key).equals(entry.getValue())) {
return false;
}
}
return true;
}
@Override
public int hashCode() {
return super.hashCode();
}
}
\ No newline at end of file
/*
* Copyright 2015 Open Networking Laboratory
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package org.onosproject.persistence.impl;
import com.google.common.collect.Iterators;
import org.mapdb.DB;
import org.mapdb.Hasher;
import org.mapdb.Serializer;
import java.util.Collection;
import java.util.Iterator;
import java.util.Set;
import static com.google.common.base.Preconditions.checkNotNull;
/**
* A set implementation that gets and receives all data from a serialized internal set.
*/
//TODO add locking for reads and writes
public class PersistentSet<E> implements Set<E> {
private final org.onosproject.store.service.Serializer serializer;
private final org.mapdb.DB database;
private final Set<byte[]> items;
private final String name;
public PersistentSet(org.onosproject.store.service.Serializer serializer, DB database, String name) {
this.serializer = checkNotNull(serializer);
this.database = checkNotNull(database);
this.name = checkNotNull(name);
items = database
.createHashSet(name)
.serializer(Serializer.BYTE_ARRAY)
.hasher(Hasher.BYTE_ARRAY)
.makeOrGet();
}
public void readInto(Set<E> items) {
this.items.forEach(item -> items.add(serializer.decode(item)));
}
@Override
public int size() {
return items.size();
}
@Override
public boolean isEmpty() {
return items.isEmpty();
}
@Override
public boolean contains(Object o) {
checkNotNull(o, "The argument cannot be null");
return items.contains(serializer.encode(o));
}
@Override
public Iterator<E> iterator() {
return Iterators.transform(items.iterator(), serializer::decode);
}
@Override
public Object[] toArray() {
Object[] retArray = new Object[items.size()];
int index = 0;
Iterator<byte[]> iterator = items.iterator();
while (iterator.hasNext()) {
retArray[index] = serializer.decode(iterator.next());
index++;
}
return retArray;
}
@Override
public <T> T[] toArray(T[] a) {
checkNotNull(a, "The passed in array cannot be null.");
int index = 0;
Iterator<byte[]> iterator = items.iterator();
T[] retArray;
if (a.length >= items.size()) {
retArray = a;
} else {
retArray = (T[]) new Object[items.size()];
}
while (iterator.hasNext()) {
retArray[index++] = serializer.decode(iterator.next());
}
if (retArray.length > items.size()) {
retArray[index] = null;
}
return retArray;
}
@Override
public boolean add(E item) {
checkNotNull("Item to be added cannot be null.");
return items.add(serializer.encode(item));
}
@Override
public boolean remove(Object o) {
checkNotNull(o, "Item to be removed cannot be null.");
return items.remove(serializer.encode(o));
}
@Override
public boolean containsAll(Collection<?> c) {
checkNotNull(c, "Collection cannot be internal.");
for (Object item : c) {
if (!items.contains(serializer.encode(item))) {
return false;
}
}
return true;
}
@Override
public boolean addAll(Collection<? extends E> c) {
checkNotNull(c, "The collection to be added cannot be null.");
boolean changed = false;
for (Object item : c) {
changed = items.add(serializer.encode(item)) || changed;
}
return changed;
}
@Override
public boolean retainAll(Collection<?> c) {
boolean changed = false;
for (byte[] item : items) {
E deserialized = serializer.decode(item);
if (!c.contains(deserialized)) {
changed = items.remove(item) || changed;
}
}
return changed;
}
@Override
public boolean removeAll(Collection<?> c) {
boolean changed = false;
for (Object item : c) {
changed = items.remove(serializer.encode(item)) || changed;
}
return changed;
}
@Override
public void clear() {
items.clear();
}
@Override
public boolean equals(Object set) {
//This is not threadsafe and on larger sets incurs a significant processing cost
if (!(set instanceof Set)) {
return false;
}
Set asSet = (Set) set;
if (asSet.size() != this.size()) {
return false;
}
for (Object item : this) {
if (!asSet.contains(item)) {
return false;
}
}
return true;
}
@Override
public int hashCode() {
return super.hashCode();
}
}
\ No newline at end of file
/*
* Copyright 2015 Open Networking Laboratory
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package org.onosproject.persistence.impl.test;
import com.google.common.collect.Maps;
import org.junit.After;
import org.junit.Before;
import org.junit.Test;
import org.mapdb.DB;
import org.mapdb.DBMaker;
import org.onosproject.persistence.impl.PersistentMap;
import org.onosproject.store.service.Serializer;
import java.nio.file.Paths;
import java.util.Map;
import java.util.Set;
import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertFalse;
import static org.junit.Assert.assertNull;
import static org.junit.Assert.assertTrue;
/**
* Test suite for Persistent Map.
*/
public class PersistentMapTest {
private Map<Integer, Integer> map = null;
private DB fakeDB = null;
/**
* Set up the database, create a map and a direct executor to handle it.
*
* @throws Exception if instantiation fails
*/
@Before
public void setUp() throws Exception {
//Creates a db, a map within it and a basic integer serializer (async writing is off)
fakeDB = DBMaker
.newFileDB(Paths.get("../testDb").toFile())
.asyncWriteEnable()
.closeOnJvmShutdown()
.make();
map = new PersistentMap<Integer, Integer>(new Serializer() {
@Override
public <T> byte[] encode(T object) {
if (object == null) {
return null;
}
int num = (Integer) object;
byte[] result = new byte[4];
result[0] = (byte) (num >> 24);
result[1] = (byte) (num >> 16);
result[2] = (byte) (num >> 8);
result[3] = (byte) num;
return result;
}
@Override
public <T> T decode(byte[] bytes) {
if (bytes == null) {
return null;
}
int num = 0x00000000;
num = num | bytes[0] << 24;
num = num | bytes[1] << 16;
num = num | bytes[2] << 8;
num = num | bytes[3];
return (T) new java.lang.Integer(num);
}
}, fakeDB, "map");
}
/**
* Clears and deletes the map, closes the datbase and deletes the file.
*
* @throws Exception if shutdown fails
*/
@After
public void tearDown() throws Exception {
map.clear();
fakeDB.delete("map:map");
fakeDB.commit();
fakeDB.close();
//This is key to prevent artifacts persisting between tests.
Paths.get("../testDB").toFile().delete();
}
@Test
public void testRemove() throws Exception {
//Checks removal and return values
fillMap(10);
assertEquals(10, map.size());
for (int i = 0; i < 10; i++) {
assertEquals("The previous value was wrong.", new Integer(i), map.remove(i));
assertNull("The previous value was wrong.", map.remove(i));
//(i+1) compensates for base zero.
assertEquals("The size was wrong.", 10 - (i + 1), map.size());
}
}
@Test
public void testSize() throws Exception {
//Checks size values throughout addition and removal
for (int i = 0; i < 10; i++) {
map.put(i, i);
assertEquals("The map size is wrong.", i + 1, map.size());
}
for (int i = 0; i < 10; i++) {
map.remove(i);
assertEquals("The map size is wrong.", 9 - i, map.size());
}
}
@Test
public void testIsEmpty() throws Exception {
//Checks empty condition
//asserts that the map starts out empty
assertTrue("Map should be empty", map.isEmpty());
map.put(1, 1);
assertFalse("Map shouldn't be empty.", map.isEmpty());
map.remove(1);
assertTrue("Map should be empty", map.isEmpty());
}
@Test
public void testContains() throws Exception {
//Checks both containsKey and containsValue be aware the implementations vary widely (value does not use mapDB
//due to object '=='being an insufficient check)
for (int i = 0; i < 10; i++) {
assertFalse("Map should not contain the key", map.containsKey(i));
assertFalse("Map should not contain the value", map.containsValue(i));
map.put(i, i);
assertTrue("Map should contain the key", map.containsKey(i));
assertTrue("Map should contain the value", map.containsValue(i));
}
}
@Test
public void testGet() throws Exception {
//Tests value retrieval and nonexistent key return values
for (int i = 0; i < 10; i++) {
map.put(i, i);
for (int j = 0; j <= i; j++) {
assertEquals("The value was wrong.", new Integer(j), map.get(j));
}
}
assertNull("Null return value for nonexistent keys.", map.get(10));
}
@Test
public void testPutAll() throws Exception {
//Tests adding of an outside map
Map<Integer, Integer> testMap = Maps.newHashMap();
fillMap(10);
map.putAll(testMap);
for (int i = 0; i < 10; i++) {
assertTrue("The map should contain the current 'i' value.", map.containsKey(i));
assertTrue("The map should contain the current 'i' value.", map.containsValue(i));
}
}
@Test
public void testClear() throws Exception {
//Tests clearing the map
assertTrue("Map was initialized incorrectly, should be empty.", map.isEmpty());
fillMap(10);
assertFalse("Map should contain entries now.", map.isEmpty());
map.clear();
assertTrue("Map should have been cleared of entries.", map.isEmpty());
}
@Test
public void testKeySet() throws Exception {
//Tests key set generation
fillMap(10);
Set<Integer> keys = map.keySet();
for (int i = 0; i < 10; i++) {
assertTrue("The key set doesn't contain all keys 0-9", keys.contains(i));
}
assertEquals("The key set has an incorrect number of entries", 10, keys.size());
}
@Test
public void testValues() throws Exception {
//Tests value set generation
fillMap(10);
Set<Integer> values = (Set<Integer>) map.values();
for (int i = 0; i < 10; i++) {
assertTrue("The key set doesn't contain all keys 0-9", values.contains(i));
}
assertEquals("The key set has an incorrect number of entries", 10, values.size());
}
@Test
public void testEntrySet() throws Exception {
//Test entry set generation (violates abstraction by knowing the type of the returned entries)
fillMap(10);
Set<Map.Entry<Integer, Integer>> entries = map.entrySet();
for (int i = 0; i < 10; i++) {
assertTrue("The key set doesn't contain all keys 0-9", entries.contains(Maps.immutableEntry(i, i)));
}
assertEquals("The key set has an incorrect number of entries", 10, entries.size());
}
@Test public void testPut() throws Exception {
//Tests insertion behavior (particularly the returning of previous value)
fillMap(10);
for (int i = 0; i < 10; i++) {
assertEquals("Put should return the previous value", new Integer(i), map.put(i, i + 1));
}
assertNull(map.put(11, 11));
}
/**
* Populated the map with pairs of integers from (0, 0) up to (numEntries - 1, numEntries -1).
* @param numEntries number of entries to add
*/
private void fillMap(int numEntries) {
for (int i = 0; i < numEntries; i++) {
map.put(i, i);
}
}
}
\ No newline at end of file
......@@ -33,6 +33,7 @@
<modules>
<module>dist</module>
<module>persistence</module>
<module>serializers</module>
</modules>
......
......@@ -96,6 +96,7 @@
<bundle>mvn:org.onosproject/onos-core-net/@ONOS-VERSION</bundle>
<bundle>mvn:org.onosproject/onos-core-common/@ONOS-VERSION</bundle>
<bundle>mvn:org.onosproject/onos-core-dist/@ONOS-VERSION</bundle>
<bundle>mvn:org.onosproject/onos-core-persistence/@ONOS-VERSION</bundle>
<bundle>mvn:org.onosproject/onos-core-serializers/@ONOS-VERSION</bundle>
<bundle>mvn:org.onosproject/onlab-netty/@ONOS-VERSION</bundle>
</feature>
......