Skip to content

Commit c62c821

Browse files
amvanbarenamvanbaren
authored
Merge pull request #851 from amvanbaren/update-publicid-unittests
Review public id updates
2 parents 84d0140 + cadcb38 commit c62c821

File tree

4 files changed

+298
-335
lines changed

4 files changed

+298
-335
lines changed

‎server/src/main/java/org/eclipse/openvsx/adapter/PublicIds.java‎

Lines changed: 13 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,13 @@
1+
/** ******************************************************************************
2+
* Copyright (c) 2024 Precies. Software Ltd and others
3+
*
4+
* This program and the accompanying materials are made available under the
5+
* terms of the Eclipse Public License v. 2.0 which is available at
6+
* http://www.eclipse.org/legal/epl-2.0.
7+
*
8+
* SPDX-License-Identifier: EPL-2.0
9+
* ****************************************************************************** */
10+
package org.eclipse.openvsx.adapter;
11+
12+
public record PublicIds(String namespace, String extension) {
13+
}

‎server/src/main/java/org/eclipse/openvsx/adapter/VSCodeIdService.java‎

Lines changed: 12 additions & 5 deletions
Original file line numberDiff line numberDiff line change
@@ -31,6 +31,7 @@
3131
import org.springframework.web.client.RestTemplate;
3232

3333
import java.time.ZoneId;
34+
import java.util.UUID;
3435

3536
@Component
3637
public class VSCodeIdService {
@@ -66,18 +67,24 @@ public void applicationStarted(ApplicationStartedEvent event) {
6667
scheduler.scheduleRecurrently("VSCodeIdDailyUpdate", Cron.daily(3), ZoneId.of("UTC"), new HandlerJobRequest<>(VSCodeIdDailyUpdateJobRequestHandler.class));
6768
}
6869

69-
public void getUpstreamPublicIds(Extension extension) {
70-
extension.setPublicId(null);
71-
extension.getNamespace().setPublicId(null);
70+
public String getRandomPublicId() {
71+
return UUID.randomUUID().toString();
72+
}
73+
74+
public PublicIds getUpstreamPublicIds(Extension extension) {
75+
String extensionPublicId = null;
76+
String namespacePublicId = null;
7277
var upstream = getUpstreamExtension(extension);
7378
if (upstream != null) {
7479
if (upstream.extensionId != null) {
75-
extension.setPublicId(upstream.extensionId);
80+
extensionPublicId = upstream.extensionId;
7681
}
7782
if (upstream.publisher != null && upstream.publisher.publisherId != null) {
78-
extension.getNamespace().setPublicId(upstream.publisher.publisherId);
83+
namespacePublicId = upstream.publisher.publisherId;
7984
}
8085
}
86+
87+
return new PublicIds(namespacePublicId, extensionPublicId);
8188
}
8289

8390
private ExtensionQueryResult.Extension getUpstreamExtension(Extension extension) {

‎server/src/main/java/org/eclipse/openvsx/adapter/VSCodeIdUpdateService.java‎

Lines changed: 38 additions & 49 deletions
Original file line numberDiff line numberDiff line change
@@ -20,14 +20,11 @@
2020
import org.springframework.stereotype.Component;
2121

2222
import java.util.*;
23-
import java.util.concurrent.Semaphore;
24-
import java.util.concurrent.TimeUnit;
2523
import java.util.stream.Collectors;
2624

2725
@Component
2826
public class VSCodeIdUpdateService {
2927
private static final Logger LOGGER = LoggerFactory.getLogger(VSCodeIdUpdateService.class);
30-
private static final Semaphore LOCK = new Semaphore(1);
3128

3229
@Autowired
3330
RepositoryService repositories;
@@ -36,75 +33,69 @@ public class VSCodeIdUpdateService {
3633
VSCodeIdService service;
3734

3835
public void update(String namespaceName, String extensionName) throws InterruptedException {
39-
var acquired = LOCK.tryAcquire(15, TimeUnit.SECONDS);
40-
if(!acquired) {
41-
throw new RuntimeException("Failed to update public id for " + NamingUtil.toExtensionId(namespaceName, extensionName));
42-
}
4336
if(BuiltInExtensionUtil.isBuiltIn(namespaceName)) {
4437
LOGGER.debug("SKIP BUILT-IN EXTENSION {}", NamingUtil.toExtensionId(namespaceName, extensionName));
4538
return;
4639
}
4740

4841
var extension = repositories.findPublicId(namespaceName, extensionName);
4942
var extensionUpdates = new HashMap<Long, String>();
50-
updateExtensionPublicId(extension, extensionUpdates);
43+
updateExtensionPublicId(extension, extensionUpdates, false);
5144
if(!extensionUpdates.isEmpty()) {
5245
repositories.updateExtensionPublicIds(extensionUpdates);
5346
}
5447

5548
var namespaceUpdates = new HashMap<Long, String>();
56-
updateNamespacePublicId(extension, namespaceUpdates);
49+
updateNamespacePublicId(extension, namespaceUpdates, false);
5750
if(!namespaceUpdates.isEmpty()) {
5851
repositories.updateNamespacePublicIds(namespaceUpdates);
5952
}
60-
LOCK.release();
6153
}
6254

63-
private void updateExtensionPublicId(Extension extension, Map<Long, String> updates) {
55+
private void updateExtensionPublicId(Extension extension, Map<Long, String> updates, boolean mustUpdate) {
6456
LOGGER.debug("updateExtensionPublicId: {}", NamingUtil.toExtensionId(extension));
65-
service.getUpstreamPublicIds(extension);
66-
if(extension.getPublicId() == null) {
67-
var publicId = "";
57+
var oldPublicId = extension.getPublicId();
58+
var newPublicId = service.getUpstreamPublicIds(extension).extension();
59+
if(newPublicId == null || (mustUpdate && newPublicId.equals(oldPublicId))) {
6860
do {
69-
publicId = UUID.randomUUID().toString();
70-
LOGGER.debug("RANDOM EXTENSION PUBLIC ID: {}", publicId);
71-
} while(updates.containsValue(publicId) || repositories.extensionPublicIdExists(publicId));
72-
LOGGER.debug("RANDOM PUT UPDATE: {} - {}", extension.getId(), publicId);
73-
updates.put(extension.getId(), publicId);
74-
} else {
75-
LOGGER.debug("UPSTREAM PUT UPDATE: {} - {}", extension.getId(), extension.getPublicId());
76-
updates.put(extension.getId(), extension.getPublicId());
77-
var duplicatePublicId = repositories.findPublicId(extension.getPublicId());
61+
newPublicId = service.getRandomPublicId();
62+
LOGGER.debug("RANDOM EXTENSION PUBLIC ID: {}", newPublicId);
63+
} while(updates.containsValue(newPublicId) || repositories.extensionPublicIdExists(newPublicId));
64+
LOGGER.debug("RANDOM PUT UPDATE: {} - {}", extension.getId(), newPublicId);
65+
updates.put(extension.getId(), newPublicId);
66+
} else if (!newPublicId.equals(oldPublicId)) {
67+
LOGGER.debug("UPSTREAM PUT UPDATE: {} - {}", extension.getId(), newPublicId);
68+
updates.put(extension.getId(), newPublicId);
69+
var duplicatePublicId = repositories.findPublicId(newPublicId);
7870
if(duplicatePublicId != null) {
79-
updateExtensionPublicId(duplicatePublicId, updates);
71+
updateExtensionPublicId(duplicatePublicId, updates, true);
8072
}
8173
}
8274
}
8375

84-
private void updateNamespacePublicId(Extension extension, Map<Long, String> updates) {
76+
private void updateNamespacePublicId(Extension extension, Map<Long, String> updates, boolean mustUpdate) {
8577
LOGGER.debug("updateNamespacePublicId: {}", extension.getNamespace().getName());
86-
service.getUpstreamPublicIds(extension);
87-
var namespace = extension.getNamespace();
88-
if(namespace.getPublicId() == null) {
89-
var publicId = "";
78+
var oldPublicId = extension.getNamespace().getPublicId();
79+
var newPublicId = service.getUpstreamPublicIds(extension).namespace();
80+
var id = extension.getNamespace().getId();
81+
if(newPublicId == null || (mustUpdate && newPublicId.equals(oldPublicId))) {
9082
do {
91-
publicId = UUID.randomUUID().toString();
92-
LOGGER.debug("RANDOM NAMESPACE PUBLIC ID: {}", publicId);
93-
} while(updates.containsValue(publicId) || repositories.namespacePublicIdExists(publicId));
94-
LOGGER.debug("RANDOM PUT UPDATE: {} - {}", namespace.getId(), publicId);
95-
updates.put(namespace.getId(), publicId);
96-
} else {
97-
LOGGER.debug("UPSTREAM PUT UPDATE: {} - {}", namespace.getId(), namespace.getPublicId());
98-
updates.put(namespace.getId(), namespace.getPublicId());
99-
var duplicatePublicId = repositories.findNamespacePublicId(namespace.getPublicId());
83+
newPublicId = service.getRandomPublicId();
84+
LOGGER.debug("RANDOM NAMESPACE PUBLIC ID: {}", newPublicId);
85+
} while(updates.containsValue(newPublicId) || repositories.namespacePublicIdExists(newPublicId));
86+
LOGGER.debug("RANDOM PUT UPDATE: {} - {}", id, newPublicId);
87+
updates.put(id, newPublicId);
88+
} else if(!newPublicId.equals(oldPublicId)) {
89+
LOGGER.debug("UPSTREAM PUT UPDATE: {} - {}", id, newPublicId);
90+
updates.put(id, newPublicId);
91+
var duplicatePublicId = repositories.findNamespacePublicId(newPublicId);
10092
if(duplicatePublicId != null) {
101-
updateNamespacePublicId(duplicatePublicId, updates);
93+
updateNamespacePublicId(duplicatePublicId, updates, true);
10294
}
10395
}
10496
}
10597

10698
public void updateAll() throws InterruptedException {
107-
LOCK.acquire();
10899
LOGGER.debug("DAILY UPDATE ALL");
109100
var extensions = repositories.findAllPublicIds();
110101
var extensionPublicIdsMap = extensions.stream()
@@ -124,16 +115,16 @@ public void updateAll() throws InterruptedException {
124115
}
125116

126117
LOGGER.trace("GET UPSTREAM PUBLIC ID: {} | {}", extension.getId(), NamingUtil.toExtensionId(extension));
127-
service.getUpstreamPublicIds(extension);
118+
var publicIds = service.getUpstreamPublicIds(extension);
128119
if(upstreamExtensionPublicIds.get(extension.getId()) == null) {
129-
LOGGER.trace("ADD EXTENSION PUBLIC ID: {} - {}", extension.getId(), extension.getPublicId());
130-
upstreamExtensionPublicIds.put(extension.getId(), extension.getPublicId());
120+
LOGGER.trace("ADD EXTENSION PUBLIC ID: {} - {}", extension.getId(), publicIds.extension());
121+
upstreamExtensionPublicIds.put(extension.getId(), publicIds.extension());
131122
}
132123

133124
var namespace = extension.getNamespace();
134125
if(upstreamNamespacePublicIds.get(namespace.getId()) == null) {
135-
LOGGER.trace("ADD NAMESPACE PUBLIC ID: {} - {}", namespace.getId(), namespace.getPublicId());
136-
upstreamNamespacePublicIds.put(namespace.getId(), namespace.getPublicId());
126+
LOGGER.trace("ADD NAMESPACE PUBLIC ID: {} - {}", namespace.getId(), publicIds.namespace());
127+
upstreamNamespacePublicIds.put(namespace.getId(), publicIds.namespace());
137128
}
138129
}
139130

@@ -160,8 +151,6 @@ public void updateAll() throws InterruptedException {
160151

161152
repositories.updateNamespacePublicIds(changedNamespacePublicIds);
162153
}
163-
164-
LOCK.release();
165154
}
166155

167156
private Map<Long, String> getChangedPublicIds(Map<Long, String> upstreamPublicIds, Map<Long, String> currentPublicIds) {
@@ -190,15 +179,15 @@ private void updatePublicIdNulls(Map<Long, String> changedPublicIds, Set<String>
190179
return remove;
191180
});
192181

193-
// put random UUIDs where upstream public id is missing
182+
// put random public ids where upstream public id is missing
194183
for(var key : changedPublicIds.keySet()) {
195184
if(changedPublicIds.get(key) != null) {
196185
continue;
197186
}
198187

199188
String publicId = null;
200189
while(newPublicIds.contains(publicId)) {
201-
publicId = UUID.randomUUID().toString();
190+
publicId = service.getRandomPublicId();
202191
LOGGER.debug("NEW PUBLIC ID - {}: '{}'", key, publicId);
203192
}
204193

0 commit comments

Comments
 (0)