17915104384

Committed 22 Sep 2025 12:21PM UTC coverage: 13.525% (-0.2%) from 13.712%

Build # 17915104384

Build Type

push

github

Committed by

tkuhn

Commit Message

fix: Handling of failing queries

Run Details

435 of 4046 branches covered (10.75%)

Branch coverage included in aggregate %.

1112 of 7392 relevant lines covered (15.04%)

0.67 hits per line

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

0.0

src/main/java/com/knowledgepixels/nanodash/ApiCache.java

package com.knowledgepixels.nanodash;

import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.Random;
import java.util.concurrent.ConcurrentHashMap;
import java.util.concurrent.ConcurrentMap;

import org.nanopub.extra.services.APINotReachableException;
import org.nanopub.extra.services.ApiResponse;
import org.nanopub.extra.services.ApiResponseEntry;
import org.nanopub.extra.services.FailedApiCallException;
import org.nanopub.extra.services.NotEnoughAPIInstancesException;
import org.nanopub.extra.services.QueryRef;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

/**
 * A utility class for caching API responses and maps to reduce redundant API calls.
 * This class is thread-safe and ensures that cached data is refreshed periodically.
 */
public class ApiCache {

    private ApiCache() {
    } // no instances allowed

    private transient static ConcurrentMap<String, ApiResponse> cachedResponses = new ConcurrentHashMap<>();
    private transient static ConcurrentMap<String, Boolean> failed = new ConcurrentHashMap<>();
    private transient static ConcurrentMap<String, Map<String, String>> cachedMaps = new ConcurrentHashMap<>();
    private transient static ConcurrentMap<String, Long> lastRefresh = new ConcurrentHashMap<>();
    private transient static ConcurrentMap<String, Long> refreshStart = new ConcurrentHashMap<>();
    private static final Logger logger = LoggerFactory.getLogger(ApiCache.class);

    /**
     * Checks if a cache refresh is currently running for the given cache ID.
     *
     * @param cacheId The unique identifier for the cache.
     * @return True if a refresh is running, false otherwise.
     */
    private static boolean isRunning(String cacheId) {
        if (!refreshStart.containsKey(cacheId)) return false;
        return System.currentTimeMillis() - refreshStart.get(cacheId) < 60 * 1000;
    }

    public static boolean isRunning(QueryRef queryRef) {
        return isRunning(queryRef.getAsUrlString());
    }
    /**
     * Updates the cached API response for a specific query reference.
     *
     * @param queryRef The query reference
     * @throws FailedApiCallException If the API call fails.
     */
    private static void updateResponse(QueryRef queryRef) throws FailedApiCallException, APINotReachableException, NotEnoughAPIInstancesException {
        ApiResponse response = QueryApiAccess.get(queryRef);
        String cacheId = queryRef.getAsUrlString();
        cachedResponses.put(cacheId, response);
        lastRefresh.put(cacheId, System.currentTimeMillis());
    }

    /**
     * Retrieves a cached API response for a specific QueryRef.
     *
     * @param queryRef The QueryRef object containing the query name and parameters.
     * @return The cached API response, or null if not cached.
     */
    public static ApiResponse retrieveResponse(QueryRef queryRef) {
        long timeNow = System.currentTimeMillis();
        String cacheId = queryRef.getAsUrlString();
        boolean isCached = false;
        boolean needsRefresh = true;
        if (cachedResponses.containsKey(cacheId) && cachedResponses.get(cacheId) != null) {
            long cacheAge = timeNow - lastRefresh.get(cacheId);
            isCached = cacheAge < 24 * 60 * 60 * 1000;
            needsRefresh = cacheAge > 60 * 1000;
        }
        if (failed.get(cacheId) != null) {
            cachedResponses.remove(cacheId);
            failed.remove(cacheId);
            throw new RuntimeException("Query failed: " + cacheId);
        }
        if (needsRefresh && !isRunning(cacheId)) {
            refreshStart.put(cacheId, timeNow);
            new Thread(() -> {
                try {
                    Thread.sleep(100 + new Random().nextLong(400));
                } catch (InterruptedException ex) {
                    logger.error("Interrupted while waiting to refresh cache: {}", ex.getMessage());
                }
                try {
                    ApiCache.updateResponse(queryRef);
                } catch (Exception ex) {
                    logger.error("Failed to update cache for {}: {}", cacheId, ex.getMessage());
                    cachedResponses.remove(cacheId);
                    failed.put(cacheId, true);
                    lastRefresh.put(cacheId, System.currentTimeMillis());
                } finally {
                    refreshStart.remove(cacheId);
                }
            }).start();
        }
        if (isCached) {
            return cachedResponses.get(cacheId);
        } else {
            return null;
        }
    }

    /**
     * Updates the cached map for a specific query reference.
     *
     * @param queryRef The query reference
     * @throws FailedApiCallException If the API call fails.
     */
    private static void updateMap(QueryRef queryRef) throws FailedApiCallException, APINotReachableException, NotEnoughAPIInstancesException {
        Map<String, String> map = new HashMap<>();
        List<ApiResponseEntry> respList = QueryApiAccess.get(queryRef).getData();
        while (respList != null && !respList.isEmpty()) {
            ApiResponseEntry resultEntry = respList.remove(0);
            map.put(resultEntry.get("key"), resultEntry.get("value"));
        }
        String cacheId = queryRef.getAsUrlString();
        cachedMaps.put(cacheId, map);
        lastRefresh.put(cacheId, System.currentTimeMillis());
    }

    /**
     * Retrieves a cached map for a specific query reference.
     * If the cache is stale, it triggers a background refresh.
     *
     * @param queryRef The query reference
     * @return The cached map, or null if not cached.
     */
    public static synchronized Map<String, String> retrieveMap(QueryRef queryRef) {
        long timeNow = System.currentTimeMillis();
        String cacheId = queryRef.getAsUrlString();
        boolean isCached = false;
        boolean needsRefresh = true;
        if (cachedMaps.containsKey(cacheId)) {
            long cacheAge = timeNow - lastRefresh.get(cacheId);
            isCached = cacheAge < 24 * 60 * 60 * 1000;
            needsRefresh = cacheAge > 60 * 1000;
        }
        if (needsRefresh && !isRunning(cacheId)) {
            refreshStart.put(cacheId, timeNow);
            new Thread(() -> {
                try {
                    Thread.sleep(100 + new Random().nextLong(400));
                } catch (InterruptedException ex) {
                    logger.error("Interrupted while waiting to refresh cache: {}", ex.getMessage());
                }
                try {
                    ApiCache.updateMap(queryRef);
                } catch (Exception ex) {
                    logger.error("Failed to update cache for {}: {}", cacheId, ex.getMessage());
                    cachedResponses.put(cacheId, null);
                    lastRefresh.put(cacheId, System.currentTimeMillis());
                } finally {
                    refreshStart.remove(cacheId);
                }
            }).start();
        }
        if (isCached) {
            if (cachedResponses.get(cacheId) == null) {
                cachedResponses.remove(cacheId);
                throw new RuntimeException("Query failed: " + cacheId);
            }
            return cachedMaps.get(cacheId);
        } else {
            return null;
        }
    }

}

1	package com.knowledgepixels.nanodash;
2
3	import java.util.HashMap;
4	import java.util.List;
5	import java.util.Map;
6	import java.util.Random;
7	import java.util.concurrent.ConcurrentHashMap;
8	import java.util.concurrent.ConcurrentMap;
9
10	import org.nanopub.extra.services.APINotReachableException;
11	import org.nanopub.extra.services.ApiResponse;
12	import org.nanopub.extra.services.ApiResponseEntry;
13	import org.nanopub.extra.services.FailedApiCallException;
14	import org.nanopub.extra.services.NotEnoughAPIInstancesException;
15	import org.nanopub.extra.services.QueryRef;
16	import org.slf4j.Logger;
17	import org.slf4j.LoggerFactory;
18
19	/**
20	* A utility class for caching API responses and maps to reduce redundant API calls.
21	* This class is thread-safe and ensures that cached data is refreshed periodically.
22	*/
23	public class ApiCache {
24
25	private ApiCache() {
26	} // no instances allowed
27
28	private transient static ConcurrentMap<String, ApiResponse> cachedResponses = new ConcurrentHashMap<>();	×
29	private transient static ConcurrentMap<String, Boolean> failed = new ConcurrentHashMap<>();	×
30	private transient static ConcurrentMap<String, Map<String, String>> cachedMaps = new ConcurrentHashMap<>();	×
31	private transient static ConcurrentMap<String, Long> lastRefresh = new ConcurrentHashMap<>();	×
32	private transient static ConcurrentMap<String, Long> refreshStart = new ConcurrentHashMap<>();	×
33	private static final Logger logger = LoggerFactory.getLogger(ApiCache.class);	×
34
35	/**
36	* Checks if a cache refresh is currently running for the given cache ID.
37	*
38	* @param cacheId The unique identifier for the cache.
39	* @return True if a refresh is running, false otherwise.
40	*/
41	private static boolean isRunning(String cacheId) {
42	if (!refreshStart.containsKey(cacheId)) return false;	×
43	return System.currentTimeMillis() - refreshStart.get(cacheId) < 60 * 1000;	×
44	}
45
46	public static boolean isRunning(QueryRef queryRef) {
47	return isRunning(queryRef.getAsUrlString());	×
48	}
49	/**
50	* Updates the cached API response for a specific query reference.
51	*
52	* @param queryRef The query reference
53	* @throws FailedApiCallException If the API call fails.
54	*/
55	private static void updateResponse(QueryRef queryRef) throws FailedApiCallException, APINotReachableException, NotEnoughAPIInstancesException {
56	ApiResponse response = QueryApiAccess.get(queryRef);	×
57	String cacheId = queryRef.getAsUrlString();	×
58	cachedResponses.put(cacheId, response);	×
59	lastRefresh.put(cacheId, System.currentTimeMillis());	×
60	}	×
61
62	/**
63	* Retrieves a cached API response for a specific QueryRef.
64	*
65	* @param queryRef The QueryRef object containing the query name and parameters.
66	* @return The cached API response, or null if not cached.
67	*/
68	public static ApiResponse retrieveResponse(QueryRef queryRef) {
69	long timeNow = System.currentTimeMillis();	×
70	String cacheId = queryRef.getAsUrlString();	×
71	boolean isCached = false;	×
72	boolean needsRefresh = true;	×
73	if (cachedResponses.containsKey(cacheId) && cachedResponses.get(cacheId) != null) {	×
74	long cacheAge = timeNow - lastRefresh.get(cacheId);	×
75	isCached = cacheAge < 24 * 60 * 60 * 1000;	×
76	needsRefresh = cacheAge > 60 * 1000;	×
77	}
78	if (failed.get(cacheId) != null) {	×
79	cachedResponses.remove(cacheId);	×
80	failed.remove(cacheId);	×
81	throw new RuntimeException("Query failed: " + cacheId);	×
82	}
83	if (needsRefresh && !isRunning(cacheId)) {	×
84	refreshStart.put(cacheId, timeNow);	×
85	new Thread(() -> {	×
86	try {
87	Thread.sleep(100 + new Random().nextLong(400));	×
88	} catch (InterruptedException ex) {	×
89	logger.error("Interrupted while waiting to refresh cache: {}", ex.getMessage());	×
90	}	×
91	try {
92	ApiCache.updateResponse(queryRef);	×
93	} catch (Exception ex) {	×
94	logger.error("Failed to update cache for {}: {}", cacheId, ex.getMessage());	×
95	cachedResponses.remove(cacheId);	×
96	failed.put(cacheId, true);	×
97	lastRefresh.put(cacheId, System.currentTimeMillis());	×
98	} finally {
99	refreshStart.remove(cacheId);	×
100	}
101	}).start();	×
102	}
103	if (isCached) {	×
104	return cachedResponses.get(cacheId);	×
105	} else {
106	return null;	×
107	}
108	}
109
110	/**
111	* Updates the cached map for a specific query reference.
112	*
113	* @param queryRef The query reference
114	* @throws FailedApiCallException If the API call fails.
115	*/
116	private static void updateMap(QueryRef queryRef) throws FailedApiCallException, APINotReachableException, NotEnoughAPIInstancesException {
117	Map<String, String> map = new HashMap<>();	×
118	List<ApiResponseEntry> respList = QueryApiAccess.get(queryRef).getData();	×
119	while (respList != null && !respList.isEmpty()) {	×
120	ApiResponseEntry resultEntry = respList.remove(0);	×
121	map.put(resultEntry.get("key"), resultEntry.get("value"));	×
122	}	×
123	String cacheId = queryRef.getAsUrlString();	×
124	cachedMaps.put(cacheId, map);	×
125	lastRefresh.put(cacheId, System.currentTimeMillis());	×
126	}	×
127
128	/**
129	* Retrieves a cached map for a specific query reference.
130	* If the cache is stale, it triggers a background refresh.
131	*
132	* @param queryRef The query reference
133	* @return The cached map, or null if not cached.
134	*/
135	public static synchronized Map<String, String> retrieveMap(QueryRef queryRef) {
136	long timeNow = System.currentTimeMillis();	×
137	String cacheId = queryRef.getAsUrlString();	×
138	boolean isCached = false;	×
139	boolean needsRefresh = true;	×
140	if (cachedMaps.containsKey(cacheId)) {	×
141	long cacheAge = timeNow - lastRefresh.get(cacheId);	×
142	isCached = cacheAge < 24 * 60 * 60 * 1000;	×
143	needsRefresh = cacheAge > 60 * 1000;	×
144	}
145	if (needsRefresh && !isRunning(cacheId)) {	×
146	refreshStart.put(cacheId, timeNow);	×
147	new Thread(() -> {	×
148	try {
149	Thread.sleep(100 + new Random().nextLong(400));	×
150	} catch (InterruptedException ex) {	×
151	logger.error("Interrupted while waiting to refresh cache: {}", ex.getMessage());	×
152	}	×
153	try {
154	ApiCache.updateMap(queryRef);	×
155	} catch (Exception ex) {	×
156	logger.error("Failed to update cache for {}: {}", cacheId, ex.getMessage());	×
157	cachedResponses.put(cacheId, null);	×
158	lastRefresh.put(cacheId, System.currentTimeMillis());	×
159	} finally {
160	refreshStart.remove(cacheId);	×
161	}
162	}).start();	×
163	}
164	if (isCached) {	×
165	if (cachedResponses.get(cacheId) == null) {	×
166	cachedResponses.remove(cacheId);	×
167	throw new RuntimeException("Query failed: " + cacheId);	×
168	}
169	return cachedMaps.get(cacheId);	×
170	} else {
171	return null;	×
172	}
173	}
174
175	}

knowledgepixels / nanodash / 17915104384

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