/*
* Copyright 2015-present 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.net.config;
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 com.google.common.annotations.Beta;
import com.google.common.collect.ImmutableSet;
import com.google.common.collect.Lists;
import org.onlab.packet.IpAddress;
import org.onlab.packet.IpPrefix;
import org.onlab.packet.MacAddress;
import org.onlab.packet.TpPort;
import org.onosproject.net.ConnectPoint;
import java.util.Collection;
import java.util.Iterator;
import java.util.List;
import java.util.Set;
import java.util.function.Function;
import java.util.stream.Collectors;
import static com.google.common.base.Preconditions.checkNotNull;
import static com.google.common.base.Preconditions.checkState;
/**
* Base abstraction of a configuration facade for a specific subject. Derived
* classes should keep all state in the specified JSON tree as that is the
* only state that will be distributed or persisted; this class is merely
* a facade for interacting with a particular facet of configuration on a
* given subject.
*
* @param <S> type of subject
*/
@Beta
public abstract class Config<S> {
private static final String TRUE_LITERAL = "true";
private static final String FALSE_LITERAL = "false";
protected S subject;
protected String key;
protected JsonNode node;
protected ObjectNode object;
protected ArrayNode array;
protected ObjectMapper mapper;
protected ConfigApplyDelegate delegate;
/**
* Indicator of whether a configuration JSON field is required.
*/
public enum FieldPresence {
/**
* Signifies that config field is an optional one.
*/
OPTIONAL,
/**
* Signifies that config field is mandatory.
*/
MANDATORY
}
/**
* Initializes the configuration behaviour with necessary context.
*
* @param subject configuration subject
* @param key configuration key
* @param node JSON node where configuration data is stored
* @param mapper JSON object mapper
* @param delegate delegate context, or null for detached configs.
*/
public final void init(S subject, String key, JsonNode node, ObjectMapper mapper,
ConfigApplyDelegate delegate) {
this.subject = checkNotNull(subject, "Subject cannot be null");
this.key = key;
this.node = checkNotNull(node, "Node cannot be null");
this.object = node instanceof ObjectNode ? (ObjectNode) node : null;
this.array = node instanceof ArrayNode ? (ArrayNode) node : null;
this.mapper = checkNotNull(mapper, "Mapper cannot be null");
this.delegate = delegate;
}
/**
* Indicates whether or not the backing JSON node contains valid data.
* <p>
* Default implementation returns true.
* Subclasses are expected to override this with their own validation.
* Implementations are free to throw a RuntimeException if data is invalid.
* </p>
*
* @return true if the data is valid; false otherwise
* @throws RuntimeException if configuration is invalid or completely foobar
*/
public boolean isValid() {
// Derivatives should use the provided set of predicates to test
// validity of their fields, e.g.:
// isString(path)
// isBoolean(path)
// isNumber(path, [min, max])
// isIntegralNumber(path, [min, max])
// isDecimal(path, [min, max])
// isMacAddress(path)
// isIpAddress(path)
// isIpPrefix(path)
// isConnectPoint(path)
// isTpPort(path)
return true;
}
/**
* Returns the specific subject to which this configuration pertains.
*
* @return configuration subject
*/
public S subject() {
return subject;
}
/**
* Returns the configuration key. This is primarily aimed for use in
* composite JSON trees in external representations and has no bearing on
* the internal behaviours.
*
* @return configuration key
*/
public String key() {
return key;
}
/**
* Returns the JSON node that contains the configuration data.
*
* @return JSON node backing the configuration
*/
public JsonNode node() {
return node;
}
/**
* Applies any configuration changes made via this configuration.
* <p>
* Not effective for detached configs.
* </p>
*/
public void apply() {
checkState(delegate != null, "Cannot apply detached config");
delegate.onApply(this);
}
// Miscellaneous helpers for interacting with JSON
/**
* Gets the specified property as a string.
*
* @param name property name
* @param defaultValue default value if property not set
* @return property value or default value
*/
protected String get(String name, String defaultValue) {
return object.path(name).asText(defaultValue);
}
/**
* Sets the specified property as a string or clears it if null value given.
*
* @param name property name
* @param value new value or null to clear the property
* @return self
*/
protected Config<S> setOrClear(String name, String value) {
if (value != null) {
object.put(name, value);
} else {
object.remove(name);
}
return this;
}
/**
* Gets the specified property as a boolean.
*
* @param name property name
* @param defaultValue default value if property not set
* @return property value or default value
*/
protected boolean get(String name, boolean defaultValue) {
return object.path(name).asBoolean(defaultValue);
}
/**
* Clears the specified property.
*
* @param name property name
* @return self
*/
protected Config<S> clear(String name) {
object.remove(name);
return this;
}
/**
* Sets the specified property as a boolean or clears it if null value given.
*
* @param name property name
* @param value new value or null to clear the property
* @return self
*/
protected Config<S> setOrClear(String name, Boolean value) {
if (value != null) {
object.put(name, value.booleanValue());
} else {
object.remove(name);
}
return this;
}
/**
* Gets the specified property as an integer.
*
* @param name property name
* @param defaultValue default value if property not set
* @return property value or default value
*/
protected int get(String name, int defaultValue) {
return object.path(name).asInt(defaultValue);
}
/**
* Sets the specified property as an integer or clears it if null value given.
*
* @param name property name
* @param value new value or null to clear the property
* @return self
*/
protected Config<S> setOrClear(String name, Integer value) {
if (value != null) {
object.put(name, value.intValue());
} else {
object.remove(name);
}
return this;
}
/**
* Gets the specified property as a long.
*
* @param name property name
* @param defaultValue default value if property not set
* @return property value or default value
*/
protected long get(String name, long defaultValue) {
return object.path(name).asLong(defaultValue);
}
/**
* Sets the specified property as a long or clears it if null value given.
*
* @param name property name
* @param value new value or null to clear the property
* @return self
*/
protected Config<S> setOrClear(String name, Long value) {
if (value != null) {
object.put(name, value.longValue());
} else {
object.remove(name);
}
return this;
}
/**
* Gets the specified property as a double.
*
* @param name property name
* @param defaultValue default value if property not set
* @return property value or default value
*/
protected double get(String name, double defaultValue) {
return object.path(name).asDouble(defaultValue);
}
/**
* Sets the specified property as a double or clears it if null value given.
*
* @param name property name
* @param value new value or null to clear the property
* @return self
*/
protected Config<S> setOrClear(String name, Double value) {
if (value != null) {
object.put(name, value.doubleValue());
} else {
object.remove(name);
}
return this;
}
/**
* Gets the specified property as an enum.
*
* @param name property name
* @param defaultValue default value if property not set
* @param enumClass the enum class
* @param <E> type of enum
* @return property value or default value
*/
protected <E extends Enum<E>> E get(String name, E defaultValue, Class<E> enumClass) {
if (defaultValue != null) {
return Enum.valueOf(enumClass, object.path(name).asText(defaultValue.toString()));
}
JsonNode node = object.get(name);
return node == null ? null : Enum.valueOf(enumClass, node.asText());
}
/**
* Sets the specified property as a double or clears it if null value given.
*
* @param name property name
* @param value new value or null to clear the property
* @param <E> type of enum
* @return self
*/
protected <E extends Enum> Config<S> setOrClear(String name, E value) {
if (value != null) {
object.put(name, value.toString());
} else {
object.remove(name);
}
return this;
}
/**
* Gets the specified array property as a list of items.
*
* @param name property name
* @param function mapper from string to item
* @param <T> type of item
* @return list of items
*/
protected <T> List<T> getList(String name, Function<String, T> function) {
List<T> list = Lists.newArrayList();
ArrayNode arrayNode = (ArrayNode) object.path(name);
arrayNode.forEach(i -> list.add(function.apply(asString(i))));
return list;
}
/**
* Converts JSON node to a String.
* <p>
* If the {@code node} was a text node, text is returned as-is,
* all other node type will be converted to String by toString().
*
* @param node JSON node to convert
* @return String representation
*/
private static String asString(JsonNode node) {
if (node.isTextual()) {
return node.asText();
} else {
return node.toString();
}
}
/**
* 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(asString(i))));
return list;
}
/**
* Sets the specified property as an array of items in a given collection
* transformed into a String with supplied {@code function}.
*
* @param name propertyName
* @param function to transform item to a String
* @param value list of items
* @param <T> type of items
* @return self
*/
protected <T> Config<S> setList(String name,
Function<? super T, String> function,
List<T> value) {
Collection<String> mapped = value.stream()
.map(function)
.collect(Collectors.toList());
return setOrClear(name, mapped);
}
/**
* Sets the specified property as an array of items in a given collection or
* clears it if null is given.
*
* @param name propertyName
* @param collection collection of items
* @param <T> type of items
* @return self
*/
protected <T> Config<S> setOrClear(String name, Collection<T> collection) {
if (collection == null) {
object.remove(name);
} else {
ArrayNode arrayNode = mapper.createArrayNode();
collection.forEach(i -> arrayNode.add(i.toString()));
object.set(name, arrayNode);
}
return this;
}
/**
* Returns true if this config contains a field with the given name.
*
* @param name the field name
* @return true if field is present, false otherwise
*/
protected boolean hasField(String name) {
return hasField(object, name);
}
/**
* Returns true if the given node contains a field with the given name.
*
* @param node the node to examine
* @param name the name to look for
* @return true if the node has a field with the given name, false otherwise
*/
protected boolean hasField(ObjectNode node, String name) {
Iterator<String> fnames = node.fieldNames();
while (fnames.hasNext()) {
if (fnames.next().equals(name)) {
return true;
}
}
return false;
}
/**
* Indicates whether only the specified fields are present in the backing JSON.
*
* @param allowedFields allowed field names
* @return true if only allowedFields are present; false otherwise
*/
protected boolean hasOnlyFields(String... allowedFields) {
return hasOnlyFields(object, allowedFields);
}
/**
* Indicates whether only the specified fields are present in a particular
* JSON object.
*
* @param node node whose fields to check
* @param allowedFields allowed field names
* @return true if only allowedFields are present; false otherwise
*/
protected boolean hasOnlyFields(ObjectNode node, String... allowedFields) {
Set<String> fields = ImmutableSet.copyOf(allowedFields);
node.fieldNames().forEachRemaining(f -> {
if (!fields.contains(f)) {
throw new InvalidFieldException(f, "Field is not allowed");
}
});
return true;
}
/**
* Indicates whether all specified fields are present in the backing JSON.
*
* @param mandatoryFields mandatory field names
* @return true if all mandatory fields are present; false otherwise
*/
protected boolean hasFields(String... mandatoryFields) {
return hasFields(object, mandatoryFields);
}
/**
* Indicates whether all specified fields are present in a particular
* JSON object.
*
* @param node node whose fields to check
* @param mandatoryFields mandatory field names
* @return true if all mandatory fields are present; false otherwise
*/
protected boolean hasFields(ObjectNode node, String... mandatoryFields) {
Set<String> fields = ImmutableSet.copyOf(mandatoryFields);
fields.forEach(f -> {
if (node.path(f).isMissingNode()) {
throw new InvalidFieldException(f, "Mandatory field is not present");
}
});
return true;
}
/**
* Indicates whether the specified field holds a valid MAC address.
*
* @param field JSON field name
* @param presence specifies if field is optional or mandatory
* @return true if valid; false otherwise
* @throws InvalidFieldException if the field is present but not valid
*/
protected boolean isMacAddress(String field, FieldPresence presence) {
return isMacAddress(object, field, presence);
}
/**
* Indicates whether the specified field of a particular node holds a valid
* MAC address.
*
* @param objectNode JSON node
* @param field JSON field name
* @param presence specifies if field is optional or mandatory
* @return true if valid; false otherwise
* @throws InvalidFieldException if the field is present but not valid
*/
protected boolean isMacAddress(ObjectNode objectNode, String field, FieldPresence presence) {
return isValid(objectNode, field, presence, n -> {
MacAddress.valueOf(n.asText());
return true;
});
}
/**
* Indicates whether the specified field holds a valid IP address.
*
* @param field JSON field name
* @param presence specifies if field is optional or mandatory
* @return true if valid; false otherwise
* @throws InvalidFieldException if the field is present but not valid
*/
protected boolean isIpAddress(String field, FieldPresence presence) {
return isIpAddress(object, field, presence);
}
/**
* Indicates whether the specified field of a particular node holds a valid
* IP address.
*
* @param objectNode node from whom to access the field
* @param field JSON field name
* @param presence specifies if field is optional or mandatory
* @return true if valid; false otherwise
* @throws InvalidFieldException if the field is present but not valid
*/
protected boolean isIpAddress(ObjectNode objectNode, String field, FieldPresence presence) {
return isValid(objectNode, field, presence, n -> {
IpAddress.valueOf(n.asText());
return true;
});
}
/**
* Indicates whether the specified field holds a valid IP prefix.
*
* @param field JSON field name
* @param presence specifies if field is optional or mandatory
* @return true if valid; false otherwise
* @throws InvalidFieldException if the field is present but not valid
*/
protected boolean isIpPrefix(String field, FieldPresence presence) {
return isIpPrefix(object, field, presence);
}
/**
* Indicates whether the specified field of a particular node holds a valid
* IP prefix.
*
* @param objectNode node from whom to access the field
* @param field JSON field name
* @param presence specifies if field is optional or mandatory
* @return true if valid; false otherwise
* @throws InvalidFieldException if the field is present but not valid
*/
protected boolean isIpPrefix(ObjectNode objectNode, String field, FieldPresence presence) {
return isValid(objectNode, field, presence, n -> {
IpPrefix.valueOf(n.asText());
return true;
});
}
/**
* Indicates whether the specified field holds a valid transport layer port.
*
* @param field JSON field name
* @param presence specifies if field is optional or mandatory
* @return true if valid; false otherwise
* @throws InvalidFieldException if the field is present but not valid
*/
protected boolean isTpPort(String field, FieldPresence presence) {
return isTpPort(object, field, presence);
}
/**
* Indicates whether the specified field of a particular node holds a valid
* transport layer port.
*
* @param objectNode node from whom to access the field
* @param field JSON field name
* @param presence specifies if field is optional or mandatory
* @return true if valid; false otherwise
* @throws InvalidFieldException if the field is present but not valid
*/
protected boolean isTpPort(ObjectNode objectNode, String field, FieldPresence presence) {
return isValid(objectNode, field, presence, n -> {
TpPort.tpPort(n.asInt());
return true;
});
}
/**
* Indicates whether the specified field holds a valid connect point string.
*
* @param field JSON field name
* @param presence specifies if field is optional or mandatory
* @return true if valid; false otherwise
* @throws InvalidFieldException if the field is present but not valid
*/
protected boolean isConnectPoint(String field, FieldPresence presence) {
return isConnectPoint(object, field, presence);
}
/**
* Indicates whether the specified field of a particular node holds a valid
* connect point string.
*
* @param objectNode JSON node
* @param field JSON field name
* @param presence specifies if field is optional or mandatory
* @return true if valid; false otherwise
* @throws InvalidFieldException if the field is present but not valid
*/
protected boolean isConnectPoint(ObjectNode objectNode, String field, FieldPresence presence) {
return isValid(objectNode, field, presence, n -> {
ConnectPoint.deviceConnectPoint(n.asText());
return true;
});
}
/**
* Indicates whether the specified field holds a valid string value.
*
* @param field JSON field name
* @param presence specifies if field is optional or mandatory
* @param pattern optional regex pattern
* @return true if valid; false otherwise
* @throws InvalidFieldException if the field is present but not valid
*/
protected boolean isString(String field, FieldPresence presence, String... pattern) {
return isString(object, field, presence, pattern);
}
/**
* Indicates whether the specified field on a particular node holds a valid
* string value.
*
* @param objectNode JSON node
* @param field JSON field name
* @param presence specifies if field is optional or mandatory
* @param pattern optional regex pattern
* @return true if valid; false otherwise
* @throws InvalidFieldException if the field is present but not valid
*/
protected boolean isString(ObjectNode objectNode, String field,
FieldPresence presence, String... pattern) {
return isValid(objectNode, field, presence, (node) -> {
if (!(node.isTextual() &&
(pattern.length > 0 && node.asText().matches(pattern[0]) || pattern.length < 1))) {
fail("Invalid string value");
}
return true;
});
}
/**
* Indicates whether the specified field holds a valid number.
*
* @param field JSON field name
* @param presence specifies if field is optional or mandatory
* @param minMax optional min/max values
* @return true if valid; false otherwise
* @throws InvalidFieldException if the field is present but not valid
*/
protected boolean isNumber(String field, FieldPresence presence, long... minMax) {
return isNumber(object, field, presence, minMax);
}
/**
* Indicates whether the specified field of a particular node holds a
* valid number.
*
* @param objectNode JSON object
* @param field JSON field name
* @param presence specifies if field is optional or mandatory
* @param minMax optional min/max values
* @return true if valid; false otherwise
* @throws InvalidFieldException if the field is present but not valid
*/
protected boolean isNumber(ObjectNode objectNode, String field,
FieldPresence presence, long... minMax) {
return isValid(objectNode, field, presence, n -> {
long number = (n.isNumber()) ? n.asLong() : Long.parseLong(n.asText());
if (minMax.length > 1) {
verifyRange(number, minMax[0], minMax[1]);
} else if (minMax.length > 0) {
verifyRange(number, minMax[0]);
}
return true;
});
}
/**
* Indicates whether the specified field holds a valid integer.
*
* @param field JSON field name
* @param presence specifies if field is optional or mandatory
* @param minMax optional min/max values
* @return true if valid; false otherwise
* @throws InvalidFieldException if the field is present but not valid
*/
protected boolean isIntegralNumber(String field, FieldPresence presence, long... minMax) {
return isIntegralNumber(object, field, presence, minMax);
}
/**
* Indicates whether the specified field of a particular node holds a valid
* integer.
*
* @param objectNode JSON node
* @param field JSON field name
* @param presence specifies if field is optional or mandatory
* @param minMax optional min/max values
* @return true if valid; false otherwise
* @throws InvalidFieldException if the field is present but not valid
*/
protected boolean isIntegralNumber(ObjectNode objectNode, String field,
FieldPresence presence, long... minMax) {
return isValid(objectNode, field, presence, n -> {
long number = (n.isIntegralNumber()) ? n.asLong() : Long.parseLong(n.asText());
if (minMax.length > 1) {
verifyRange(number, minMax[0], minMax[1]);
} else if (minMax.length > 0) {
verifyRange(number, minMax[0]);
}
return true;
});
}
/**
* Indicates whether the specified field holds a valid decimal number.
*
* @param field JSON field name
* @param presence specifies if field is optional or mandatory
* @param minMax optional min/max values
* @return true if valid; false otherwise
* @throws InvalidFieldException if the field is present but not valid
*/
protected boolean isDecimal(String field, FieldPresence presence, double... minMax) {
return isDecimal(object, field, presence, minMax);
}
/**
* Indicates whether the specified field of a particular node holds a valid
* decimal number.
*
* @param objectNode JSON node
* @param field JSON field name
* @param presence specifies if field is optional or mandatory
* @param minMax optional min/max values
* @return true if valid; false otherwise
* @throws InvalidFieldException if the field is present but not valid
*/
protected boolean isDecimal(ObjectNode objectNode, String field,
FieldPresence presence, double... minMax) {
return isValid(objectNode, field, presence, n -> {
double number = (n.isDouble()) ? n.asDouble() : Double.parseDouble(n.asText());
if (minMax.length > 1) {
verifyRange(number, minMax[0], minMax[1]);
} else if (minMax.length > 0) {
verifyRange(number, minMax[0]);
}
return true;
});
}
/**
* Indicates whether the specified field holds a valid boolean value.
*
* @param field JSON field name
* @param presence specifies if field is optional or mandatory
* @return true if valid; false otherwise
* @throws InvalidFieldException if the field is present but not valid
*/
protected boolean isBoolean(String field, FieldPresence presence) {
return isBoolean(object, field, presence);
}
/**
* Indicates whether the specified field of a particular node holds a valid
* boolean value.
*
* @param objectNode JSON object node
* @param field JSON field name
* @param presence specifies if field is optional or mandatory
* @return true if valid; false otherwise
* @throws InvalidFieldException if the field is present but not valid
*/
protected boolean isBoolean(ObjectNode objectNode, String field, FieldPresence presence) {
return isValid(objectNode, field, presence, n -> {
if (!(n.isBoolean() || (n.isTextual() && isBooleanString(n.asText())))) {
fail("Field is not a boolean value");
}
return true;
});
}
/**
* Indicates whether a string holds a boolean literal value.
*
* @param str string to test
* @return true if the string contains "true" or "false" (case insensitive),
* otherwise false
*/
private boolean isBooleanString(String str) {
return str.equalsIgnoreCase(TRUE_LITERAL) || str.equalsIgnoreCase(FALSE_LITERAL);
}
/**
* Indicates whether a field in the node is present and of correct value or
* not mandatory and absent.
*
* @param objectNode JSON object node containing field to validate
* @param field name of field to validate
* @param presence specified if field is optional or mandatory
* @param validationFunction function which can be used to verify if the
* node has the correct value
* @return true if the field is as expected
* @throws InvalidFieldException if the field is present but not valid
*/
private boolean isValid(ObjectNode objectNode, String field, FieldPresence presence,
Function<JsonNode, Boolean> validationFunction) {
JsonNode node = objectNode.path(field);
boolean isMandatory = presence == FieldPresence.MANDATORY;
if (isMandatory && node.isMissingNode()) {
throw new InvalidFieldException(field, "Mandatory field not present");
}
if (!isMandatory && (node.isNull() || node.isMissingNode())) {
return true;
}
try {
if (validationFunction.apply(node)) {
return true;
} else {
throw new InvalidFieldException(field, "Validation error");
}
} catch (IllegalArgumentException e) {
throw new InvalidFieldException(field, e);
}
}
private static void fail(String message) {
throw new IllegalArgumentException(message);
}
private static <N extends Comparable> void verifyRange(N num, N min) {
if (num.compareTo(min) < 0) {
fail("Field must be greater than " + min);
}
}
private static <N extends Comparable> void verifyRange(N num, N min, N max) {
verifyRange(num, min);
if (num.compareTo(max) > 0) {
fail("Field must be less than " + max);
}
}
@Override
public String toString() {
return String.valueOf(node);
}
}