pulling query info into table

core/redis-smart-cache-core/src/main/java/com/redis/smartcache/core/Config.java

@@ -361,6 +361,7 @@ public static class RuleConfig {
 		private List<String> tablesAny;
 		private List<String> tablesAll;
 		private String regex;
+
 		private List<String> queryIds;
 		private Duration ttl = DEFAULT_TTL;
 

core/redis-smart-cache-core/src/main/java/com/redis/smartcache/core/Query.java

@@ -0,0 +1,71 @@
+package com.redis.smartcache.core;
+
+import java.util.Set;
+
+public class Query {
+
+	private String id;
+	private String sql;
+	private Set<String> tables;
+
+	public Query(){
+	}
+	private Query(QueryBuilder builder) {
+		this.id = builder.id;
+		this.sql = builder.sql;
+		this.tables = builder.tables;
+	}
+
+	public String getId() {
+		return id;
+	}
+
+	public void setId(String id) {
+		this.id = id;
+	}
+
+	public String getSql() {
+		return sql;
+	}
+
+	public void setSql(String sql) {
+		this.sql = sql;
+	}
+
+	public Set<String> getTables() {
+		return tables;
+	}
+
+	public void setTables(Set<String> tables) {
+		this.tables = tables;
+	}
+
+	public static class QueryBuilder {
+		private String id;
+		private String sql;
+		private Set<String> tables;
+
+		public QueryBuilder() {}
+
+		public QueryBuilder setId(String id) {
+			this.id = id;
+			return this;
+		}
+
+		public QueryBuilder setSql(String sql) {
+			this.sql = sql;
+			return this;
+		}
+
+		public QueryBuilder setTables(Set<String> tables) {
+			this.tables = tables;
+			return this;
+		}
+
+		public Query build() {
+			return new Query(this);
+		}
+	}
+
+
+}

core/redis-smart-cache-jdbc/src/main/java/com/redis/smartcache/Driver.java

@@ -27,7 +27,7 @@
 import com.redis.smartcache.core.Mappers;
 import com.redis.smartcache.core.MeterRegistryManager;
 import com.redis.smartcache.core.RulesetManager;
-import com.redis.smartcache.jdbc.Query;
+import com.redis.smartcache.core.Query;
 import com.redis.smartcache.jdbc.QueryRuleSession;
 import com.redis.smartcache.jdbc.RedisResultSetCache;
 import com.redis.smartcache.jdbc.ResultSetCache;

core/redis-smart-cache-jdbc/src/main/java/com/redis/smartcache/jdbc/QueryRuleSession.java

@@ -11,6 +11,7 @@
 import com.google.common.base.Predicates;
 import com.redis.smartcache.core.Config.RuleConfig;
 import com.redis.smartcache.core.Config.RulesetConfig;
+import com.redis.smartcache.core.Query;
 import com.redis.smartcache.core.rules.CollectionRule;
 import com.redis.smartcache.core.rules.PredicateRule;
 import com.redis.smartcache.core.rules.RegexRule;

core/redis-smart-cache-jdbc/src/main/java/com/redis/smartcache/jdbc/SmartConnection.java

@@ -27,6 +27,7 @@
 import com.redis.smartcache.Driver;
 import com.redis.smartcache.core.KeyBuilder;
 
+import com.redis.smartcache.core.Query;
 import io.micrometer.core.instrument.MeterRegistry;
 
 public class SmartConnection implements Connection {

core/redis-smart-cache-jdbc/src/main/java/com/redis/smartcache/jdbc/SmartStatement.java

@@ -9,6 +9,7 @@
 
 import com.redis.smartcache.core.Fields;
 
+import com.redis.smartcache.core.Query;
 import io.micrometer.core.instrument.Counter;
 import io.micrometer.core.instrument.Tags;
 import io.micrometer.core.instrument.Timer;

core/redis-smart-cache-jdbc/src/test/java/com/redis/smartcache/jdbc/RulesTests.java

@@ -2,6 +2,7 @@
 
 import java.util.concurrent.TimeUnit;
 
+import com.redis.smartcache.core.Query;
 import org.junit.jupiter.api.Assertions;
 import org.junit.jupiter.api.Test;
 

tools/redis-smart-cache-cli/redis-smart-cache-cli.gradle

@@ -1,7 +1,13 @@
 dependencies {
     implementation project(':redis-smart-cache-core')
+    implementation group: 'io.lettuce', name: 'lettuce-core', version: '6.2.4.RELEASE'
+    implementation group: 'org.springframework.data', name: 'spring-data-redis', version: '2.7.11'
+    implementation 'com.fasterxml.jackson.core:jackson-databind'
+    implementation 'com.fasterxml.jackson.dataformat:jackson-dataformat-properties'
     implementation 'org.springframework.boot:spring-boot-starter'
     implementation 'org.springframework.shell:spring-shell-starter'
+    implementation group: 'io.airlift', name: 'units', version: airliftVersion
+    implementation 'com.redis:lettucemod:3.5.0'
 }
 
 dependencyManagement {

tools/redis-smart-cache-cli/src/main/java/com/redis/smartcache/cli/RedisConfig.java

@@ -0,0 +1,54 @@
+package com.redis.smartcache.cli;
+
+import com.redis.lettucemod.RedisModulesClient;
+import com.redis.lettucemod.api.StatefulRedisModulesConnection;
+import com.redis.smartcache.core.ClientManager;
+import com.redis.smartcache.core.Config;
+import io.lettuce.core.AbstractRedisClient;
+import io.lettuce.core.RedisClient;
+import io.lettuce.core.api.StatefulRedisConnection;
+import org.springframework.beans.factory.annotation.Value;
+import org.springframework.boot.autoconfigure.cache.CacheProperties;
+import org.springframework.boot.autoconfigure.condition.ConditionalOnMissingBean;
+import org.springframework.boot.autoconfigure.data.redis.RedisProperties;
+import org.springframework.boot.context.properties.EnableConfigurationProperties;
+import org.springframework.context.annotation.Bean;
+import org.springframework.context.annotation.Configuration;
+import org.springframework.context.annotation.Primary;
+import org.springframework.data.redis.connection.RedisConnectionFactory;
+import org.springframework.data.redis.connection.RedisStandaloneConfiguration;
+import org.springframework.data.redis.connection.lettuce.LettuceConnectionFactory;
+import org.springframework.data.redis.connection.lettuce.LettucePoolingClientConfiguration;
+import org.springframework.data.redis.core.RedisTemplate;
+
+import io.lettuce.core.ClientOptions;
+import io.lettuce.core.resource.ClientResources;
+import io.lettuce.core.resource.DefaultClientResources;
+
+@Configuration
+@EnableConfigurationProperties(RedisProperties.class)
+public class RedisConfig {
+    @Bean
+    public Config conf(){
+        Config config = new Config();
+        Config.RedisConfig conf = new Config.RedisConfig();
+        conf.setUri("redis://localhost:6379");
+        config.setRedis(conf);
+        return config;
+    }
+
+    @Bean
+    public ClientManager abstractRedisClient(){
+        return new ClientManager();
+    }
+
+//    @Bean
+//    public StatefulRedisConnection<String,String> redisClient() {
+//        return RedisClient.create("redis://localhost:6379").connect();
+//    }
+
+    @Bean
+    public StatefulRedisModulesConnection<String, String> modClient(){
+        return RedisModulesClient.create("redis://localhost:6379").connect();
+    }
+}

tools/redis-smart-cache-cli/src/main/java/com/redis/smartcache/cli/RedisService.java

@@ -0,0 +1,11 @@
+package com.redis.smartcache.cli;
+
+import com.redis.smartcache.cli.structures.QueryInfo;
+
+import java.util.List;
+
+public interface RedisService {
+    String ping();
+    List<QueryInfo> getQueries(String applicationName);
+
+}

tools/redis-smart-cache-cli/src/main/java/com/redis/smartcache/cli/RedisServiceImpl.java

@@ -0,0 +1,82 @@
+package com.redis.smartcache.cli;
+
+import com.fasterxml.jackson.annotation.JsonInclude;
+import com.fasterxml.jackson.databind.DeserializationFeature;
+import com.fasterxml.jackson.databind.PropertyNamingStrategies;
+import com.fasterxml.jackson.dataformat.javaprop.JavaPropsMapper;
+import com.redis.lettucemod.api.StatefulRedisModulesConnection;
+import com.redis.lettucemod.api.sync.RediSearchCommands;
+import com.redis.lettucemod.api.sync.RedisTimeSeriesCommands;
+import com.redis.lettucemod.search.Document;
+import com.redis.lettucemod.search.SearchResults;
+import com.redis.lettucemod.timeseries.GetResult;
+import com.redis.lettucemod.timeseries.Label;
+import com.redis.smartcache.cli.structures.QueryInfo;
+import com.redis.smartcache.cli.util.Util;
+import com.redis.smartcache.core.ClientManager;
+import com.redis.smartcache.core.Config;
+import com.redis.smartcache.core.Config.RuleConfig;
+import com.redis.smartcache.core.Query;
+import com.redis.smartcache.core.RulesetManager;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.stereotype.Service;
+import io.airlift.units.Duration;
+
+import java.util.*;
+import java.util.concurrent.TimeUnit;
+
+@Service
+public class RedisServiceImpl implements RedisService{
+    @Autowired
+    Config conf;
+
+    @Autowired
+    ClientManager manager;
+
+    @Autowired
+    StatefulRedisModulesConnection<String, String> connection;
+
+
+    public String ping(){
+        return connection.sync().ping();
+    }
+
+    public List<RuleConfig> GetRules(){
+        RulesetManager rulesetManager = new RulesetManager(manager);
+
+        Config.RulesetConfig ruleSetConfig = rulesetManager.getRuleset(conf);
+        return ruleSetConfig.getRules();
+    }
+
+    static String configKeyName(String applicationName){
+        return String.format("%s:config", applicationName);
+    }
+
+    static String HashKeyName(String applicationName, String id){
+        return String.format("%s:query:%s", applicationName, id);
+
+    }
+
+    static String IndexName(String applicationName){
+        return String.format("%s-query-idx", applicationName);
+    }
+
+    public List<QueryInfo> getQueries(String applicationName){
+        List<QueryInfo> response = new ArrayList<>();
+        List<RuleConfig> rules = GetRules();
+
+        RediSearchCommands<String, String> searchCommands = connection.sync();
+
+        SearchResults<String, String> searchResults = searchCommands.ftSearch(IndexName(applicationName), "*");
+
+        for(Document<String, String> doc : searchResults){
+
+            QueryInfo qi = QueryInfo.fromDocument(doc);
+            Optional<RuleConfig> currentRule = QueryInfo.matchRule(qi.getQuery(), rules);
+            currentRule.ifPresent(qi::setCurrentRule);
+            response.add(qi);
+
+        }
+        return response;
+    }
+}

tools/redis-smart-cache-cli/src/main/java/com/redis/smartcache/cli/commands/Commands.java

@@ -0,0 +1,44 @@
+package com.redis.smartcache.cli.commands;
+
+import com.redis.smartcache.cli.RedisServiceImpl;
+import com.redis.smartcache.cli.components.TableSelector;
+import com.redis.smartcache.cli.structures.QueryInfo;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.shell.component.support.SelectorItem;
+import org.springframework.shell.standard.AbstractShellComponent;
+import org.springframework.shell.standard.ShellComponent;
+import org.springframework.shell.standard.ShellMethod;
+
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.List;
+import java.util.Optional;
+
+@ShellComponent
+public class Commands extends AbstractShellComponent {
+    @Autowired
+    RedisServiceImpl client;
+
+    @ShellMethod(key = "ping", value = "ping")
+    String ping(){
+        return client.ping();
+    }
+
+    @ShellMethod(key = "list-queries", value = "Get the table of queries", group = "Components")
+    public String queryTable(){
+        List<SelectorItem<QueryInfo>> queries = new ArrayList<>();
+
+        for (QueryInfo q : client.getQueries("smartcache")){
+            queries.add(SelectorItem.of(q.getQueryId(),q));
+        }
+
+        TableSelector<QueryInfo, SelectorItem<QueryInfo>> component = new TableSelector<>(getTerminal(),
+                queries, "queries", null, QueryInfo.getHeaderRow((getTerminal().getWidth()-10)/8));
+        component.setResourceLoader(getResourceLoader());
+        component.setTemplateExecutor(getTemplateExecutor());
+        TableSelector.SingleItemSelectorContext<QueryInfo, SelectorItem<QueryInfo>> context = component
+                .run(TableSelector.SingleItemSelectorContext.empty());
+        QueryInfo result = context.getResultItem().flatMap(si -> Optional.ofNullable(si.getItem())).get();
+        return "Got value " + result.toString();
+    }
+}