diff --git a/subprojects/lettucemod/src/main/java/com/redis/lettucemod/RedisModulesUtils.java b/subprojects/lettucemod/src/main/java/com/redis/lettucemod/RedisModulesUtils.java new file mode 100644 index 0000000..853cec3 --- /dev/null +++ b/subprojects/lettucemod/src/main/java/com/redis/lettucemod/RedisModulesUtils.java @@ -0,0 +1,337 @@ +package com.redis.lettucemod; + +import java.io.BufferedReader; +import java.io.IOException; +import java.io.InputStream; +import java.io.InputStreamReader; +import java.nio.charset.Charset; +import java.time.Duration; +import java.util.ArrayList; +import java.util.HashMap; +import java.util.Iterator; +import java.util.List; +import java.util.Map; +import java.util.Optional; +import java.util.concurrent.ExecutionException; +import java.util.concurrent.TimeUnit; +import java.util.concurrent.TimeoutException; +import java.util.function.Consumer; +import java.util.function.Supplier; +import java.util.stream.Collectors; + +import com.redis.lettucemod.api.StatefulRedisModulesConnection; +import com.redis.lettucemod.cluster.RedisModulesClusterClient; +import com.redis.lettucemod.cluster.api.StatefulRedisModulesClusterConnection; +import com.redis.lettucemod.protocol.SearchCommandKeyword; +import com.redis.lettucemod.search.CreateOptions; +import com.redis.lettucemod.search.Field; +import com.redis.lettucemod.search.Field.Type; +import com.redis.lettucemod.search.IndexDefinitionParser; +import com.redis.lettucemod.search.IndexInfo; +import com.redis.lettucemod.search.TagField; +import com.redis.lettucemod.search.TextField; + +import io.lettuce.core.AbstractRedisClient; +import io.lettuce.core.ReadFrom; +import io.lettuce.core.RedisCommandExecutionException; +import io.lettuce.core.RedisFuture; +import io.lettuce.core.codec.RedisCodec; +import io.lettuce.core.codec.StringCodec; +import io.lettuce.core.internal.LettuceAssert; +import io.lettuce.core.internal.LettuceStrings; +import io.lettuce.core.pubsub.StatefulRedisPubSubConnection; + +public class RedisModulesUtils { + + private static final String FIELD_FIELDS = "fields"; + + private static final String FIELD_ATTRIBUTES = "attributes"; + + public static final String ERROR_UNKNOWN_INDEX_NAME = "Unknown Index name"; + + private RedisModulesUtils() { + } + + public static Optional indexInfo(Supplier> infoList) { + try { + return Optional.of(indexInfo(infoList.get())); + } catch (RedisCommandExecutionException e) { + if (ERROR_UNKNOWN_INDEX_NAME.equalsIgnoreCase(e.getMessage())) { + return Optional.empty(); + } + throw e; + } + } + + @SuppressWarnings("unchecked") + public static IndexInfo indexInfo(List infoList) { + LettuceAssert.isTrue(infoList.size() % 2 == 0, + "List must be a multiple of 2 and contain a sequence of field1, value1, field2, value2, ..., fieldN, valueN"); + Map map = new HashMap<>(); + for (int i = 0; i < infoList.size(); i += 2) { + map.put((String) infoList.get(i), infoList.get(i + 1)); + } + IndexInfo indexInfo = new IndexInfo(); + indexInfo.setIndexName(getString(map.get("index_name"))); + CreateOptions.Builder options = CreateOptions.builder(); + indexOptions((List) map.get("index_options"), options); + indexDefinition((List) map.get("index_definition"), options); + indexInfo.setIndexOptions(options.build()); + if (map.containsKey(FIELD_FIELDS)) { + indexInfo.setFields(fieldsFromFields((List) map.getOrDefault(FIELD_FIELDS, new ArrayList<>()))); + } + if (map.containsKey(FIELD_ATTRIBUTES)) { + indexInfo.setFields( + fieldsFromAttributes((List) map.getOrDefault(FIELD_ATTRIBUTES, new ArrayList<>()))); + } + indexInfo.setNumDocs(getDouble(map.get("num_docs"))); + indexInfo.setMaxDocId(getString(map.get("max_doc_id"))); + indexInfo.setNumTerms(toLong(map, "num_terms")); + indexInfo.setNumRecords(toLong(map, "num_records")); + indexInfo.setInvertedSizeMb(getDouble(map.get("inverted_sz_mb"))); + indexInfo.setTotalInvertedIndexBlocks(toLong(map, "total_inverted_index_blocks")); + indexInfo.setVectorIndexSizeMb(getDouble(map.get("vector_index_sz_mb"))); + indexInfo.setOffsetVectorsSizeMb(getDouble(map.get("offset_vectors_sz_mb"))); + indexInfo.setDocTableSizeMb(getDouble(map.get("doc_table_size_mb"))); + indexInfo.setSortableValuesSizeMb(getDouble(map.get("sortable_values_size_mb"))); + indexInfo.setKeyTableSizeMb(getDouble(map.get("key_table_size_mb"))); + indexInfo.setRecordsPerDocAvg(getDouble(map.get("records_per_doc_avg"))); + indexInfo.setBytesPerRecordAvg(getDouble(map.get("bytes_per_record_avg"))); + indexInfo.setOffsetsPerTermAvg(getDouble(map.get("offsets_per_term_avg"))); + indexInfo.setOffsetBitsPerRecordAvg(getDouble(map.get("offset_bits_per_record_avg"))); + indexInfo.setGcStats((List) map.get("gc_stats")); + indexInfo.setCursorStats((List) map.get("cursor_stats")); + return indexInfo; + } + + private static void indexOptions(List list, CreateOptions.Builder options) { + // TODO Missing from FT.INFO: NOHL SKIPINITIALSCAN STOPWORDS TEMPORARY + Iterator iterator = list.iterator(); + while (iterator.hasNext()) { + String key = (String) iterator.next(); + matchOption(key, SearchCommandKeyword.NOOFFSETS, options::noOffsets); + matchOption(key, SearchCommandKeyword.NOHL, options::noHL); + matchOption(key, SearchCommandKeyword.NOFIELDS, options::noFields); + matchOption(key, SearchCommandKeyword.NOFREQS, options::noFreqs); + matchOption(key, SearchCommandKeyword.MAXTEXTFIELDS, options::maxTextFields); + } + } + + private static void matchOption(String key, SearchCommandKeyword keyword, Consumer setter) { + if (key.toUpperCase().equals(keyword.name())) { + setter.accept(true); + } + } + + private static void indexDefinition(List list, CreateOptions.Builder options) { + new IndexDefinitionParser(list, options).parse(); + } + + private static Long getLong(Object object) { + if (object instanceof String) { + try { + return Long.parseLong((String) object); + } catch (NumberFormatException e) { + return null; + } + } + if (object instanceof Long) { + return (Long) object; + } + return null; + } + + public static Double getDouble(Object object) { + if (object instanceof String) { + return LettuceStrings.toDouble((String) object); + } + if (object instanceof Long) { + return ((Long) object).doubleValue(); + } + if (object instanceof Double) { + return (Double) object; + } + return null; + } + + private static String getString(Object object) { + if (object instanceof String) { + return (String) object; + } + return null; + } + + @SuppressWarnings("unchecked") + private static List> fieldsFromAttributes(List list) { + List> fields = new ArrayList<>(); + for (Object object : list) { + List attributes = (List) object; + Field field = field((String) attributes.get(5), (String) attributes.get(1)); + field.setAs((String) attributes.get(3)); + if (attributes.size() > 6) { + populateField(field, attributes.subList(6, attributes.size())); + } + fields.add(field); + } + return fields; + } + + private static void populateField(Field field, List attributes) { + // TODO Missing from FT.INFO: PHONETIC UNF CASESENSITIVE WITHSUFFIXTRIE + if (field.getType() == Type.TAG) { + LettuceAssert.isTrue(SearchCommandKeyword.SEPARATOR.name().equals(attributes.remove(0)), + "Wrong attribute name"); + TagField tagField = (TagField) field; + String separator = (String) attributes.remove(0); + if (!separator.isEmpty()) { + tagField.setSeparator(separator.charAt(0)); + } + tagField.setCaseSensitive(attributes.contains(SearchCommandKeyword.CASESENSITIVE.name())); + } else { + if (field.getType() == Type.TEXT) { + LettuceAssert.isTrue(SearchCommandKeyword.WEIGHT.name().equals(attributes.remove(0)), + "Wrong attribute name"); + TextField textField = (TextField) field; + Object weight = attributes.remove(0); + textField.setWeight(getDouble(weight)); + textField.setNoStem(attributes.contains(SearchCommandKeyword.NOSTEM.name())); + } + } + field.setNoIndex(attributes.contains(SearchCommandKeyword.NOINDEX.name())); + field.setSortable(attributes.contains(SearchCommandKeyword.SORTABLE.name())); + field.setUnNormalizedForm(attributes.contains(SearchCommandKeyword.UNF.name())); + } + + @SuppressWarnings("unchecked") + private static List> fieldsFromFields(List list) { + List> fields = new ArrayList<>(); + for (Object infoObject : list) { + List info = (List) infoObject; + Field field = field((String) info.get(2), (String) info.get(0)); + populateField(field, info.subList(3, info.size())); + fields.add(field); + } + return fields; + } + + private static Field field(String type, String name) { + if (type.toUpperCase().equals(SearchCommandKeyword.GEO.name())) { + return Field.geo(name).build(); + } + if (type.toUpperCase().equals(SearchCommandKeyword.NUMERIC.name())) { + return Field.numeric(name).build(); + } + if (type.toUpperCase().equals(SearchCommandKeyword.TAG.name())) { + return Field.tag(name).build(); + } + if (type.toUpperCase().equals(SearchCommandKeyword.TEXT.name())) { + return Field.text(name).build(); + } + if (type.toUpperCase().equals(SearchCommandKeyword.VECTOR.name())) { + return Field.vector(name).build(); + } + throw new IllegalArgumentException("Unknown field type: " + type); + } + + private static Long toLong(Map map, String key) { + if (!map.containsKey(key)) { + return null; + } + return getLong(map.get(key)); + } + + public static String escapeTag(String value) { + return value.replaceAll("([^a-zA-Z0-9])", "\\\\$1"); + } + + public static String toString(InputStream inputStream, Charset charset) throws IOException { + return toString(new InputStreamReader(inputStream, charset)); + } + + public static String toString(InputStreamReader reader) throws IOException { + try (BufferedReader bufferedReader = new BufferedReader(reader)) { + return bufferedReader.lines().collect(Collectors.joining(System.lineSeparator())); + } + } + + public static String toString(InputStream inputStream) throws IOException { + return toString(new InputStreamReader(inputStream)); + } + + public static StatefulRedisModulesConnection connection(AbstractRedisClient client) { + return connection(client, StringCodec.UTF8); + } + + public static StatefulRedisModulesConnection connection(AbstractRedisClient client, + RedisCodec codec) { + if (client instanceof RedisModulesClusterClient) { + return ((RedisModulesClusterClient) client).connect(codec); + } + return ((RedisModulesClient) client).connect(codec); + } + + public static StatefulRedisPubSubConnection pubSubConnection(AbstractRedisClient client) { + return pubSubConnection(client, StringCodec.UTF8); + } + + public static StatefulRedisPubSubConnection pubSubConnection(AbstractRedisClient client, + RedisCodec codec) { + if (client instanceof RedisModulesClusterClient) { + return ((RedisModulesClusterClient) client).connectPubSub(codec); + } + return ((RedisModulesClient) client).connectPubSub(codec); + } + + public static Supplier> supplier(AbstractRedisClient client, + RedisCodec codec, ReadFrom readFrom) { + if (client instanceof RedisModulesClusterClient) { + RedisModulesClusterClient clusterClient = (RedisModulesClusterClient) client; + return () -> connection(clusterClient, codec, readFrom); + } + RedisModulesClient redisClient = (RedisModulesClient) client; + return () -> redisClient.connect(codec); + } + + public static StatefulRedisModulesConnection connection(AbstractRedisClient client, + RedisCodec codec, ReadFrom readFrom) { + if (client instanceof RedisModulesClusterClient) { + return connection((RedisModulesClusterClient) client, codec, readFrom); + } + return ((RedisModulesClient) client).connect(codec); + } + + public static StatefulRedisModulesClusterConnection connection(RedisModulesClusterClient client, + RedisCodec codec, ReadFrom readFrom) { + StatefulRedisModulesClusterConnection connection = client.connect(codec); + if (readFrom != null) { + connection.setReadFrom(readFrom); + } + return connection; + } + + public static List getAll(Duration timeout, Iterable> futures) + throws TimeoutException, InterruptedException, ExecutionException { + List items = new ArrayList<>(); + long nanos = timeout.toNanos(); + long time = System.nanoTime(); + for (RedisFuture f : futures) { + if (f == null) { + continue; + } + if (timeout.isNegative()) { + items.add(f.get()); + } else { + if (nanos < 0) { + throw new TimeoutException(String.format("Timed out after %s", timeout)); + } + T item = f.get(nanos, TimeUnit.NANOSECONDS); + items.add(item); + long now = System.nanoTime(); + nanos -= now - time; + time = now; + } + } + return items; + } + +} diff --git a/subprojects/lettucemod/src/main/java/com/redis/lettucemod/util/GeoLocation.java b/subprojects/lettucemod/src/main/java/com/redis/lettucemod/search/GeoLocation.java similarity index 96% rename from subprojects/lettucemod/src/main/java/com/redis/lettucemod/util/GeoLocation.java rename to subprojects/lettucemod/src/main/java/com/redis/lettucemod/search/GeoLocation.java index 4b03ce4..aafbbd5 100644 --- a/subprojects/lettucemod/src/main/java/com/redis/lettucemod/util/GeoLocation.java +++ b/subprojects/lettucemod/src/main/java/com/redis/lettucemod/search/GeoLocation.java @@ -1,4 +1,4 @@ -package com.redis.lettucemod.util; +package com.redis.lettucemod.search; import io.lettuce.core.internal.LettuceAssert; diff --git a/subprojects/lettucemod/src/main/java/com/redis/lettucemod/util/IndexDefinitionParser.java b/subprojects/lettucemod/src/main/java/com/redis/lettucemod/search/IndexDefinitionParser.java similarity index 92% rename from subprojects/lettucemod/src/main/java/com/redis/lettucemod/util/IndexDefinitionParser.java rename to subprojects/lettucemod/src/main/java/com/redis/lettucemod/search/IndexDefinitionParser.java index 49976ca..3a07fa4 100644 --- a/subprojects/lettucemod/src/main/java/com/redis/lettucemod/util/IndexDefinitionParser.java +++ b/subprojects/lettucemod/src/main/java/com/redis/lettucemod/search/IndexDefinitionParser.java @@ -1,11 +1,10 @@ -package com.redis.lettucemod.util; +package com.redis.lettucemod.search; import java.util.Iterator; import java.util.List; -import com.redis.lettucemod.search.CreateOptions; +import com.redis.lettucemod.RedisModulesUtils; import com.redis.lettucemod.search.CreateOptions.DataType; -import com.redis.lettucemod.search.Language; public class IndexDefinitionParser { diff --git a/subprojects/lettucemod/src/main/java/com/redis/lettucemod/util/RedisModulesUtils.java b/subprojects/lettucemod/src/main/java/com/redis/lettucemod/util/RedisModulesUtils.java deleted file mode 100644 index 7e263d9..0000000 --- a/subprojects/lettucemod/src/main/java/com/redis/lettucemod/util/RedisModulesUtils.java +++ /dev/null @@ -1,271 +0,0 @@ -package com.redis.lettucemod.util; - -import java.io.BufferedReader; -import java.io.InputStream; -import java.io.InputStreamReader; -import java.nio.charset.Charset; -import java.util.ArrayList; -import java.util.HashMap; -import java.util.Iterator; -import java.util.List; -import java.util.Map; -import java.util.Optional; -import java.util.function.Consumer; -import java.util.function.Supplier; -import java.util.stream.Collectors; - -import com.redis.lettucemod.RedisModulesClient; -import com.redis.lettucemod.api.StatefulRedisModulesConnection; -import com.redis.lettucemod.cluster.RedisModulesClusterClient; -import com.redis.lettucemod.protocol.SearchCommandKeyword; -import com.redis.lettucemod.search.CreateOptions; -import com.redis.lettucemod.search.Field; -import com.redis.lettucemod.search.Field.Type; -import com.redis.lettucemod.search.IndexInfo; -import com.redis.lettucemod.search.TagField; -import com.redis.lettucemod.search.TextField; - -import io.lettuce.core.AbstractRedisClient; -import io.lettuce.core.RedisCommandExecutionException; -import io.lettuce.core.codec.RedisCodec; -import io.lettuce.core.codec.StringCodec; -import io.lettuce.core.internal.LettuceAssert; -import io.lettuce.core.internal.LettuceStrings; -import io.lettuce.core.pubsub.StatefulRedisPubSubConnection; - -public class RedisModulesUtils { - - private static final String FIELD_FIELDS = "fields"; - - private static final String FIELD_ATTRIBUTES = "attributes"; - - public static final String ERROR_UNKNOWN_INDEX_NAME = "Unknown Index name"; - - private RedisModulesUtils() { - } - - public static Optional indexInfo(Supplier> infoList) { - try { - return Optional.of(indexInfo(infoList.get())); - } catch (RedisCommandExecutionException e) { - if (ERROR_UNKNOWN_INDEX_NAME.equalsIgnoreCase(e.getMessage())) { - return Optional.empty(); - } - throw e; - } - } - - @SuppressWarnings("unchecked") - public static IndexInfo indexInfo(List infoList) { - LettuceAssert.isTrue(infoList.size() % 2 == 0, - "List must be a multiple of 2 and contain a sequence of field1, value1, field2, value2, ..., fieldN, valueN"); - Map map = new HashMap<>(); - for (int i = 0; i < infoList.size(); i += 2) { - map.put((String) infoList.get(i), infoList.get(i + 1)); - } - IndexInfo indexInfo = new IndexInfo(); - indexInfo.setIndexName(getString(map.get("index_name"))); - CreateOptions.Builder options = CreateOptions.builder(); - indexOptions((List) map.get("index_options"), options); - indexDefinition((List) map.get("index_definition"), options); - indexInfo.setIndexOptions(options.build()); - if (map.containsKey(FIELD_FIELDS)) { - indexInfo.setFields(fieldsFromFields((List) map.getOrDefault(FIELD_FIELDS, new ArrayList<>()))); - } - if (map.containsKey(FIELD_ATTRIBUTES)) { - indexInfo.setFields(fieldsFromAttributes((List) map.getOrDefault(FIELD_ATTRIBUTES, new ArrayList<>()))); - } - indexInfo.setNumDocs(getDouble(map.get("num_docs"))); - indexInfo.setMaxDocId(getString(map.get("max_doc_id"))); - indexInfo.setNumTerms(toLong(map, "num_terms")); - indexInfo.setNumRecords(toLong(map, "num_records")); - indexInfo.setInvertedSizeMb(getDouble(map.get("inverted_sz_mb"))); - indexInfo.setTotalInvertedIndexBlocks(toLong(map, "total_inverted_index_blocks")); - indexInfo.setVectorIndexSizeMb(getDouble(map.get("vector_index_sz_mb"))); - indexInfo.setOffsetVectorsSizeMb(getDouble(map.get("offset_vectors_sz_mb"))); - indexInfo.setDocTableSizeMb(getDouble(map.get("doc_table_size_mb"))); - indexInfo.setSortableValuesSizeMb(getDouble(map.get("sortable_values_size_mb"))); - indexInfo.setKeyTableSizeMb(getDouble(map.get("key_table_size_mb"))); - indexInfo.setRecordsPerDocAvg(getDouble(map.get("records_per_doc_avg"))); - indexInfo.setBytesPerRecordAvg(getDouble(map.get("bytes_per_record_avg"))); - indexInfo.setOffsetsPerTermAvg(getDouble(map.get("offsets_per_term_avg"))); - indexInfo.setOffsetBitsPerRecordAvg(getDouble(map.get("offset_bits_per_record_avg"))); - indexInfo.setGcStats((List) map.get("gc_stats")); - indexInfo.setCursorStats((List) map.get("cursor_stats")); - return indexInfo; - } - - private static void indexOptions(List list, CreateOptions.Builder options) { - // TODO Missing from FT.INFO: NOHL SKIPINITIALSCAN STOPWORDS TEMPORARY - Iterator iterator = list.iterator(); - while (iterator.hasNext()) { - String key = (String) iterator.next(); - matchOption(key, SearchCommandKeyword.NOOFFSETS, options::noOffsets); - matchOption(key, SearchCommandKeyword.NOHL, options::noHL); - matchOption(key, SearchCommandKeyword.NOFIELDS, options::noFields); - matchOption(key, SearchCommandKeyword.NOFREQS, options::noFreqs); - matchOption(key, SearchCommandKeyword.MAXTEXTFIELDS, options::maxTextFields); - } - } - - private static void matchOption(String key, SearchCommandKeyword keyword, Consumer setter) { - if (key.toUpperCase().equals(keyword.name())) { - setter.accept(true); - } - } - - private static void indexDefinition(List list, CreateOptions.Builder options) { - new IndexDefinitionParser(list, options).parse(); - } - - private static Long getLong(Object object) { - if (object instanceof String) { - try { - return Long.parseLong((String) object); - } catch (NumberFormatException e) { - return null; - } - } - if (object instanceof Long) { - return (Long) object; - } - return null; - } - - static Double getDouble(Object object) { - if (object instanceof String) { - return LettuceStrings.toDouble((String) object); - } - if (object instanceof Long) { - return ((Long) object).doubleValue(); - } - if (object instanceof Double) { - return (Double) object; - } - return null; - } - - private static String getString(Object object) { - if (object instanceof String) { - return (String) object; - } - return null; - } - - @SuppressWarnings("unchecked") - private static List> fieldsFromAttributes(List list) { - List> fields = new ArrayList<>(); - for (Object object : list) { - List attributes = (List) object; - Field field = field((String) attributes.get(5), (String) attributes.get(1)); - field.setAs((String) attributes.get(3)); - if (attributes.size() > 6) { - populateField(field, attributes.subList(6, attributes.size())); - } - fields.add(field); - } - return fields; - } - - private static void populateField(Field field, List attributes) { - // TODO Missing from FT.INFO: PHONETIC UNF CASESENSITIVE WITHSUFFIXTRIE - if (field.getType() == Type.TAG) { - LettuceAssert.isTrue(SearchCommandKeyword.SEPARATOR.name().equals(attributes.remove(0)), "Wrong attribute name"); - TagField tagField = (TagField) field; - String separator = (String) attributes.remove(0); - if (!separator.isEmpty()) { - tagField.setSeparator(separator.charAt(0)); - } - tagField.setCaseSensitive(attributes.contains(SearchCommandKeyword.CASESENSITIVE.name())); - } else { - if (field.getType() == Type.TEXT) { - LettuceAssert.isTrue(SearchCommandKeyword.WEIGHT.name().equals(attributes.remove(0)), "Wrong attribute name"); - TextField textField = (TextField) field; - Object weight = attributes.remove(0); - textField.setWeight(getDouble(weight)); - textField.setNoStem(attributes.contains(SearchCommandKeyword.NOSTEM.name())); - } - } - field.setNoIndex(attributes.contains(SearchCommandKeyword.NOINDEX.name())); - field.setSortable(attributes.contains(SearchCommandKeyword.SORTABLE.name())); - field.setUnNormalizedForm(attributes.contains(SearchCommandKeyword.UNF.name())); - } - - @SuppressWarnings("unchecked") - private static List> fieldsFromFields(List list) { - List> fields = new ArrayList<>(); - for (Object infoObject : list) { - List info = (List) infoObject; - Field field = field((String) info.get(2), (String) info.get(0)); - populateField(field, info.subList(3, info.size())); - fields.add(field); - } - return fields; - } - - private static Field field(String type, String name) { - if (type.toUpperCase().equals(SearchCommandKeyword.GEO.name())) { - return Field.geo(name).build(); - } - if (type.toUpperCase().equals(SearchCommandKeyword.NUMERIC.name())) { - return Field.numeric(name).build(); - } - if (type.toUpperCase().equals(SearchCommandKeyword.TAG.name())) { - return Field.tag(name).build(); - } - if (type.toUpperCase().equals(SearchCommandKeyword.TEXT.name())) { - return Field.text(name).build(); - } - if (type.toUpperCase().equals(SearchCommandKeyword.VECTOR.name())) { - return Field.vector(name).build(); - } - throw new IllegalArgumentException("Unknown field type: " + type); - } - - private static Long toLong(Map map, String key) { - if (!map.containsKey(key)) { - return null; - } - return getLong(map.get(key)); - } - - public static String escapeTag(String value) { - return value.replaceAll("([^a-zA-Z0-9])", "\\\\$1"); - } - - public static String toString(InputStream inputStream, Charset charset) { - return toString(new InputStreamReader(inputStream, charset)); - } - - public static String toString(InputStreamReader reader) { - return new BufferedReader(reader).lines().collect(Collectors.joining(System.lineSeparator())); - } - - public static String toString(InputStream inputStream) { - return toString(new InputStreamReader(inputStream)); - } - - public static StatefulRedisModulesConnection connection(AbstractRedisClient client) { - return connection(client, StringCodec.UTF8); - } - - public static StatefulRedisModulesConnection connection(AbstractRedisClient client, RedisCodec codec) { - if (client instanceof RedisModulesClusterClient) { - return ((RedisModulesClusterClient) client).connect(codec); - } - return ((RedisModulesClient) client).connect(codec); - } - - public static StatefulRedisPubSubConnection pubSubConnection(AbstractRedisClient client) { - return pubSubConnection(client, StringCodec.UTF8); - } - - public static StatefulRedisPubSubConnection pubSubConnection(AbstractRedisClient client, - RedisCodec codec) { - if (client instanceof RedisModulesClusterClient) { - return ((RedisModulesClusterClient) client).connectPubSub(codec); - } - return ((RedisModulesClient) client).connectPubSub(codec); - } - -} diff --git a/subprojects/lettucemod/src/test/java/com/redis/lettucemod/EnterpriseTests.java b/subprojects/lettucemod/src/test/java/com/redis/lettucemod/EnterpriseTests.java index 12156e3..3d9d1df 100644 --- a/subprojects/lettucemod/src/test/java/com/redis/lettucemod/EnterpriseTests.java +++ b/subprojects/lettucemod/src/test/java/com/redis/lettucemod/EnterpriseTests.java @@ -8,7 +8,7 @@ import com.redis.enterprise.RedisModule; import com.redis.lettucemod.cluster.RedisModulesClusterClient; import com.redis.lettucemod.cluster.api.StatefulRedisModulesClusterConnection; -import com.redis.testcontainers.RedisEnterpriseContainer; +import com.redis.enterprise.testcontainers.RedisEnterpriseContainer; import com.redis.testcontainers.RedisServer; import io.lettuce.core.RedisURI; @@ -18,10 +18,12 @@ @EnabledOnOs(OS.LINUX) class EnterpriseTests extends ModulesTests { + private final Database database = Database.builder().name("ModulesTests").memoryMB(110).ossCluster(true) + .modules(RedisModule.SEARCH, RedisModule.JSON, RedisModule.BLOOM, RedisModule.TIMESERIES).build(); + private final RedisEnterpriseContainer container = new RedisEnterpriseContainer( - RedisEnterpriseContainer.DEFAULT_IMAGE_NAME.withTag("latest")) - .withDatabase(Database.builder().name("ModulesTests").memoryMB(110).ossCluster(true) - .modules(RedisModule.SEARCH, RedisModule.JSON, RedisModule.BLOOM, RedisModule.TIMESERIES).build()); + RedisEnterpriseContainer.DEFAULT_IMAGE_NAME.withTag(RedisEnterpriseContainer.DEFAULT_TAG)) + .withDatabase(database); @Override protected RedisServer getRedisServer() { diff --git a/subprojects/lettucemod/src/test/java/com/redis/lettucemod/ModulesTests.java b/subprojects/lettucemod/src/test/java/com/redis/lettucemod/ModulesTests.java index f03b059..0c79ae0 100644 --- a/subprojects/lettucemod/src/test/java/com/redis/lettucemod/ModulesTests.java +++ b/subprojects/lettucemod/src/test/java/com/redis/lettucemod/ModulesTests.java @@ -82,6 +82,7 @@ import com.redis.lettucemod.search.CursorOptions; import com.redis.lettucemod.search.Document; import com.redis.lettucemod.search.Field; +import com.redis.lettucemod.search.GeoLocation; import com.redis.lettucemod.search.Group; import com.redis.lettucemod.search.IndexInfo; import com.redis.lettucemod.search.Language; @@ -107,8 +108,6 @@ import com.redis.lettucemod.timeseries.RangeOptions; import com.redis.lettucemod.timeseries.Sample; import com.redis.lettucemod.timeseries.TimeRange; -import com.redis.lettucemod.util.GeoLocation; -import com.redis.lettucemod.util.RedisModulesUtils; import com.redis.testcontainers.RedisServer; import io.lettuce.core.AbstractRedisClient; diff --git a/subprojects/lettucemod/src/test/java/com/redis/lettucemod/StackTests.java b/subprojects/lettucemod/src/test/java/com/redis/lettucemod/StackTests.java index 3343038..4fca859 100644 --- a/subprojects/lettucemod/src/test/java/com/redis/lettucemod/StackTests.java +++ b/subprojects/lettucemod/src/test/java/com/redis/lettucemod/StackTests.java @@ -24,8 +24,7 @@ import com.redis.lettucemod.timeseries.RangeResult; import com.redis.lettucemod.timeseries.Sample; import com.redis.lettucemod.timeseries.TimeRange; -import com.redis.lettucemod.util.RedisModulesUtils; -import com.redis.testcontainers.AbstractRedisContainer; +import com.redis.testcontainers.RedisServer; import com.redis.testcontainers.RedisStackContainer; import io.lettuce.core.AbstractRedisClient; @@ -42,7 +41,7 @@ class StackTests extends ModulesTests { private final RedisStackContainer container = new RedisStackContainer(imageName); @Override - protected AbstractRedisContainer getRedisServer() { + protected RedisServer getRedisServer() { return container; } diff --git a/subprojects/lettucemod/src/test/java/com/redis/lettucemod/Usage.java b/subprojects/lettucemod/src/test/java/com/redis/lettucemod/Usage.java index 6dcd960..9778db5 100644 --- a/subprojects/lettucemod/src/test/java/com/redis/lettucemod/Usage.java +++ b/subprojects/lettucemod/src/test/java/com/redis/lettucemod/Usage.java @@ -6,11 +6,11 @@ import java.util.Collections; import java.util.List; import java.util.concurrent.TimeUnit; -import java.util.logging.Level; -import java.util.logging.Logger; import org.apache.commons.pool2.impl.GenericObjectPool; import org.apache.commons.pool2.impl.GenericObjectPoolConfig; +import org.slf4j.Logger; +import org.slf4j.LoggerFactory; import com.redis.lettucemod.RedisModulesClient; import com.redis.lettucemod.api.StatefulRedisModulesConnection; @@ -38,7 +38,7 @@ @SuppressWarnings("unused") public class Usage { - private static final Logger log = Logger.getLogger(Usage.class.getName()); + private final Logger log = LoggerFactory.getLogger(Usage.class); @SuppressWarnings("unchecked") void usage() { @@ -161,7 +161,7 @@ public void connectionPooling() { } catch (Exception e) { - log.log(Level.SEVERE, "Could not get a connection from the pool", e); + log.error("Could not get a connection from the pool", e); }