Skip to content

Commit d05fec8

Browse files
wy471xclaude
andcommitted
fix: harden upstream URL handling — transaction atomicity, host:port fallback, port validation, and defensive parse
- Listener: rethrow after LOG.error in handleUpdated/handleDeleted so @transactional rollback works instead of silently committing partial batches. - Service layer: add matchByHostAndPort fallback in deleteBySelectorIdAndUrl and changeStatusBySelectorIdAndUrl so old-format records (missing port, unbracketed IPv6) can be deleted/status-toggled via the REST path, matching the listener path. - Transfer layer: catch IllegalArgumentException in mapToCommonUpstream and mapToDiscoveryUpstreamData; log and return null instead of breaking the entire stream. Callers in UpstreamCheckService filter null. - IpUtils.parseHostPort: validate port is numeric and in range 1–65535 at the parse boundary; prevents NumberFormatException from propagating through normalizeUrl. - Tests: add 11 round-trip normalizeUrl tests (hostname, IPv4, IPv6, IPv6 zone-id, plus error paths for non-numeric and out-of-range ports). Co-Authored-By: Claude Opus 4.7 <[email protected]>
1 parent dc3cfb9 commit d05fec8

6 files changed

Lines changed: 174 additions & 31 deletions

File tree

‎shenyu-admin/src/main/java/org/apache/shenyu/admin/discovery/DiscoveryDataChangedEventSyncListener.java‎

Lines changed: 2 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -167,6 +167,7 @@ private void handleUpdated(final List<DiscoveryUpstreamData> upstreamDataList, f
167167
LOG.info("[DiscoveryDataChangedEventSyncListener] UPDATE Upstream {}, effect = {} ", discoveryUpstreamDO.getUpstreamUrl(), effect);
168168
} catch (Exception e) {
169169
LOG.error("[DiscoveryDataChangedEventSyncListener] UPDATE Upstream failed: {}", discoveryUpstreamDO.getUpstreamUrl(), e);
170+
throw e;
170171
}
171172
});
172173
}
@@ -191,6 +192,7 @@ private void handleDeleted(final List<DiscoveryUpstreamData> upstreamDataList, f
191192
LOG.info("[DiscoveryDataChangedEventSyncListener] DELETE Upstream {}, effect = {}", normalizedUrl, effect);
192193
} catch (Exception e) {
193194
LOG.error("[DiscoveryDataChangedEventSyncListener] DELETE Upstream failed: {}", up.getUrl(), e);
195+
throw e;
194196
}
195197
});
196198
}

‎shenyu-admin/src/main/java/org/apache/shenyu/admin/service/impl/DiscoveryUpstreamServiceImpl.java‎

Lines changed: 20 additions & 2 deletions
Original file line numberDiff line numberDiff line change
@@ -248,7 +248,15 @@ public List<DiscoveryUpstreamData> findBySelectorId(final String selectorId) {
248248
public void deleteBySelectorIdAndUrl(final String selectorId, final String url) {
249249
DiscoveryHandlerDO discoveryHandlerDO = discoveryHandlerMapper.selectBySelectorId(selectorId);
250250
if (Objects.nonNull(discoveryHandlerDO)) {
251-
discoveryUpstreamMapper.deleteByUrl(discoveryHandlerDO.getId(), CommonUpstreamUtils.normalizeUrl(url));
251+
String normalizedUrl = CommonUpstreamUtils.normalizeUrl(url);
252+
int effect = discoveryUpstreamMapper.deleteByUrl(discoveryHandlerDO.getId(), normalizedUrl);
253+
if (effect == 0) {
254+
DiscoveryUpstreamDO oldRecord = CommonUpstreamUtils.matchByHostAndPort(
255+
discoveryUpstreamMapper, discoveryHandlerDO.getId(), normalizedUrl);
256+
if (Objects.nonNull(oldRecord)) {
257+
discoveryUpstreamMapper.deleteByIds(Collections.singletonList(oldRecord.getId()));
258+
}
259+
}
252260
}
253261
}
254262

@@ -257,7 +265,17 @@ public void deleteBySelectorIdAndUrl(final String selectorId, final String url)
257265
public void changeStatusBySelectorIdAndUrl(final String selectorId, final String url, final Boolean enabled) {
258266
DiscoveryHandlerDO discoveryHandlerDO = discoveryHandlerMapper.selectBySelectorId(selectorId);
259267
if (Objects.nonNull(discoveryHandlerDO)) {
260-
discoveryUpstreamMapper.updateStatusByUrl(discoveryHandlerDO.getId(), CommonUpstreamUtils.normalizeUrl(url), enabled ? 0 : 1);
268+
String normalizedUrl = CommonUpstreamUtils.normalizeUrl(url);
269+
int status = enabled ? 0 : 1;
270+
int effect = discoveryUpstreamMapper.updateStatusByUrl(discoveryHandlerDO.getId(), normalizedUrl, status);
271+
if (effect == 0) {
272+
DiscoveryUpstreamDO oldRecord = CommonUpstreamUtils.matchByHostAndPort(
273+
discoveryUpstreamMapper, discoveryHandlerDO.getId(), normalizedUrl);
274+
if (Objects.nonNull(oldRecord)) {
275+
oldRecord.setUpstreamStatus(status);
276+
discoveryUpstreamMapper.updateSelective(oldRecord);
277+
}
278+
}
261279
}
262280
}
263281

‎shenyu-admin/src/main/java/org/apache/shenyu/admin/service/impl/UpstreamCheckService.java‎

Lines changed: 9 additions & 2 deletions
Original file line numberDiff line numberDiff line change
@@ -435,7 +435,10 @@ private void updateSelectorHandler(final String selectorId, final List<CommonUps
435435
List<DiscoveryUpstreamData> discoveryUpstreamDataList = discoveryUpstreamService.findBySelectorId(selectorId);
436436

437437
if (CollectionUtils.isEmpty(discoveryUpstreamDataList)) {
438-
discoveryUpstreamDataList = aliveList.stream().map(DiscoveryTransfer.INSTANCE::mapToDiscoveryUpstreamData).collect(Collectors.toList());
438+
discoveryUpstreamDataList = aliveList.stream()
439+
.map(DiscoveryTransfer.INSTANCE::mapToDiscoveryUpstreamData)
440+
.filter(Objects::nonNull)
441+
.collect(Collectors.toList());
439442
}
440443

441444
discoveryUpstreamDataList.removeIf(u -> {
@@ -481,6 +484,7 @@ public void fetchUpstreamData() {
481484
List<CommonUpstream> commonUpstreams = new LinkedList<>();
482485
discoveryUpstreamService.findBySelectorId(selectorDO.getId()).stream()
483486
.map(DiscoveryTransfer.INSTANCE::mapToCommonUpstream)
487+
.filter(Objects::nonNull)
484488
.forEach(commonUpstreams::add);
485489
String handle = selectorDO.getHandle();
486490
if (StringUtils.isNotEmpty(handle)) {
@@ -506,7 +510,10 @@ public void onDiscoveryUpstreamUpdated(final DiscoveryStreamUpdatedEvent event)
506510
LOG.info("onDiscoveryUpstreamUpdated plugin={}|list={}", discoverySyncData.getPluginName(), discoverySyncData.getUpstreamDataList());
507511
if (PluginEnum.DIVIDE.getName().equals(discoverySyncData.getPluginName())) {
508512
List<DiscoveryUpstreamData> upstreamDataList = discoverySyncData.getUpstreamDataList();
509-
List<CommonUpstream> collect = upstreamDataList.stream().map(DiscoveryTransfer.INSTANCE::mapToCommonUpstream).collect(Collectors.toList());
513+
List<CommonUpstream> collect = upstreamDataList.stream()
514+
.map(DiscoveryTransfer.INSTANCE::mapToCommonUpstream)
515+
.filter(Objects::nonNull)
516+
.collect(Collectors.toList());
510517
List<CommonUpstream> commonUpstreams = CommonUpstreamUtils.convertCommonUpstreamList(collect);
511518
LOG.info("UpstreamCacheManager replace selectorId={}|json={}", discoverySyncData.getSelectorId(), GsonUtils.getGson().toJson(commonUpstreams));
512519
replace(discoverySyncData.getSelectorId(), commonUpstreams);

‎shenyu-admin/src/main/java/org/apache/shenyu/admin/transfer/DiscoveryTransfer.java‎

Lines changed: 35 additions & 26 deletions
Original file line numberDiff line numberDiff line change
@@ -36,6 +36,8 @@
3636
import org.apache.shenyu.common.dto.ProxySelectorData;
3737
import org.apache.shenyu.common.dto.convert.selector.CommonUpstream;
3838
import org.apache.shenyu.common.utils.GsonUtils;
39+
import org.slf4j.Logger;
40+
import org.slf4j.LoggerFactory;
3941

4042
import java.util.Optional;
4143
import java.util.Properties;
@@ -49,6 +51,8 @@ public enum DiscoveryTransfer {
4951
*/
5052
INSTANCE;
5153

54+
private static final Logger LOG = LoggerFactory.getLogger(DiscoveryTransfer.class);
55+
5256
/**
5357
* mapToDo.
5458
*
@@ -78,14 +82,19 @@ public DiscoveryUpstreamDO mapToDo(DiscoveryUpstreamData discoveryUpstreamData)
7882
public CommonUpstream mapToCommonUpstream(DiscoveryUpstreamData discoveryUpstreamData) {
7983
return Optional.ofNullable(discoveryUpstreamData).map(data -> {
8084
String url = data.getUrl();
81-
CommonUpstream commonUpstream = new CommonUpstream(data.getProtocol(),
82-
CommonUpstreamUtils.parseHostPort(url)[0], url, false, data.getDateCreated().getTime());
83-
Properties properties = Optional.ofNullable(data.getProps())
84-
.map(props -> GsonUtils.getInstance().fromJson(props, Properties.class))
85-
.orElse(new Properties());
86-
commonUpstream
87-
.setHealthCheckEnabled(Boolean.parseBoolean(properties.getProperty("healthCheckEnabled", "true")));
88-
return commonUpstream;
85+
try {
86+
CommonUpstream commonUpstream = new CommonUpstream(data.getProtocol(),
87+
CommonUpstreamUtils.parseHostPort(url)[0], url, false, data.getDateCreated().getTime());
88+
Properties properties = Optional.ofNullable(data.getProps())
89+
.map(props -> GsonUtils.getInstance().fromJson(props, Properties.class))
90+
.orElse(new Properties());
91+
commonUpstream
92+
.setHealthCheckEnabled(Boolean.parseBoolean(properties.getProperty("healthCheckEnabled", "true")));
93+
return commonUpstream;
94+
} catch (IllegalArgumentException e) {
95+
LOG.warn("Skip malformed upstream URL: {}", url, e);
96+
return null;
97+
}
8998
}).orElse(null);
9099
}
91100

@@ -350,26 +359,26 @@ public DiscoveryUpstreamDTO mapToDTO(DiscoveryUpstreamDO discoveryUpstreamDO) {
350359
public DiscoveryUpstreamData mapToDiscoveryUpstreamData(CommonUpstream commonUpstream) {
351360
String upstreamUrl = commonUpstream.getUpstreamUrl();
352361
if (upstreamUrl == null) {
353-
throw new IllegalArgumentException("Upstream URL must not be null");
362+
return null;
354363
}
355-
String[] parts = CommonUpstreamUtils.parseHostPort(upstreamUrl);
356-
String host = parts[0];
357-
int port;
358364
try {
359-
port = Integer.parseInt(parts[1]);
360-
} catch (NumberFormatException e) {
361-
throw new IllegalArgumentException("Invalid port in upstream URL: " + upstreamUrl, e);
365+
String[] parts = CommonUpstreamUtils.parseHostPort(upstreamUrl);
366+
String host = parts[0];
367+
int port = Integer.parseInt(parts[1]);
368+
DiscoveryUpstreamDTO discoveryUpstreamDTO = CommonUpstreamUtils.buildDefaultDiscoveryUpstreamDTO(
369+
host,
370+
port,
371+
commonUpstream.getProtocol(),
372+
commonUpstream.getNamespaceId());
373+
Properties properties = Optional.ofNullable(discoveryUpstreamDTO.getProps())
374+
.map(props -> GsonUtils.getInstance().fromJson(props, Properties.class))
375+
.orElse(new Properties());
376+
properties.setProperty("healthCheckEnabled", String.valueOf(commonUpstream.isHealthCheckEnabled()));
377+
discoveryUpstreamDTO.setProps(GsonUtils.getInstance().toJson(properties));
378+
return mapToData(discoveryUpstreamDTO);
379+
} catch (IllegalArgumentException e) {
380+
LOG.warn("Skip malformed upstream URL in mapToDiscoveryUpstreamData: {}", upstreamUrl, e);
381+
return null;
362382
}
363-
DiscoveryUpstreamDTO discoveryUpstreamDTO = CommonUpstreamUtils.buildDefaultDiscoveryUpstreamDTO(
364-
host,
365-
port,
366-
commonUpstream.getProtocol(),
367-
commonUpstream.getNamespaceId());
368-
Properties properties = Optional.ofNullable(discoveryUpstreamDTO.getProps())
369-
.map(props -> GsonUtils.getInstance().fromJson(props, Properties.class))
370-
.orElse(new Properties());
371-
properties.setProperty("healthCheckEnabled", String.valueOf(commonUpstream.isHealthCheckEnabled()));
372-
discoveryUpstreamDTO.setProps(GsonUtils.getInstance().toJson(properties));
373-
return mapToData(discoveryUpstreamDTO);
374383
}
375384
}

‎shenyu-admin/src/test/java/org/apache/shenyu/admin/utils/CommonUpstreamUtilsTest.java‎

Lines changed: 93 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -435,4 +435,97 @@ public void testBuildUrlIpv4() {
435435
String url = CommonUpstreamUtils.buildUrl("192.168.1.1", 8080);
436436
Assert.assertEquals("192.168.1.1:8080", url);
437437
}
438+
439+
// ---------- normalizeUrl round-trip tests ----------
440+
441+
@Test
442+
public void testNormalizeUrlHostnameWithoutPortRoundTrip() {
443+
String normalized = CommonUpstreamUtils.normalizeUrl("example.com");
444+
Assert.assertEquals("example.com:80", normalized);
445+
String[] parts = CommonUpstreamUtils.parseHostPort(normalized);
446+
Assert.assertEquals("example.com", parts[0]);
447+
Assert.assertEquals("80", parts[1]);
448+
}
449+
450+
@Test
451+
public void testNormalizeUrlHostnameWithPortRoundTrip() {
452+
String normalized = CommonUpstreamUtils.normalizeUrl("example.com:8080");
453+
Assert.assertEquals("example.com:8080", normalized);
454+
String[] parts = CommonUpstreamUtils.parseHostPort(normalized);
455+
Assert.assertEquals("example.com", parts[0]);
456+
Assert.assertEquals("8080", parts[1]);
457+
}
458+
459+
@Test
460+
public void testNormalizeUrlIpv4WithoutPortRoundTrip() {
461+
String normalized = CommonUpstreamUtils.normalizeUrl("192.168.1.1");
462+
Assert.assertEquals("192.168.1.1:80", normalized);
463+
String[] parts = CommonUpstreamUtils.parseHostPort(normalized);
464+
Assert.assertEquals("192.168.1.1", parts[0]);
465+
Assert.assertEquals("80", parts[1]);
466+
}
467+
468+
@Test
469+
public void testNormalizeUrlIpv4WithPortRoundTrip() {
470+
String normalized = CommonUpstreamUtils.normalizeUrl("192.168.1.1:8080");
471+
Assert.assertEquals("192.168.1.1:8080", normalized);
472+
String[] parts = CommonUpstreamUtils.parseHostPort(normalized);
473+
Assert.assertEquals("192.168.1.1", parts[0]);
474+
Assert.assertEquals("8080", parts[1]);
475+
}
476+
477+
@Test
478+
public void testNormalizeUrlIpv6WithoutPortRoundTrip() {
479+
String normalized = CommonUpstreamUtils.normalizeUrl("[2001:db8::1]");
480+
Assert.assertEquals("[2001:db8::1]:80", normalized);
481+
String[] parts = CommonUpstreamUtils.parseHostPort(normalized);
482+
Assert.assertEquals("2001:db8::1", parts[0]);
483+
Assert.assertEquals("80", parts[1]);
484+
}
485+
486+
@Test
487+
public void testNormalizeUrlIpv6WithPortRoundTrip() {
488+
String normalized = CommonUpstreamUtils.normalizeUrl("[2001:db8::1]:8080");
489+
Assert.assertEquals("[2001:db8::1]:8080", normalized);
490+
String[] parts = CommonUpstreamUtils.parseHostPort(normalized);
491+
Assert.assertEquals("2001:db8::1", parts[0]);
492+
Assert.assertEquals("8080", parts[1]);
493+
}
494+
495+
@Test
496+
public void testNormalizeUrlIpv6LoopbackRoundTrip() {
497+
String normalized = CommonUpstreamUtils.normalizeUrl("[::1]");
498+
Assert.assertEquals("[::1]:80", normalized);
499+
String[] parts = CommonUpstreamUtils.parseHostPort(normalized);
500+
Assert.assertEquals("::1", parts[0]);
501+
Assert.assertEquals("80", parts[1]);
502+
}
503+
504+
@Test
505+
public void testNormalizeUrlIpv6WithZoneIdAndPortRoundTrip() {
506+
String normalized = CommonUpstreamUtils.normalizeUrl("[fe80::1%lo0]:8080");
507+
Assert.assertEquals("[fe80::1%lo0]:8080", normalized);
508+
String[] parts = CommonUpstreamUtils.parseHostPort(normalized);
509+
Assert.assertEquals("fe80::1%lo0", parts[0]);
510+
Assert.assertEquals("8080", parts[1]);
511+
}
512+
513+
@Test
514+
public void testNormalizeUrlIpv6WithZoneIdWithoutPortRoundTrip() {
515+
String normalized = CommonUpstreamUtils.normalizeUrl("[fe80::1%lo0]");
516+
Assert.assertEquals("[fe80::1%lo0]:80", normalized);
517+
String[] parts = CommonUpstreamUtils.parseHostPort(normalized);
518+
Assert.assertEquals("fe80::1%lo0", parts[0]);
519+
Assert.assertEquals("80", parts[1]);
520+
}
521+
522+
@Test(expected = IllegalArgumentException.class)
523+
public void testNormalizeUrlWithNonNumericPortThrows() {
524+
CommonUpstreamUtils.normalizeUrl("example.com:abc");
525+
}
526+
527+
@Test(expected = IllegalArgumentException.class)
528+
public void testNormalizeUrlWithPortOutOfRangeThrows() {
529+
CommonUpstreamUtils.normalizeUrl("example.com:99999");
530+
}
438531
}

‎shenyu-common/src/main/java/org/apache/shenyu/common/utils/IpUtils.java‎

Lines changed: 15 additions & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -441,6 +441,7 @@ public static String[] parseHostPort(final String upstreamUrl) {
441441
String portPart = upstreamUrl.substring(closingBracket + 2);
442442
port = portPart.isEmpty() ? "80" : portPart;
443443
}
444+
validateNumericPort(port, upstreamUrl);
444445
return new String[]{host, port};
445446
}
446447
int lastColon = upstreamUrl.lastIndexOf(':');
@@ -450,8 +451,10 @@ public static String[] parseHostPort(final String upstreamUrl) {
450451
}
451452
String host = upstreamUrl.substring(0, lastColon);
452453
String port = upstreamUrl.substring(lastColon + 1);
454+
port = port.isEmpty() ? "80" : port;
453455
validateHostIfLooksLikeIP(host);
454-
return new String[]{host, port.isEmpty() ? "80" : port};
456+
validateNumericPort(port, upstreamUrl);
457+
return new String[]{host, port};
455458
}
456459

457460
private static void validateIPv6Address(final String host) {
@@ -469,6 +472,17 @@ private static void validateIPv6Address(final String host) {
469472
}
470473
}
471474

475+
private static void validateNumericPort(final String port, final String upstreamUrl) {
476+
try {
477+
int portNum = Integer.parseInt(port);
478+
if (portNum < 1 || portNum > 65535) {
479+
throw new IllegalArgumentException("Invalid upstream URL, port out of range (1-65535): " + upstreamUrl);
480+
}
481+
} catch (NumberFormatException e) {
482+
throw new IllegalArgumentException("Invalid upstream URL, non-numeric port: " + upstreamUrl, e);
483+
}
484+
}
485+
472486
private static void validateHostIfLooksLikeIP(final String host) {
473487
if (Objects.nonNull(host) && host.indexOf('.') >= 0 && DIGITS_AND_DOTS.matcher(host).matches()) {
474488
if (!isCompleteHost(host)) {

0 commit comments

Comments
 (0)