홍길동 / onos

Go to a project
Toggle navigation Toggle navigation pinning
Naoki Shiota
Committed by Gerrit Code Review
399a0b36 1 parent b56b9173

[ONOS-3205] Migrate LLDP Link Discovery configuration to Network Configuration System 

- deviceIds under suppression will be moved out to different location. (See ONOS-3461)

Change-Id: I6ebe0ce7f5f2d26e7ee7175974e19305f7c17fad
Expand all
Inline Side-by-side
Showing 11 changed files with 316 additions and 260 deletions
......@@ -333,6 +333,26 @@ public abstract class Config<S> {
}
/**
* Gets the specified array property as a list of items.
*
* @param name property name
* @param function mapper from string to item
* @param defaultValue default value if property not set
* @param <T> type of item
* @return list of items
*/
protected <T> List<T> getList(String name, Function<String, T> function, List<T> defaultValue) {
List<T> list = Lists.newArrayList();
JsonNode jsonNode = object.path(name);
if (jsonNode.isMissingNode()) {
return defaultValue;
}
ArrayNode arrayNode = (ArrayNode) jsonNode;
arrayNode.forEach(i -> list.add(function.apply(i.asText())));
return list;
}
/**
* Sets the specified property as an array of items in a given collection or
* clears it if null is given.
*
......
......@@ -55,5 +55,9 @@
<scope>test</scope>
</dependency>
<dependency>
<groupId>com.fasterxml.jackson.core</groupId>
<artifactId>jackson-databind</artifactId>
</dependency>
</dependencies>
</project>
......
/*
* Copyright 2014-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.provider.lldp.impl;
import com.fasterxml.jackson.core.JsonProcessingException;
import com.fasterxml.jackson.databind.JsonNode;
import com.fasterxml.jackson.databind.ObjectMapper;
import com.fasterxml.jackson.databind.node.ObjectNode;
import com.google.common.collect.ImmutableList;
import com.google.common.collect.ImmutableMap;
import com.google.common.collect.ImmutableSet;
import com.google.common.collect.Maps;
import org.onosproject.core.ApplicationId;
import org.onosproject.net.Device;
import org.onosproject.net.DeviceId;
import org.onosproject.net.config.Config;
import org.slf4j.Logger;
import java.io.IOException;
import java.util.Iterator;
import java.util.List;
import java.util.Map;
import java.util.Set;
import static org.onosproject.provider.lldp.impl.LldpLinkProvider.DEFAULT_RULES;
import static org.slf4j.LoggerFactory.getLogger;
/**
* LLDP suppression config class.
*/
public class SuppressionConfig extends Config<ApplicationId> {
private static final String DEVICE_IDS = "deviceIds";
private static final String DEVICE_TYPES = "deviceTypes";
private static final String ANNOTATION = "annotation";
private static final ObjectMapper MAPPER = new ObjectMapper();
private static final List<DeviceId> DEFAULT_DEVICE_IDS
= ImmutableList.copyOf(DEFAULT_RULES.getSuppressedDevice());
private static final List<Device.Type> DEFAULT_DEVICE_TYPES
= ImmutableList.copyOf(DEFAULT_RULES.getSuppressedDeviceType());
private final Logger log = getLogger(getClass());
/**
* Returns device IDs on which LLDP is suppressed.
*
* @return Set of DeviceId objects
*/
@Deprecated
public Set<DeviceId> deviceIds() {
return ImmutableSet.copyOf(getList(DEVICE_IDS, DeviceId::deviceId, DEFAULT_DEVICE_IDS));
}
/**
* Sets device IDs on which LLDP is suppressed.
*
* @param deviceIds new set of device IDs; null to clear
* @return self
*/
@Deprecated
public SuppressionConfig deviceIds(Set<DeviceId> deviceIds) {
return (SuppressionConfig) setOrClear(DEVICE_IDS, deviceIds);
}
/**
* Returns types of devices on which LLDP is suppressed.
*
* @return set of device types
*/
public Set<Device.Type> deviceTypes() {
return ImmutableSet.copyOf(getList(DEVICE_TYPES, Device.Type::valueOf, DEFAULT_DEVICE_TYPES));
}
/**
* Sets types of devices on which LLDP is suppressed.
*
* @param deviceTypes new set of device types; null to clear
* @return self
*/
public SuppressionConfig deviceTypes(Set<Device.Type> deviceTypes) {
return (SuppressionConfig) setOrClear(DEVICE_TYPES, deviceTypes);
}
/**
* Returns annotation of Ports on which LLDP is suppressed.
*
* @return key-value pairs of annotation
*/
public Map<String, String> annotation() {
ImmutableMap.Builder<String, String> builder = ImmutableMap.builder();
String jsonAnnotation = get(ANNOTATION, null);
if (jsonAnnotation == null || jsonAnnotation.isEmpty()) {
return ImmutableMap.of();
}
JsonNode annotationNode;
try {
annotationNode = MAPPER.readTree(jsonAnnotation);
} catch (IOException e) {
log.error("Failed to read JSON tree from: {}", jsonAnnotation);
return ImmutableMap.of();
}
if (annotationNode.isObject()) {
ObjectNode obj = (ObjectNode) annotationNode;
Iterator<Map.Entry<String, JsonNode>> it = obj.fields();
while (it.hasNext()) {
Map.Entry<String, JsonNode> entry = it.next();
final String key = entry.getKey();
final JsonNode value = entry.getValue();
if (value.isValueNode()) {
if (value.isNull()) {
builder.put(key, SuppressionRules.ANY_VALUE);
} else {
builder.put(key, value.asText());
}
} else {
log.warn("Encountered unexpected JSON field {} for annotation", entry);
}
}
} else {
log.error("Encountered unexpected JSONNode {} for annotation", annotationNode);
return ImmutableMap.of();
}
return builder.build();
}
/**
* Sets annotation of Ports on which LLDP is suppressed.
*
* @param annotation new key-value pair of annotation; null to clear
* @return self
*/
public SuppressionConfig annotation(Map<String, String> annotation) {
// ANY_VALUE should be null in JSON
Map<String, String> config = Maps.transformValues(annotation,
v -> (v == SuppressionRules.ANY_VALUE) ? null : v);
String jsonAnnotation = null;
try {
// TODO Store annotation as a Map instead of a String (which needs NetworkConfigRegistry modification)
jsonAnnotation = MAPPER.writeValueAsString(config);
} catch (JsonProcessingException e) {
log.error("Failed to write JSON from: {}", annotation);
}
return (SuppressionConfig) setOrClear(ANNOTATION, jsonAnnotation);
}
}
......@@ -18,6 +18,7 @@ package org.onosproject.provider.lldp.impl;
import java.util.Map;
import java.util.Map.Entry;
import java.util.Objects;
import java.util.Set;
import org.onosproject.net.Annotations;
......@@ -28,6 +29,7 @@ import org.onosproject.net.Port;
import com.google.common.collect.ImmutableMap;
import com.google.common.collect.ImmutableSet;
import com.google.common.base.MoreObjects;
public class SuppressionRules {
......@@ -103,4 +105,34 @@ public class SuppressionRules {
Map<String, String> getSuppressedAnnotation() {
return suppressedAnnotation;
}
@Override
public int hashCode() {
return Objects.hash(suppressedDevice,
suppressedDeviceType,
suppressedAnnotation);
}
@Override
public boolean equals(Object object) {
if (object != null && getClass() == object.getClass()) {
SuppressionRules that = (SuppressionRules) object;
return Objects.equals(this.suppressedDevice,
that.suppressedDevice)
&& Objects.equals(this.suppressedDeviceType,
that.suppressedDeviceType)
&& Objects.equals(this.suppressedAnnotation,
that.suppressedAnnotation);
}
return false;
}
@Override
public String toString() {
return MoreObjects.toStringHelper(this)
.add("suppressedDevice", suppressedDevice)
.add("suppressedDeviceType", suppressedDeviceType)
.add("suppressedAnnotation", suppressedAnnotation)
.toString();
}
}
......
/*
* Copyright 2014-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.provider.lldp.impl;
import static com.google.common.base.Preconditions.checkNotNull;
import static org.slf4j.LoggerFactory.getLogger;
import com.fasterxml.jackson.core.JsonEncoding;
import com.fasterxml.jackson.core.JsonFactory;
import com.fasterxml.jackson.databind.JsonNode;
import com.fasterxml.jackson.databind.ObjectMapper;
import com.fasterxml.jackson.databind.node.ArrayNode;
import com.fasterxml.jackson.databind.node.ObjectNode;
import org.onosproject.net.Device;
import org.onosproject.net.DeviceId;
import org.slf4j.Logger;
import java.io.File;
import java.io.IOException;
import java.util.EnumSet;
import java.util.HashMap;
import java.util.HashSet;
import java.util.Iterator;
import java.util.Map;
import java.util.Map.Entry;
import java.util.Set;
/*
* JSON file example
*
{
"deviceId" : [ "of:2222000000000000" ],
"deviceType" : [ "ROADM" ],
"annotation" : { "no-lldp" : null, "sendLLDP" : "false" }
}
*/
/**
* Allows for reading and writing LLDP suppression definition as a JSON file.
*/
public class SuppressionRulesStore {
private static final String DEVICE_ID = "deviceId";
private static final String DEVICE_TYPE = "deviceType";
private static final String ANNOTATION = "annotation";
private final Logger log = getLogger(getClass());
private final File file;
/**
* Creates a reader/writer of the LLDP suppression definition file.
*
* @param filePath location of the definition file
*/
public SuppressionRulesStore(String filePath) {
file = new File(filePath);
}
/**
* Creates a reader/writer of the LLDP suppression definition file.
*
* @param file definition file
*/
public SuppressionRulesStore(File file) {
this.file = checkNotNull(file);
}
/**
* Returns SuppressionRules.
*
* @return SuppressionRules
* @throws IOException if error occurred while reading the data
*/
public SuppressionRules read() throws IOException {
final Set<DeviceId> suppressedDevice = new HashSet<>();
final EnumSet<Device.Type> suppressedDeviceType = EnumSet.noneOf(Device.Type.class);
final Map<String, String> suppressedAnnotation = new HashMap<>();
ObjectMapper mapper = new ObjectMapper();
ObjectNode root = (ObjectNode) mapper.readTree(file);
for (JsonNode deviceId : root.get(DEVICE_ID)) {
if (deviceId.isTextual()) {
suppressedDevice.add(DeviceId.deviceId(deviceId.asText()));
} else {
log.warn("Encountered unexpected JSONNode {} for deviceId", deviceId);
}
}
for (JsonNode deviceType : root.get(DEVICE_TYPE)) {
if (deviceType.isTextual()) {
suppressedDeviceType.add(Device.Type.valueOf(deviceType.asText()));
} else {
log.warn("Encountered unexpected JSONNode {} for deviceType", deviceType);
}
}
JsonNode annotation = root.get(ANNOTATION);
if (annotation.isObject()) {
ObjectNode obj = (ObjectNode) annotation;
Iterator<Entry<String, JsonNode>> it = obj.fields();
while (it.hasNext()) {
Entry<String, JsonNode> entry = it.next();
final String key = entry.getKey();
final JsonNode value = entry.getValue();
if (value.isValueNode()) {
if (value.isNull()) {
suppressedAnnotation.put(key, SuppressionRules.ANY_VALUE);
} else {
suppressedAnnotation.put(key, value.asText());
}
} else {
log.warn("Encountered unexpected JSON field {} for annotation", entry);
}
}
} else {
log.warn("Encountered unexpected JSONNode {} for annotation", annotation);
}
return new SuppressionRules(suppressedDevice,
suppressedDeviceType,
suppressedAnnotation);
}
/**
* Writes the given SuppressionRules.
*
* @param rules SuppressionRules
* @throws IOException if error occurred while writing the data
*/
public void write(SuppressionRules rules) throws IOException {
ObjectMapper mapper = new ObjectMapper();
ObjectNode root = mapper.createObjectNode();
ArrayNode deviceIds = mapper.createArrayNode();
ArrayNode deviceTypes = mapper.createArrayNode();
ObjectNode annotations = mapper.createObjectNode();
root.set(DEVICE_ID, deviceIds);
root.set(DEVICE_TYPE, deviceTypes);
root.set(ANNOTATION, annotations);
rules.getSuppressedDevice()
.forEach(deviceId -> deviceIds.add(deviceId.toString()));
rules.getSuppressedDeviceType()
.forEach(type -> deviceTypes.add(type.toString()));
rules.getSuppressedAnnotation().forEach((key, value) -> {
if (value == SuppressionRules.ANY_VALUE) {
annotations.putNull(key);
} else {
annotations.put(key, value);
}
});
mapper.writeTree(new JsonFactory().createGenerator(file, JsonEncoding.UTF8),
root);
}
}
package org.onosproject.provider.lldp.impl;
import static org.junit.Assert.*;
import com.fasterxml.jackson.databind.ObjectMapper;
import com.fasterxml.jackson.databind.node.JsonNodeFactory;
import org.junit.Before;
import org.junit.Test;
import org.onosproject.TestApplicationId;
import org.onosproject.net.Device;
import org.onosproject.net.DeviceId;
import org.onosproject.net.config.ConfigApplyDelegate;
import java.util.HashMap;
import java.util.HashSet;
import java.util.Map;
import java.util.Set;
public class SuppressionConfigTest {
private static final String APP_NAME = "SuppressionConfigTest";
private static final TestApplicationId APP_ID = new TestApplicationId(APP_NAME);
private static final DeviceId DEVICE_ID_1 = DeviceId.deviceId("of:1111000000000000");
private static final DeviceId DEVICE_ID_2 = DeviceId.deviceId("of:2222000000000000");
private static final Device.Type DEVICE_TYPE_1 = Device.Type.ROADM;
private static final Device.Type DEVICE_TYPE_2 = Device.Type.FIBER_SWITCH;
private static final String ANNOTATION_KEY_1 = "no_lldp";
private static final String ANNOTATION_VALUE_1 = "true";
private static final String ANNOTATION_KEY_2 = "sendLLDP";
private static final String ANNOTATION_VALUE_2 = "false";
private SuppressionConfig cfg;
@Before
public void setUp() throws Exception {
ConfigApplyDelegate delegate = config -> { };
ObjectMapper mapper = new ObjectMapper();
cfg = new SuppressionConfig();
cfg.init(APP_ID, LldpLinkProvider.CONFIG_KEY, JsonNodeFactory.instance.objectNode(), mapper, delegate);
}
@Test
public void testDeviceIds() {
Set<DeviceId> inputIds = new HashSet<DeviceId>() { {
add(DEVICE_ID_1);
add(DEVICE_ID_2);
} };
assertNotNull(cfg.deviceIds(inputIds));
Set<DeviceId> outputIds = cfg.deviceIds();
assertTrue(outputIds.contains(DEVICE_ID_1));
assertTrue(outputIds.contains(DEVICE_ID_2));
assertEquals(outputIds.size(), 2);
}
@Test
public void testDeviceTypes() {
Set<Device.Type> inputTypes = new HashSet<Device.Type>() { {
add(DEVICE_TYPE_1);
add(DEVICE_TYPE_2);
} };
assertNotNull(cfg.deviceTypes(inputTypes));
Set<Device.Type> outputTypes = cfg.deviceTypes();
assertTrue(outputTypes.contains(DEVICE_TYPE_1));
assertTrue(outputTypes.contains(DEVICE_TYPE_2));
assertEquals(outputTypes.size(), 2);
}
@Test
public void testDeviceAnnotation() {
Map<String, String> inputMap = new HashMap<String, String>() { {
put(ANNOTATION_KEY_1, ANNOTATION_VALUE_1);
put(ANNOTATION_KEY_2, ANNOTATION_VALUE_2);
} };
assertNotNull(cfg.annotation(inputMap));
Map<String, String> outputMap = cfg.annotation();
assertEquals(outputMap.get(ANNOTATION_KEY_1), ANNOTATION_VALUE_1);
assertEquals(outputMap.get(ANNOTATION_KEY_2), ANNOTATION_VALUE_2);
assertEquals(outputMap.size(), 2);
}
}
/*
* Copyright 2014-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.provider.lldp.impl;
import static org.junit.Assert.*;
import static org.onosproject.net.DeviceId.deviceId;
import java.io.File;
import java.io.IOException;
import java.net.URISyntaxException;
import java.nio.file.Path;
import java.nio.file.Paths;
import org.junit.Rule;
import org.junit.Test;
import org.junit.rules.TemporaryFolder;
import org.onosproject.net.Device;
import com.google.common.collect.ImmutableMap;
import com.google.common.collect.ImmutableSet;
import com.google.common.io.Resources;
public class SuppressionRulesStoreTest {
@Rule
public TemporaryFolder tempFolder = new TemporaryFolder();
// "lldp_suppression.json"
SuppressionRules testData
= new SuppressionRules(ImmutableSet.of(deviceId("of:2222000000000000")),
ImmutableSet.of(Device.Type.ROADM),
ImmutableMap.of("no-lldp", SuppressionRules.ANY_VALUE,
"sendLLDP", "false"));
private static void assertRulesEqual(SuppressionRules expected, SuppressionRules actual) {
assertEquals(expected.getSuppressedDevice(),
actual.getSuppressedDevice());
assertEquals(expected.getSuppressedDeviceType(),
actual.getSuppressedDeviceType());
assertEquals(expected.getSuppressedAnnotation(),
actual.getSuppressedAnnotation());
}
@Test
public void testRead() throws URISyntaxException, IOException {
Path path = Paths.get(Resources.getResource("lldp_suppression.json").toURI());
SuppressionRulesStore store = new SuppressionRulesStore(path.toString());
SuppressionRules rules = store.read();
assertRulesEqual(testData, rules);
}
@Test
public void testWrite() throws IOException {
File newFile = tempFolder.newFile();
SuppressionRulesStore store = new SuppressionRulesStore(newFile);
store.write(testData);
SuppressionRulesStore reload = new SuppressionRulesStore(newFile);
SuppressionRules rules = reload.read();
assertRulesEqual(testData, rules);
}
}
{
"deviceId" : [ "of:2222000000000000" ],
"deviceType" : [ "ROADM" ],
"annotation" : { "no-lldp" : null, "sendLLDP" : "false" }
}
......@@ -62,5 +62,12 @@
]
}
}
"org.onosproject.provider.lldp": {
"suppression": {
"deviceIds": [ "of:2222000000000000" ],
"deviceTypes": [ "ROADM" ],
"annotation": { "no-lldp": null, "sendLLDP" : "false" }
}
}
}
}
......