25600722838

Committed 09 May 2026 12:06PM UTC coverage: 83.396% (-5.3%) from 88.677%

Build # 25600722838

Build Type

push

github

Committed by

web-flow

Commit Message

Nats v2 web (#295)

* ci: compile main sources in coverage_report job

The coverage_report job was producing an effectively empty
jacocoTestReport.xml (3.4KB vs ~1.1MB locally) because no .class files
existed when coverageReportOnly ran — the job checked out source code
and downloaded .exec artifacts, but never compiled. JaCoCo's report
generator skips packages/classes it cannot resolve, so the merged XML
ended up with only <sessioninfo> entries and no <package> elements.

That made coverallsJacoco silently no-op via the
"source file set empty, skipping" branch in CoverallsReporter, so
"Push coverage to Coveralls" reported success without uploading.

Verified by downloading the coverage-report artifact from a recent run
and comparing its XML structure against a local build's report.

Assisted-By: Claude Code

* nats-web: implement pause / soft-delete admin ops and capability-aware Q-detail

Replace the all-stub `NatsRqueueUtilityService` with real impls for the operations
JetStream can model: `pauseUnpauseQueue` persists the `paused` flag on `QueueConfig`
in the queue-config KV bucket and notifies the local listener container so the poller
stops dispatching; `deleteMessage` is a soft delete via `MessageMetadataService`
(stream message persists, dashboard hides via the metadata flag); `getDataType`
reports `STREAM`. `moveMessage`, `enqueueMessage`, and `makeEmpty` deliberately
remain "not supported" — there is no JetStream primitive for those.

Update `RqueueQDetailServiceImpl.getRunningTasks` / `getScheduledTasks` to return
header-only tables when the broker capabilities suppress those sections, instead of
emitting zero rows or 501s on NATS.

20 new unit tests cover the pause/delete paths and lock in the still-unsupported
operations. Updates `nats-task.md` / `nats-task-v2.md` to reflect what landed.

Assisted-By: Claude Code

* nats-web: capability-aware nav / charts and stream-based peek

End-to-end browser-tested the NATS dashboard and shipped the t... (continued)

Coverage Stats

2566 of 3407 branches covered (75.32%)

Branch coverage included in aggregate %.

795 of 1072 new or added lines in 22 files covered. (74.16%)

312 existing lines in 38 files now uncovered.

7715 of 8921 relevant lines covered (86.48%)

0.86 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

91.55

/rqueue-core/src/main/java/com/github/sonus21/rqueue/utils/RedisUtils.java

/*
 * Copyright (c) 2019-2026 Sonu Kumar
 *
 * 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
 *
 *     https://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 com.github.sonus21.rqueue.utils;

import com.github.sonus21.rqueue.common.RqueueRedisTemplate;
import com.github.sonus21.rqueue.converter.RqueueRedisSerializer;
import java.util.List;
import org.springframework.data.redis.connection.ReactiveRedisConnectionFactory;
import org.springframework.data.redis.connection.RedisConnection;
import org.springframework.data.redis.connection.RedisConnectionFactory;
import org.springframework.data.redis.connection.ReturnType;
import org.springframework.data.redis.core.ReactiveRedisTemplate;
import org.springframework.data.redis.core.RedisCallback;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.data.redis.serializer.RedisSerializationContext;
import org.springframework.data.redis.serializer.RedisSerializationContext.RedisSerializationContextBuilder;
import org.springframework.data.redis.serializer.RedisSerializer;
import org.springframework.data.redis.serializer.StringRedisSerializer;

public final class RedisUtils {

  @SuppressWarnings({"java:S1104", "java:S1444"})
  public static RedisTemplateProvider redisTemplateProvider = new RedisTemplateProvider() {
    @Override
    public <V> RedisTemplate<String, V> getRedisTemplate(
        RedisConnectionFactory redisConnectionFactory) {
      RedisTemplate<String, V> redisTemplate = new RedisTemplate<>();
      StringRedisSerializer stringRedisSerializer = new StringRedisSerializer();
      RqueueRedisSerializer rqueueRedisSerializer = new RqueueRedisSerializer();
      redisTemplate.setConnectionFactory(redisConnectionFactory);
      redisTemplate.setKeySerializer(stringRedisSerializer);
      redisTemplate.setValueSerializer(rqueueRedisSerializer);
      redisTemplate.setHashKeySerializer(stringRedisSerializer);
      redisTemplate.setHashValueSerializer(rqueueRedisSerializer);
      return redisTemplate;
    }
  };

  @SuppressWarnings({"java:S1104", "java:S1444"})
  public static RedisSerializationContextProvider redisSerializationContextProvider = () -> {
    StringRedisSerializer stringRedisSerializer = new StringRedisSerializer();
    RqueueRedisSerializer rqueueRedisSerializer = new RqueueRedisSerializer();
    RedisSerializationContextBuilder<String, Object> redisSerializationContextBuilder =
        RedisSerializationContext.newSerializationContext();
    redisSerializationContextBuilder = redisSerializationContextBuilder.key(stringRedisSerializer);
    redisSerializationContextBuilder =
        redisSerializationContextBuilder.value(rqueueRedisSerializer);
    redisSerializationContextBuilder =
        redisSerializationContextBuilder.hashKey(stringRedisSerializer);
    redisSerializationContextBuilder =
        redisSerializationContextBuilder.hashValue(rqueueRedisSerializer);
    return redisSerializationContextBuilder.build();
  };

  @SuppressWarnings({"java:S1104", "java:S1444"})
  public static ReactiveRedisTemplateProvider reactiveRedisTemplateProvider =
      new ReactiveRedisTemplateProvider() {
        @Override
        public <V> ReactiveRedisTemplate<String, V> getRedisTemplate(
            ReactiveRedisConnectionFactory redisConnectionFactory) {
          return new ReactiveRedisTemplate(
              redisConnectionFactory, redisSerializationContextProvider.getSerializationContext());
        }
      };

  private RedisUtils() {}

  public static <V> RedisTemplate<String, V> getRedisTemplate(
      RedisConnectionFactory redisConnectionFactory) {
    return redisTemplateProvider.getRedisTemplate(redisConnectionFactory);
  }

  public static <V> ReactiveRedisTemplate<String, V> getReactiveRedisTemplate(
      ReactiveRedisConnectionFactory redisConnectionFactory) {
    return reactiveRedisTemplateProvider.getRedisTemplate(redisConnectionFactory);
  }

  @SuppressWarnings("unchecked")
  public static <V> List<Object> executePipeLine(
      RedisTemplate<String, V> template, RedisPipelineCallback callback) {
    return template.executePipelined((RedisCallback<Object>) connection -> {
      RedisSerializer<String> keySerializer = (RedisSerializer<String>) template.getKeySerializer();
      RedisSerializer<Object> valueSerializer =
          (RedisSerializer<Object>) template.getValueSerializer();
      callback.doInRedis(connection, keySerializer, valueSerializer);
      return null;
    });
  }

  public static void setVersion(
      RqueueRedisTemplate<Integer> rqueueRedisTemplate, String versionKey, int version) {
    rqueueRedisTemplate.set(versionKey, version);
  }

  private static int checkDbVersion(Object data) {
    if (data instanceof Integer || data instanceof Long) {
      return ((Number) data).intValue();
    } else if (data instanceof String) {
      return Integer.parseInt((String) data);
    } else if (data != null) {
      throw new IllegalStateException("Invalid db version" + data);
    }
    return -1;
  }

  public static int updateAndGetVersion(
      RqueueRedisTemplate<Integer> rqueueRedisTemplate, String versionKey, int defaultVersion) {
    Object data = rqueueRedisTemplate.get(versionKey);
    int dbVersion = checkDbVersion(data);
    if (dbVersion > 0) {
      return dbVersion;
    }
    List<Object> result = RedisUtils.executePipeLine(
        rqueueRedisTemplate.getRedisTemplate(),
        ((connection, keySerializer, valueSerializer) -> connection.eval(
            "return #redis.pcall('keys', 'rqueue-*')".getBytes(), ReturnType.INTEGER, 0)));
    Long count = (Long) result.get(0);
    if (count != null && count > 0L) {
      rqueueRedisTemplate.set(versionKey, 1);
      return 1;
    }
    rqueueRedisTemplate.set(versionKey, defaultVersion);
    return defaultVersion;
  }

  public interface RedisTemplateProvider {

    <V> RedisTemplate<String, V> getRedisTemplate(RedisConnectionFactory redisConnectionFactory);
  }

  public interface ReactiveRedisTemplateProvider {

    <V> ReactiveRedisTemplate<String, V> getRedisTemplate(
        ReactiveRedisConnectionFactory redisConnectionFactory);
  }

  public interface RedisSerializationContextProvider {

    RedisSerializationContext<String, Object> getSerializationContext();
  }

  public interface RedisPipelineCallback {

    void doInRedis(
        RedisConnection connection,
        RedisSerializer<String> keySerializer,
        RedisSerializer<Object> valueSerializer);
  }
}

1	/*
2	* Copyright (c) 2019-2026 Sonu Kumar
3	*
4	* Licensed under the Apache License, Version 2.0 (the "License");
5	* You may not use this file except in compliance with the License.
6	* You may obtain a copy of the License at
7	*
8	* https://www.apache.org/licenses/LICENSE-2.0
9	*
10	* Unless required by applicable law or agreed to in writing, software
11	* distributed under the License is distributed on an "AS IS" BASIS,
12	* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13	* See the License for the specific language governing permissions and limitations under the License.
14	*
15	*/
16
17	package com.github.sonus21.rqueue.utils;
18
19	import com.github.sonus21.rqueue.common.RqueueRedisTemplate;
20	import com.github.sonus21.rqueue.converter.RqueueRedisSerializer;
21	import java.util.List;
22	import org.springframework.data.redis.connection.ReactiveRedisConnectionFactory;
23	import org.springframework.data.redis.connection.RedisConnection;
24	import org.springframework.data.redis.connection.RedisConnectionFactory;
25	import org.springframework.data.redis.connection.ReturnType;
26	import org.springframework.data.redis.core.ReactiveRedisTemplate;
27	import org.springframework.data.redis.core.RedisCallback;
28	import org.springframework.data.redis.core.RedisTemplate;
29	import org.springframework.data.redis.serializer.RedisSerializationContext;
30	import org.springframework.data.redis.serializer.RedisSerializationContext.RedisSerializationContextBuilder;
31	import org.springframework.data.redis.serializer.RedisSerializer;
32	import org.springframework.data.redis.serializer.StringRedisSerializer;
33
34	public final class RedisUtils {
35
36	@SuppressWarnings({"java:S1104", "java:S1444"})
37	public static RedisTemplateProvider redisTemplateProvider = new RedisTemplateProvider() {	1✔
38	@Override
39	public <V> RedisTemplate<String, V> getRedisTemplate(
40	RedisConnectionFactory redisConnectionFactory) {
41	RedisTemplate<String, V> redisTemplate = new RedisTemplate<>();	1✔
42	StringRedisSerializer stringRedisSerializer = new StringRedisSerializer();	1✔
43	RqueueRedisSerializer rqueueRedisSerializer = new RqueueRedisSerializer();	1✔
44	redisTemplate.setConnectionFactory(redisConnectionFactory);	1✔
45	redisTemplate.setKeySerializer(stringRedisSerializer);	1✔
46	redisTemplate.setValueSerializer(rqueueRedisSerializer);	1✔
47	redisTemplate.setHashKeySerializer(stringRedisSerializer);	1✔
48	redisTemplate.setHashValueSerializer(rqueueRedisSerializer);	1✔
49	return redisTemplate;	1✔
50	}
51	};
52
53	@SuppressWarnings({"java:S1104", "java:S1444"})
54	public static RedisSerializationContextProvider redisSerializationContextProvider = () -> {	1✔
55	StringRedisSerializer stringRedisSerializer = new StringRedisSerializer();	1✔
56	RqueueRedisSerializer rqueueRedisSerializer = new RqueueRedisSerializer();	1✔
57	RedisSerializationContextBuilder<String, Object> redisSerializationContextBuilder =
58	RedisSerializationContext.newSerializationContext();	1✔
59	redisSerializationContextBuilder = redisSerializationContextBuilder.key(stringRedisSerializer);	1✔
60	redisSerializationContextBuilder =	1✔
61	redisSerializationContextBuilder.value(rqueueRedisSerializer);	1✔
62	redisSerializationContextBuilder =	1✔
63	redisSerializationContextBuilder.hashKey(stringRedisSerializer);	1✔
64	redisSerializationContextBuilder =	1✔
65	redisSerializationContextBuilder.hashValue(rqueueRedisSerializer);	1✔
66	return redisSerializationContextBuilder.build();	1✔
67	};
68
69	@SuppressWarnings({"java:S1104", "java:S1444"})
70	public static ReactiveRedisTemplateProvider reactiveRedisTemplateProvider =	1✔
71	new ReactiveRedisTemplateProvider() {	1✔
72	@Override
73	public <V> ReactiveRedisTemplate<String, V> getRedisTemplate(
74	ReactiveRedisConnectionFactory redisConnectionFactory) {
75	return new ReactiveRedisTemplate(	1✔
76	redisConnectionFactory, redisSerializationContextProvider.getSerializationContext());	1✔
77	}
78	};
79
80	private RedisUtils() {}
81
82	public static <V> RedisTemplate<String, V> getRedisTemplate(
83	RedisConnectionFactory redisConnectionFactory) {
84	return redisTemplateProvider.getRedisTemplate(redisConnectionFactory);	1✔
85	}
86
87	public static <V> ReactiveRedisTemplate<String, V> getReactiveRedisTemplate(
88	ReactiveRedisConnectionFactory redisConnectionFactory) {
89	return reactiveRedisTemplateProvider.getRedisTemplate(redisConnectionFactory);	1✔
90	}
91
92	@SuppressWarnings("unchecked")
93	public static <V> List<Object> executePipeLine(
94	RedisTemplate<String, V> template, RedisPipelineCallback callback) {
95	return template.executePipelined((RedisCallback<Object>) connection -> {	1✔
96	RedisSerializer<String> keySerializer = (RedisSerializer<String>) template.getKeySerializer();	1✔
97	RedisSerializer<Object> valueSerializer =	1✔
98	(RedisSerializer<Object>) template.getValueSerializer();	1✔
99	callback.doInRedis(connection, keySerializer, valueSerializer);	1✔
100	return null;	1✔
101	});
102	}
103
104	public static void setVersion(
105	RqueueRedisTemplate<Integer> rqueueRedisTemplate, String versionKey, int version) {
106	rqueueRedisTemplate.set(versionKey, version);	1✔
107	}	1✔
108
109	private static int checkDbVersion(Object data) {
110	if (data instanceof Integer \|\| data instanceof Long) {	1!
111	return ((Number) data).intValue();	1✔
112	} else if (data instanceof String) {	1!
UNCOV 113	return Integer.parseInt((String) data);	×
114	} else if (data != null) {	1!
UNCOV 115	throw new IllegalStateException("Invalid db version" + data);	×
116	}
117	return -1;	1✔
118	}
119
120	public static int updateAndGetVersion(
121	RqueueRedisTemplate<Integer> rqueueRedisTemplate, String versionKey, int defaultVersion) {
122	Object data = rqueueRedisTemplate.get(versionKey);	1✔
123	int dbVersion = checkDbVersion(data);	1✔
124	if (dbVersion > 0) {	1✔
125	return dbVersion;	1✔
126	}
127	List<Object> result = RedisUtils.executePipeLine(	1✔
128	rqueueRedisTemplate.getRedisTemplate(),	1✔
129	((connection, keySerializer, valueSerializer) -> connection.eval(	1✔
130	"return #redis.pcall('keys', 'rqueue-*')".getBytes(), ReturnType.INTEGER, 0)));	1✔
131	Long count = (Long) result.get(0);	1✔
132	if (count != null && count > 0L) {	1!
133	rqueueRedisTemplate.set(versionKey, 1);	1✔
134	return 1;	1✔
135	}
136	rqueueRedisTemplate.set(versionKey, defaultVersion);	1✔
137	return defaultVersion;	1✔
138	}
139
140	public interface RedisTemplateProvider {
141
142	<V> RedisTemplate<String, V> getRedisTemplate(RedisConnectionFactory redisConnectionFactory);
143	}
144
145	public interface ReactiveRedisTemplateProvider {
146
147	<V> ReactiveRedisTemplate<String, V> getRedisTemplate(
148	ReactiveRedisConnectionFactory redisConnectionFactory);
149	}
150
151	public interface RedisSerializationContextProvider {
152
153	RedisSerializationContext<String, Object> getSerializationContext();
154	}
155
156	public interface RedisPipelineCallback {
157
158	void doInRedis(
159	RedisConnection connection,
160	RedisSerializer<String> keySerializer,
161	RedisSerializer<Object> valueSerializer);
162	}
163	}

sonus21 / rqueue / 25600722838

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous