row);
-
+ Object readFromCache(CacheableQueryRow row);
}
diff --git a/core/query/src/main/java/datawave/core/query/configuration/CheckpointableQueryConfiguration.java b/core/query/src/main/java/datawave/core/query/configuration/CheckpointableQueryConfiguration.java
new file mode 100644
index 00000000000..8a243afcbaa
--- /dev/null
+++ b/core/query/src/main/java/datawave/core/query/configuration/CheckpointableQueryConfiguration.java
@@ -0,0 +1,12 @@
+package datawave.core.query.configuration;
+
+public interface CheckpointableQueryConfiguration {
+
+ /**
+ * Create an instance of this configuration suitable for a checkpoint. Basically ensure that everything is copied that is required to continue execution of
+ * the query post create.
+ *
+ * @return The configuration
+ */
+ GenericQueryConfiguration checkpoint();
+}
diff --git a/core/query/src/main/java/datawave/core/query/configuration/GenericQueryConfiguration.java b/core/query/src/main/java/datawave/core/query/configuration/GenericQueryConfiguration.java
new file mode 100644
index 00000000000..18945b1f88a
--- /dev/null
+++ b/core/query/src/main/java/datawave/core/query/configuration/GenericQueryConfiguration.java
@@ -0,0 +1,374 @@
+package datawave.core.query.configuration;
+
+import java.io.Serializable;
+import java.nio.charset.StandardCharsets;
+import java.util.Collection;
+import java.util.Collections;
+import java.util.Date;
+import java.util.HashMap;
+import java.util.Iterator;
+import java.util.Map;
+import java.util.Objects;
+import java.util.Set;
+import java.util.stream.Collectors;
+
+import org.apache.accumulo.core.client.AccumuloClient;
+import org.apache.accumulo.core.client.BatchScanner;
+import org.apache.accumulo.core.client.ScannerBase;
+import org.apache.accumulo.core.security.Authorizations;
+
+import com.google.common.collect.Iterators;
+
+import datawave.core.common.util.EnvProvider;
+import datawave.core.query.logic.BaseQueryLogic;
+import datawave.microservice.query.Query;
+import datawave.util.TableName;
+
+/**
+ *
+ * A basic query configuration object that contains the information needed to run a query.
+ *
+ *
+ *
+ * Provides some "expected" default values for parameters. This configuration object also encapsulates iterators and their options that would be set on a
+ * {@link BatchScanner}.
+ *
+ *
+ */
+public class GenericQueryConfiguration implements Serializable {
+ // is this execution expected to be checkpointable (changes how we allocate ranges to scanners)
+ private boolean checkpointable = false;
+
+ private transient AccumuloClient client = null;
+
+ // This is just used for (de)serialization
+ private Set auths = Collections.emptySet();
+
+ private Set authorizations = Collections.singleton(Authorizations.EMPTY);
+
+ private Query query = null;
+
+ // Leave in a top-level query for backwards-compatibility purposes
+ private String queryString = null;
+
+ private Date beginDate = null;
+ private Date endDate = null;
+
+ // The max number of next + seek calls made by the underlying iterators
+ private Long maxWork = -1L;
+
+ protected int baseIteratorPriority = 100;
+
+ // Table name
+ private String tableName = TableName.SHARD;
+
+ private Collection queries = Collections.emptyList();
+
+ private transient Iterator queriesIter = Collections.emptyIterator();
+ protected boolean bypassAccumulo;
+
+ // use a value like 'env:PASS' to pull from the environment
+ private String accumuloPassword = "";
+
+ private String connPoolName;
+
+ // Whether or not this query emits every result or performs some kind of result reduction
+ protected boolean reduceResults = false;
+
+ // either IMMEDIATE or EVENTUAL
+ private Map tableConsistencyLevels = new HashMap<>();
+ // provides default scan hints
+ // NOTE: accumulo reserves the execution hint name 'meta'
+ // NOTE: datawave reserves the execution hint name 'expansion' for index expansion
+ private Map> tableHints = new HashMap<>();
+
+ /**
+ * Empty default constructor
+ */
+ public GenericQueryConfiguration() {
+
+ }
+
+ /**
+ * Pulls the table name, max query results, and max rows to scan from the provided argument
+ *
+ * @param configuredLogic
+ * A pre-configured BaseQueryLogic to initialize the Configuration with
+ */
+ public GenericQueryConfiguration(BaseQueryLogic configuredLogic) {
+ this(configuredLogic.getConfig());
+ }
+
+ @SuppressWarnings("CopyConstructorMissesField")
+ public GenericQueryConfiguration(GenericQueryConfiguration other) {
+ copyFrom(other);
+ }
+
+ /**
+ * Deeply copies over all fields from the given {@link GenericQueryConfiguration} to this {@link GenericQueryConfiguration}.
+ *
+ * @param other
+ * the {@link GenericQueryConfiguration} to copy values from
+ */
+ public void copyFrom(GenericQueryConfiguration other) {
+ this.setQuery(other.getQuery());
+ this.setCheckpointable(other.isCheckpointable());
+ this.setBaseIteratorPriority(other.getBaseIteratorPriority());
+ this.setBypassAccumulo(other.getBypassAccumulo());
+ this.setAccumuloPassword(other.getAccumuloPassword());
+ this.setConnPoolName(other.getConnPoolName());
+ this.setAuthorizations(other.getAuthorizations());
+ this.setBeginDate(other.getBeginDate());
+ this.setClient(other.getClient());
+ this.setEndDate(other.getEndDate());
+ this.setMaxWork(other.getMaxWork());
+ this.setQueries(other.getQueries());
+ // copying the query iterators can cause issues if the query is running.
+ // this.setQueriesIter(other.getQueriesIter());
+ this.setQueryString(other.getQueryString());
+ this.setTableName(other.getTableName());
+ this.setReduceResults(other.isReduceResults());
+ this.setTableConsistencyLevels(other.getTableConsistencyLevels());
+ this.setTableHints(other.getTableHints());
+ }
+
+ public Collection getQueries() {
+ return queries;
+ }
+
+ public void setQueries(Collection queries) {
+ this.queries = queries;
+ }
+
+ /**
+ * Return the configured {@code Iterator}
+ *
+ * @return An iterator of query ranges
+ */
+ public Iterator getQueriesIter() {
+ if ((queriesIter == null || !queriesIter.hasNext()) && queries != null) {
+ return Iterators.unmodifiableIterator(queries.iterator());
+ } else {
+ return Iterators.unmodifiableIterator(this.queriesIter);
+ }
+ }
+
+ /**
+ * Set the queries to be run.
+ *
+ * @param queriesIter
+ * An iterator of query ranges
+ */
+ public void setQueriesIter(Iterator queriesIter) {
+ this.queriesIter = queriesIter;
+ }
+
+ public boolean isCheckpointable() {
+ return checkpointable;
+ }
+
+ public void setCheckpointable(boolean checkpointable) {
+ this.checkpointable = checkpointable;
+ }
+
+ public AccumuloClient getClient() {
+ return client;
+ }
+
+ public void setClient(AccumuloClient client) {
+ this.client = client;
+ }
+
+ public Query getQuery() {
+ return query;
+ }
+
+ public void setQuery(Query query) {
+ this.query = query;
+ }
+
+ public void setQueryString(String query) {
+ this.queryString = query;
+ }
+
+ public String getQueryString() {
+ return queryString;
+ }
+
+ public Set getAuths() {
+ if (auths == null && authorizations != null) {
+ auths = authorizations.stream().flatMap(a -> a.getAuthorizations().stream()).map(b -> new String(b, StandardCharsets.UTF_8))
+ .collect(Collectors.toSet());
+ }
+ return auths;
+ }
+
+ public void setAuths(Set auths) {
+ this.auths = auths;
+ this.authorizations = null;
+ getAuthorizations();
+ }
+
+ public Set getAuthorizations() {
+ if (authorizations == null && auths != null) {
+ authorizations = Collections
+ .singleton(new Authorizations(auths.stream().map(a -> a.getBytes(StandardCharsets.UTF_8)).collect(Collectors.toList())));
+ }
+ return authorizations;
+ }
+
+ public void setAuthorizations(Set authorizations) {
+ this.authorizations = authorizations;
+ this.auths = null;
+ getAuths();
+ }
+
+ public int getBaseIteratorPriority() {
+ return baseIteratorPriority;
+ }
+
+ public void setBaseIteratorPriority(final int baseIteratorPriority) {
+ this.baseIteratorPriority = baseIteratorPriority;
+ }
+
+ public Date getBeginDate() {
+ return beginDate;
+ }
+
+ public void setBeginDate(Date beginDate) {
+ this.beginDate = beginDate;
+ }
+
+ public Date getEndDate() {
+ return endDate;
+ }
+
+ public void setEndDate(Date endDate) {
+ this.endDate = endDate;
+ }
+
+ public Long getMaxWork() {
+ return maxWork;
+ }
+
+ public void setMaxWork(Long maxWork) {
+ this.maxWork = maxWork;
+ }
+
+ public String getTableName() {
+ return tableName;
+ }
+
+ public void setTableName(String tableName) {
+ this.tableName = tableName;
+ }
+
+ public boolean getBypassAccumulo() {
+ return bypassAccumulo;
+ }
+
+ public void setBypassAccumulo(boolean bypassAccumulo) {
+ this.bypassAccumulo = bypassAccumulo;
+ }
+
+ /**
+ * @return - the accumulo password
+ */
+ public String getAccumuloPassword() {
+ return this.accumuloPassword;
+ }
+
+ public boolean isReduceResults() {
+ return reduceResults;
+ }
+
+ public void setReduceResults(boolean reduceResults) {
+ this.reduceResults = reduceResults;
+ }
+
+ /**
+ * Sets configured password for accumulo access
+ *
+ * @param password
+ * the password used to connect to accumulo
+ */
+ public void setAccumuloPassword(String password) {
+ this.accumuloPassword = EnvProvider.resolve(password);
+ }
+
+ public String getConnPoolName() {
+ return connPoolName;
+ }
+
+ public void setConnPoolName(String connPoolName) {
+ this.connPoolName = connPoolName;
+ }
+
+ public Map getTableConsistencyLevels() {
+ return tableConsistencyLevels;
+ }
+
+ public void setTableConsistencyLevels(Map tableConsistencyLevels) {
+ this.tableConsistencyLevels = tableConsistencyLevels;
+ }
+
+ public Map> getTableHints() {
+ return tableHints;
+ }
+
+ public void setTableHints(Map> tableHints) {
+ this.tableHints = tableHints;
+ }
+
+ /**
+ * Checks for non-null, sane values for the configured values
+ *
+ * @return True if all of the encapsulated values have legitimate values, otherwise false
+ */
+ public boolean canRunQuery() {
+ // Ensure we were given connector and authorizations
+ if (null == this.getClient() || null == this.getAuthorizations()) {
+ return false;
+ }
+
+ // Ensure valid dates
+ if (null == this.getBeginDate() || null == this.getEndDate() || endDate.before(beginDate)) {
+ return false;
+ }
+
+ // A non-empty table was given
+ if (null == getTableName() || this.getTableName().isEmpty()) {
+ return false;
+ }
+
+ // At least one QueryData was provided
+ if (null == this.getQueriesIter()) {
+ return false;
+ }
+
+ return true;
+ }
+
+ @Override
+ public boolean equals(Object o) {
+ if (this == o)
+ return true;
+ if (o == null || getClass() != o.getClass())
+ return false;
+ GenericQueryConfiguration that = (GenericQueryConfiguration) o;
+ return isCheckpointable() == that.isCheckpointable() && getBaseIteratorPriority() == that.getBaseIteratorPriority()
+ && getBypassAccumulo() == that.getBypassAccumulo() && Objects.equals(getAuthorizations(), that.getAuthorizations())
+ && Objects.equals(getQuery(), that.getQuery()) && Objects.equals(getQueryString(), that.getQueryString())
+ && Objects.equals(getBeginDate(), that.getBeginDate()) && Objects.equals(getEndDate(), that.getEndDate())
+ && Objects.equals(getMaxWork(), that.getMaxWork()) && Objects.equals(getTableName(), that.getTableName())
+ && Objects.equals(getQueries(), that.getQueries()) && Objects.equals(getAccumuloPassword(), that.getAccumuloPassword())
+ && Objects.equals(getConnPoolName(), that.getConnPoolName()) && Objects.equals(isReduceResults(), that.isReduceResults());
+ }
+
+ @Override
+ public int hashCode() {
+ return Objects.hash(isCheckpointable(), getAuthorizations(), getQuery(), getQueryString(), getBeginDate(), getEndDate(), getMaxWork(),
+ getBaseIteratorPriority(), getTableName(), getQueries(), getBypassAccumulo(), getConnPoolName(), getAccumuloPassword(),
+ isReduceResults());
+ }
+}
diff --git a/core/query/src/main/java/datawave/core/query/configuration/QueryData.java b/core/query/src/main/java/datawave/core/query/configuration/QueryData.java
new file mode 100644
index 00000000000..a5a4a868a1a
--- /dev/null
+++ b/core/query/src/main/java/datawave/core/query/configuration/QueryData.java
@@ -0,0 +1,556 @@
+package datawave.core.query.configuration;
+
+import java.io.Externalizable;
+import java.io.IOException;
+import java.io.ObjectInput;
+import java.io.ObjectOutput;
+import java.util.ArrayList;
+import java.util.Collection;
+import java.util.Collections;
+import java.util.HashMap;
+import java.util.HashSet;
+import java.util.List;
+import java.util.Map;
+
+import org.apache.accumulo.core.client.IteratorSetting;
+import org.apache.accumulo.core.data.Key;
+import org.apache.accumulo.core.data.Range;
+import org.apache.commons.lang3.builder.EqualsBuilder;
+import org.apache.commons.lang3.builder.HashCodeBuilder;
+import org.apache.hadoop.io.Text;
+
+import com.fasterxml.jackson.core.JsonGenerator;
+import com.fasterxml.jackson.core.JsonParser;
+import com.fasterxml.jackson.core.JsonProcessingException;
+import com.fasterxml.jackson.core.ObjectCodec;
+import com.fasterxml.jackson.databind.DeserializationContext;
+import com.fasterxml.jackson.databind.JsonNode;
+import com.fasterxml.jackson.databind.ObjectMapper;
+import com.fasterxml.jackson.databind.SerializerProvider;
+import com.fasterxml.jackson.databind.annotation.JsonDeserialize;
+import com.fasterxml.jackson.databind.annotation.JsonSerialize;
+import com.fasterxml.jackson.databind.deser.std.StdDeserializer;
+import com.fasterxml.jackson.databind.ser.std.StdSerializer;
+
+/**
+ * Class to encapsulate all required information to run a query.
+ */
+public class QueryData implements ResultContext, Externalizable {
+ private String tableName;
+ private String query;
+ @JsonSerialize(using = RangeListSerializer.class)
+ @JsonDeserialize(using = RangeListDeserializer.class)
+ private Collection ranges = new HashSet<>();
+ private Collection columnFamilies = new HashSet<>();
+ @JsonDeserialize(using = IteratorSettingListDeserializer.class)
+ private List settings = new ArrayList<>();
+ @JsonSerialize(using = KeySerializer.class)
+ @JsonDeserialize(using = KeyDeserializer.class)
+ private Key lastResult;
+ private boolean rebuildHashCode = true;
+ private int hashCode = -1;
+ boolean finished = false;
+
+ public QueryData() {
+ // empty constructor
+ }
+
+ /**
+ * Full constructor
+ *
+ * @param tableName
+ * the table name
+ * @param query
+ * the query string
+ * @param ranges
+ * a collection of ranges
+ * @param columnFamilies
+ * a collection of column families
+ * @param settings
+ * a list of IteratorSetting
+ */
+ public QueryData(String tableName, String query, Collection ranges, Collection columnFamilies, List settings) {
+ this.tableName = tableName;
+ this.query = query;
+ this.ranges = ranges;
+ this.columnFamilies = columnFamilies;
+ this.settings = settings;
+ }
+
+ /**
+ * Copy constructor
+ *
+ * @param other
+ * another instance of QueryData
+ */
+ public QueryData(QueryData other) {
+ this.tableName = other.tableName;
+ this.query = other.query;
+ this.ranges = new HashSet<>(other.ranges);
+ this.columnFamilies = new HashSet<>(other.columnFamilies);
+ this.settings = new ArrayList<>(other.settings);
+ this.hashCode = other.hashCode;
+ this.rebuildHashCode = other.rebuildHashCode;
+ this.lastResult = other.lastResult;
+ this.finished = other.finished;
+ }
+
+ // builder style methods
+
+ public QueryData withTableName(String tableName) {
+ this.tableName = tableName;
+ resetHashCode();
+ return this;
+ }
+
+ public QueryData withQuery(String query) {
+ this.query = query;
+ resetHashCode();
+ return this;
+ }
+
+ public QueryData withRanges(Collection ranges) {
+ this.ranges = ranges;
+ resetHashCode();
+ return this;
+ }
+
+ public QueryData withColumnFamilies(Collection columnFamilies) {
+ this.columnFamilies = columnFamilies;
+ resetHashCode();
+ return this;
+ }
+
+ public QueryData withSettings(List settings) {
+ this.settings = settings;
+ resetHashCode();
+ return this;
+ }
+
+ public void setSettings(List settings) {
+ this.settings.clear();
+ if (settings != null) {
+ this.settings.addAll(settings);
+ }
+ resetHashCode();
+ }
+
+ public List getSettings() {
+ return settings;
+ }
+
+ public void setQuery(String query) {
+ this.query = query;
+ resetHashCode();
+ }
+
+ public String getQuery() {
+ return query;
+ }
+
+ public String getTableName() {
+ return tableName;
+ }
+
+ public void setTableName(String tableName) {
+ this.tableName = tableName;
+ resetHashCode();
+ }
+
+ public Collection getRanges() {
+ if (isFinished()) {
+ return Collections.emptySet();
+ } else if (lastResult != null) {
+ List newRanges = new ArrayList<>();
+ for (Range range : ranges) {
+ if (range.contains(lastResult)) {
+ newRanges.add(new Range(lastResult, false, range.getEndKey(), range.isEndKeyInclusive()));
+ } else {
+ newRanges.add(range);
+ }
+ }
+ return newRanges;
+ }
+ return ranges;
+ }
+
+ public Collection getColumnFamilies() {
+ return columnFamilies;
+ }
+
+ public void setColumnFamilies(Collection columnFamilies) {
+ this.columnFamilies.clear();
+ if (columnFamilies != null) {
+ this.columnFamilies.addAll(columnFamilies);
+ }
+ resetHashCode();
+ }
+
+ public void addColumnFamily(String cf) {
+ this.columnFamilies.add(cf);
+ resetHashCode();
+ }
+
+ public void addColumnFamily(Text cf) {
+ this.columnFamilies.add(cf.toString());
+ resetHashCode();
+ }
+
+ public void setRanges(Collection ranges) {
+ this.ranges.clear();
+ if (null != ranges) {
+ this.ranges.addAll(ranges);
+ }
+ resetHashCode();
+ }
+
+ public void addRange(Range range) {
+ this.ranges.add(range);
+ resetHashCode();
+ }
+
+ public void addIterator(IteratorSetting cfg) {
+ this.settings.add(cfg);
+ resetHashCode();
+ }
+
+ public void setLastResult(Key result) {
+ this.lastResult = result;
+ if (this.lastResult == null) {
+ this.finished = true;
+ }
+ resetHashCode();
+ }
+
+ public boolean isFinished() {
+ return this.finished;
+ }
+
+ public Key getLastResult() {
+ return lastResult;
+ }
+
+ @Override
+ public String toString() {
+ // @formatter:off
+ return new StringBuilder()
+ .append("Query: '").append(this.query)
+ .append("', Ranges: ").append(this.ranges)
+ .append(", lastResult: ").append(this.lastResult)
+ .append(", Settings: ").append(this.settings)
+ .toString();
+ // @formatter:on
+ }
+
+ @Override
+ public void writeExternal(ObjectOutput out) throws IOException {
+ out.writeUTF(tableName);
+ out.writeInt(settings.size());
+ for (IteratorSetting setting : settings) {
+ setting.write(out);
+ }
+ if (query != null) {
+ out.writeBoolean(true);
+ out.writeUTF(query);
+ } else {
+ out.writeBoolean(false);
+ }
+ out.writeInt(ranges.size());
+ for (Range range : ranges) {
+ range.write(out);
+ }
+ out.writeInt(columnFamilies.size());
+ for (String cf : columnFamilies) {
+ out.writeUTF(cf);
+ }
+ if (lastResult != null) {
+ out.writeBoolean(true);
+ lastResult.write(out);
+ } else {
+ out.writeBoolean(false);
+ }
+ out.writeBoolean(finished);
+ }
+
+ @Override
+ public void readExternal(ObjectInput in) throws IOException {
+ tableName = in.readUTF();
+ settings.clear();
+ int count = in.readInt();
+ for (int i = 0; i < count; i++) {
+ settings.add(new IteratorSetting(in));
+ }
+ boolean exists = in.readBoolean();
+ if (exists) {
+ query = in.readUTF();
+ }
+ ranges.clear();
+ count = in.readInt();
+ for (int i = 0; i < count; i++) {
+ Range range = new Range();
+ range.readFields(in);
+ ranges.add(range);
+ }
+ count = in.readInt();
+ for (int i = 0; i < count; i++) {
+ columnFamilies.add(in.readUTF());
+ }
+ exists = in.readBoolean();
+ if (exists) {
+ lastResult = new Key();
+ lastResult.readFields(in);
+ }
+ finished = in.readBoolean();
+ }
+
+ public QueryData(ObjectInput in) throws IOException {
+ readExternal(in);
+ }
+
+ @Override
+ public int hashCode() {
+ if (rebuildHashCode) {
+ // @formatter:off
+ hashCode = new HashCodeBuilder()
+ .append(tableName)
+ .append(query)
+ .append(ranges)
+ .append(columnFamilies)
+ .append(settings)
+ .append(lastResult)
+ .append(finished)
+ .hashCode();
+ rebuildHashCode = false;
+ // @formatter:on
+ }
+ return hashCode;
+ }
+
+ public boolean equals(Object o) {
+ if (o instanceof QueryData) {
+ QueryData other = (QueryData) o;
+ // @formatter:off
+ return new EqualsBuilder()
+ .append(tableName, other.tableName)
+ .append(query, other.query)
+ .append(ranges, other.ranges)
+ .append(columnFamilies, other.columnFamilies)
+ .append(settings, other.settings)
+ .append(lastResult, other.lastResult)
+ .append(finished, other.finished)
+ .isEquals();
+ // @formatter:on
+ }
+ return false;
+ }
+
+ /**
+ * Method to reset the hashcode when an internal variable is updated
+ */
+ private void resetHashCode() {
+ rebuildHashCode = true;
+ }
+
+ /**
+ * A json deserializer for a list of IteratorSetting which handles the json deserialization issues. The accumulo IteratorSetting does not have a default
+ * constructor.
+ */
+ public static class IteratorSettingListDeserializer extends StdDeserializer> {
+ private ObjectMapper mapper = new ObjectMapper();
+
+ public IteratorSettingListDeserializer() {
+ this(null);
+ }
+
+ public IteratorSettingListDeserializer(Class valueClass) {
+ super(valueClass);
+ }
+
+ @Override
+ public List deserialize(JsonParser parser, DeserializationContext deserializer) throws IOException, JsonProcessingException {
+ List list = new ArrayList<>();
+ ObjectCodec codec = parser.getCodec();
+ JsonNode node = codec.readTree(parser);
+
+ for (int i = 0; i < node.size(); i++) {
+ list.add(getIteratorSetting(node.get(i)));
+ }
+
+ return list;
+ }
+
+ private IteratorSetting getIteratorSetting(JsonNode node) throws JsonProcessingException {
+ int priority = -1;
+ String name = null;
+ String iteratorClass = null;
+ Map options = null;
+ JsonNode child = node.get("priority");
+ if (child != null) {
+ priority = child.asInt();
+ }
+ child = node.get("name");
+ if (child != null) {
+ name = child.asText();
+ }
+ child = node.get("iteratorClass");
+ if (child != null) {
+ iteratorClass = child.asText();
+ }
+ child = node.get("options");
+ if (child == null) {
+ child = node.get("properties");
+ }
+ if (child != null) {
+ options = mapper.treeToValue(child, HashMap.class);
+ }
+ IteratorSetting setting = new IteratorSetting(priority, name, iteratorClass);
+ if (options != null) {
+ setting.addOptions(options);
+ }
+ return setting;
+ }
+ }
+
+ /**
+ * A json deserializer for a list of Range which handles the json deserialization issues. The accumulo Range and Key classes do not have appropriate
+ * setters.
+ */
+ public static class RangeListSerializer extends StdSerializer> {
+ private ObjectMapper mapper = new ObjectMapper();
+
+ public RangeListSerializer() {
+ this(null);
+ }
+
+ public RangeListSerializer(Class> type) {
+ super(type);
+ }
+
+ @Override
+ public void serialize(Collection ranges, JsonGenerator jgen, SerializerProvider provider) throws IOException {
+ jgen.writeStartArray(ranges == null ? 0 : ranges.size());
+ if (ranges != null) {
+ for (Range range : ranges) {
+ serialize(range, jgen, provider);
+ }
+ }
+ jgen.writeEndArray();
+ }
+
+ public void serialize(Range range, JsonGenerator jgen, SerializerProvider provider) throws IOException {
+ jgen.writeStartObject();
+ if (range.getStartKey() != null) {
+ jgen.writeFieldName("startKey");
+ new KeySerializer().serialize(range.getStartKey(), jgen, provider);
+ }
+ jgen.writeBooleanField("startKeyInclusive", range.isStartKeyInclusive());
+ if (range.getEndKey() != null) {
+ jgen.writeFieldName("endKey");
+ new KeySerializer().serialize(range.getEndKey(), jgen, provider);
+ }
+ jgen.writeBooleanField("endKeyInclusive", range.isEndKeyInclusive());
+ jgen.writeEndObject();
+ }
+ }
+
+ /**
+ * A json deserializer for a list of Range which handles the json deserialization issues. The accumulo Range and Key classes do not have appropriate
+ * setters.
+ */
+ public static class RangeListDeserializer extends StdDeserializer> {
+ public RangeListDeserializer() {
+ this(null);
+ }
+
+ public RangeListDeserializer(Class valueClass) {
+ super(valueClass);
+ }
+
+ @Override
+ public Collection deserialize(JsonParser parser, DeserializationContext deserializer) throws IOException {
+ ObjectCodec codec = parser.getCodec();
+ JsonNode node = codec.readTree(parser);
+ return deserialize(node);
+ }
+
+ public Collection deserialize(JsonNode node) throws IOException {
+ Collection list = new ArrayList<>();
+ for (int i = 0; i < node.size(); i++) {
+ list.add(getRange(node.get(i)));
+ }
+ return list;
+ }
+
+ private Range getRange(JsonNode node) throws IOException {
+ JsonNode start = node.get("startKey");
+ JsonNode startInclusive = node.get("startKeyInclusive");
+ JsonNode end = node.get("endKey");
+ JsonNode endInclusive = node.get("endKeyInclusive");
+ return new Range(getKey(start), startInclusive.asBoolean(), getKey(end), endInclusive.asBoolean());
+ }
+
+ private Key getKey(JsonNode node) throws IOException {
+ return new KeyDeserializer().deserialize(node);
+ }
+ }
+
+ /**
+ * A json deserializer for a list of Range which handles the json deserialization issues. The accumulo Range and Key classes do not have appropriate
+ * setters.
+ */
+ public static class KeySerializer extends StdSerializer {
+ public KeySerializer() {
+ this(null);
+ }
+
+ public KeySerializer(Class
-[![Apache License][li]][ll] 
+[![Apache License][li]][ll] 
DataWave is a Java-based ingest and query framework that leverages [Apache Accumulo](http://accumulo.apache.org/) to provide fast, secure access to your data. DataWave supports a wide variety of use cases, including but not limited to...
@@ -56,5 +56,9 @@ mvn -Pdocker,dist -DskipMicroservices clean install -T 1C
git submodule deinit --all
```
+### DataWave Microservices
+
+For more information about deploying the datawave quickstart and microservices, check out the [Docker Readme](docker/README.md#usage)
+
[li]: http://img.shields.io/badge/license-ASL-blue.svg
[ll]: https://www.apache.org/licenses/LICENSE-2.0
diff --git a/checkstyle.xml b/checkstyle.xml
index 8744f2ba1a0..6ac2c34afa1 100644
--- a/checkstyle.xml
+++ b/checkstyle.xml
@@ -2,12 +2,14 @@