20413250445

Committed 21 Dec 2025 05:19PM UTC coverage: 0.924% (-0.03%) from 0.954%

Build # 20413250445

Build Type

push

github

Committed by

ashleycaselli

Commit Message

chore: minor code cleanup

Run Details

6 of 592 branches covered (1.01%)

Branch coverage included in aggregate %.

16 of 1789 relevant lines covered (0.89%)

0.11 hits per line

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

0.0

src/main/java/com/knowledgepixels/registry/NanopubLoader.java

package com.knowledgepixels.registry;

import com.mongodb.client.ClientSession;
import com.mongodb.client.MongoCursor;
import net.trustyuri.TrustyUriUtils;
import net.trustyuri.rdf.RdfModule;
import org.apache.http.Header;
import org.apache.http.HttpResponse;
import org.apache.http.client.HttpClient;
import org.apache.http.client.methods.CloseableHttpResponse;
import org.apache.http.client.methods.HttpGet;
import org.apache.http.util.EntityUtils;
import org.bson.Document;
import org.bson.types.Binary;
import org.eclipse.rdf4j.common.exception.RDF4JException;
import org.eclipse.rdf4j.rio.RDFFormat;
import org.nanopub.MalformedNanopubException;
import org.nanopub.Nanopub;
import org.nanopub.NanopubImpl;
import org.nanopub.NanopubUtils;
import org.nanopub.extra.server.GetNanopub;
import org.nanopub.jelly.JellyUtils;
import org.nanopub.jelly.MaybeNanopub;
import org.nanopub.jelly.NanopubStream;
import org.nanopub.trusty.TrustyNanopubUtils;
import org.nanopub.vocabulary.NPX;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

import java.io.IOException;
import java.io.InputStream;
import java.util.ArrayList;
import java.util.Collections;
import java.util.List;
import java.util.stream.Stream;

import static com.knowledgepixels.registry.RegistryDB.has;

public class NanopubLoader {

    private NanopubLoader() {
    }

    public final static String INTRO_TYPE = NPX.DECLARED_BY.stringValue();
    public final static String INTRO_TYPE_HASH = Utils.getHash(INTRO_TYPE);
    public final static String ENDORSE_TYPE = Utils.APPROVES_OF.stringValue();
    public final static String ENDORSE_TYPE_HASH = Utils.getHash(ENDORSE_TYPE);
    private static final Logger log = LoggerFactory.getLogger(NanopubLoader.class);

    // TODO Distinguish and support these cases:
    //      1. Simple load: load to all core lists if pubkey is "core-loaded", or load to all lists if pubkey is "full-loaded"
    //      2. Core load: load to all core lists (initialize if needed), or load to all lists if pubkey is "full-loaded"
    //      3. Full load: load to all lists (initialize if needed)

    public static void simpleLoad(ClientSession mongoSession, String nanopubId) {
        simpleLoad(mongoSession, retrieveNanopub(mongoSession, nanopubId));
    }

    public static void simpleLoad(ClientSession mongoSession, Nanopub np) {
        String pubkey = RegistryDB.getPubkey(np);
        if (pubkey == null) {
            log.info("Ignore (not signed): {}", np.getUri());
            return;
        }
        String pubkeyHash = Utils.getHash(pubkey);
        // TODO Do we need to load anything else here, into the other DB collections?
        if (has(mongoSession, "lists", new Document("pubkey", pubkeyHash).append("type", "$").append("status", "loaded"))) {
            RegistryDB.loadNanopub(mongoSession, np, pubkeyHash, "$");
        } else if (has(mongoSession, "lists", new Document("pubkey", pubkeyHash).append("type", INTRO_TYPE_HASH).append("status", "loaded"))) {
            RegistryDB.loadNanopub(mongoSession, np, pubkeyHash, INTRO_TYPE, ENDORSE_TYPE);
        }
    }

    /**
     * Retrieve Nanopubs from the peers of this Nanopub Registry.
     *
     * @param typeHash   The hash of the type of the Nanopub to retrieve.
     * @param pubkeyHash The hash of the pubkey of the Nanopub to retrieve.
     * @return A stream of MaybeNanopub objects, or an empty stream if no peer is available.
     */
    public static Stream<MaybeNanopub> retrieveNanopubsFromPeers(String typeHash, String pubkeyHash) {
        // TODO Move the code of this method to nanopub-java library.

        List<String> peerUrlsToTry = new ArrayList<>(Utils.getPeerUrls());
        Collections.shuffle(peerUrlsToTry);
        while (!peerUrlsToTry.isEmpty()) {
            String peerUrl = peerUrlsToTry.removeFirst();

            String requestUrl = peerUrl + "list/" + pubkeyHash + "/" + typeHash + ".jelly";
            log.info("Request: {}", requestUrl);
            try {
                CloseableHttpResponse resp = NanopubUtils.getHttpClient().execute(new HttpGet(requestUrl));
                int httpStatus = resp.getStatusLine().getStatusCode();
                if (httpStatus < 200 || httpStatus >= 300) {
                    log.info("Request failed: {} {}", peerUrl, httpStatus);
                    EntityUtils.consumeQuietly(resp.getEntity());
                    continue;
                }
                Header nrStatus = resp.getFirstHeader("Nanopub-Registry-Status");
                if (nrStatus == null) {
                    log.info("Nanopub-Registry-Status header not found at: {}", peerUrl);
                    EntityUtils.consumeQuietly(resp.getEntity());
                    continue;
                } else if (!nrStatus.getValue().equals("ready") && !nrStatus.getValue().equals("updating")) {
                    log.info("Peer in non-ready state: {} {}", peerUrl, nrStatus.getValue());
                    EntityUtils.consumeQuietly(resp.getEntity());
                    continue;
                }
                InputStream is = resp.getEntity().getContent();
                return NanopubStream.fromByteStream(is).getAsNanopubs();
            } catch (UnsupportedOperationException | IOException ex) {
                log.info("Request failed: ", ex);
            }
        }
        return Stream.empty();
    }

    public static Nanopub retrieveNanopub(ClientSession mongoSession, String nanopubId) {
        Nanopub np = retrieveLocalNanopub(mongoSession, nanopubId);
        int tryCount = 0;
        while (np == null) {
            if (tryCount > 10) {
                throw new RuntimeException("Could not load nanopub: " + nanopubId);
            } else if (tryCount > 0) {
                try {
                    Thread.sleep(100);
                } catch (InterruptedException ex) {
                    log.info("Thread was interrupted", ex);
                }
            }
            log.info("Loading {}", nanopubId);

            // TODO Reach out to other Nanopub Registries here:
            np = getNanopub(nanopubId);
            if (np != null) {
                RegistryDB.loadNanopub(mongoSession, np);
            } else {
                tryCount = tryCount + 1;
            }
        }
        return np;
    }

    public static Nanopub retrieveLocalNanopub(ClientSession mongoSession, String nanopubId) {
        String ac = TrustyUriUtils.getArtifactCode(nanopubId);
        MongoCursor<Document> cursor = RegistryDB.get(mongoSession, "nanopubs", new Document("_id", ac));
        if (!cursor.hasNext()) return null;
        try {
            // Parse from Jelly, not TriG (it's faster)
            return JellyUtils.readFromDB(((Binary) cursor.next().get("jelly")).getData());
        } catch (RDF4JException | MalformedNanopubException ex) {
            log.info("Exception reading Jelly", ex);
            return null;
        }
    }

    // TODO Provide this method in nanopub-java (GetNanopub)
    private static Nanopub getNanopub(String uriOrArtifactCode) {
        List<String> peerUrls = new ArrayList<>(Utils.getPeerUrls());
        Collections.shuffle(peerUrls);
        String ac = GetNanopub.getArtifactCode(uriOrArtifactCode);
        if (!ac.startsWith(RdfModule.MODULE_ID)) {
            throw new IllegalArgumentException("Not a trusty URI of type RA");
        }
        while (!peerUrls.isEmpty()) {
            String peerUrl = peerUrls.removeFirst();
            try {
                Nanopub np = get(ac, peerUrl, NanopubUtils.getHttpClient());
                if (np != null) {
                    return np;
                }
            } catch (IOException | RDF4JException | MalformedNanopubException ex) {
                // ignore
            }
        }
        return null;
    }

    // TODO Provide this method in nanopub-java (GetNanopub)
    private static Nanopub get(String artifactCode, String registryUrl, HttpClient httpClient)
            throws IOException, RDF4JException, MalformedNanopubException {
        HttpGet get = null;
        // TODO Get in Jelly format:
        String getUrl = registryUrl + "np/" + artifactCode;
        try {
            get = new HttpGet(getUrl);
        } catch (IllegalArgumentException ex) {
            throw new IOException("invalid URL: " + getUrl);
        }
        get.setHeader("Accept", "application/trig");
        InputStream in = null;
        try {
            HttpResponse resp = httpClient.execute(get);
            if (!wasSuccessful(resp)) {
                EntityUtils.consumeQuietly(resp.getEntity());
                throw new IOException(resp.getStatusLine().toString());
            }
            in = resp.getEntity().getContent();
            Nanopub nanopub = new NanopubImpl(in, RDFFormat.TRIG);
            if (!TrustyNanopubUtils.isValidTrustyNanopub(nanopub)) {
                throw new MalformedNanopubException("Nanopub is not trusty");
            }
            return nanopub;
        } finally {
            if (in != null) in.close();
        }
    }

    private static boolean wasSuccessful(HttpResponse resp) {
        int c = resp.getStatusLine().getStatusCode();
        return c >= 200 && c < 300;
    }

}

1	package com.knowledgepixels.registry;
2
3	import com.mongodb.client.ClientSession;
4	import com.mongodb.client.MongoCursor;
5	import net.trustyuri.TrustyUriUtils;
6	import net.trustyuri.rdf.RdfModule;
7	import org.apache.http.Header;
8	import org.apache.http.HttpResponse;
9	import org.apache.http.client.HttpClient;
10	import org.apache.http.client.methods.CloseableHttpResponse;
11	import org.apache.http.client.methods.HttpGet;
12	import org.apache.http.util.EntityUtils;
13	import org.bson.Document;
14	import org.bson.types.Binary;
15	import org.eclipse.rdf4j.common.exception.RDF4JException;
16	import org.eclipse.rdf4j.rio.RDFFormat;
17	import org.nanopub.MalformedNanopubException;
18	import org.nanopub.Nanopub;
19	import org.nanopub.NanopubImpl;
20	import org.nanopub.NanopubUtils;
21	import org.nanopub.extra.server.GetNanopub;
22	import org.nanopub.jelly.JellyUtils;
23	import org.nanopub.jelly.MaybeNanopub;
24	import org.nanopub.jelly.NanopubStream;
25	import org.nanopub.trusty.TrustyNanopubUtils;
26	import org.nanopub.vocabulary.NPX;
27	import org.slf4j.Logger;
28	import org.slf4j.LoggerFactory;
29
30	import java.io.IOException;
31	import java.io.InputStream;
32	import java.util.ArrayList;
33	import java.util.Collections;
34	import java.util.List;
35	import java.util.stream.Stream;
36
37	import static com.knowledgepixels.registry.RegistryDB.has;
38
39	public class NanopubLoader {
40
41	private NanopubLoader() {
42	}
43
44	public final static String INTRO_TYPE = NPX.DECLARED_BY.stringValue();	×
45	public final static String INTRO_TYPE_HASH = Utils.getHash(INTRO_TYPE);	×
46	public final static String ENDORSE_TYPE = Utils.APPROVES_OF.stringValue();	×
47	public final static String ENDORSE_TYPE_HASH = Utils.getHash(ENDORSE_TYPE);	×
48	private static final Logger log = LoggerFactory.getLogger(NanopubLoader.class);	×
49
50	// TODO Distinguish and support these cases:
51	// 1. Simple load: load to all core lists if pubkey is "core-loaded", or load to all lists if pubkey is "full-loaded"
52	// 2. Core load: load to all core lists (initialize if needed), or load to all lists if pubkey is "full-loaded"
53	// 3. Full load: load to all lists (initialize if needed)
54
55	public static void simpleLoad(ClientSession mongoSession, String nanopubId) {
56	simpleLoad(mongoSession, retrieveNanopub(mongoSession, nanopubId));	×
57	}	×
58
59	public static void simpleLoad(ClientSession mongoSession, Nanopub np) {
60	String pubkey = RegistryDB.getPubkey(np);	×
61	if (pubkey == null) {	×
62	log.info("Ignore (not signed): {}", np.getUri());	×
63	return;	×
64	}
65	String pubkeyHash = Utils.getHash(pubkey);	×
66	// TODO Do we need to load anything else here, into the other DB collections?
67	if (has(mongoSession, "lists", new Document("pubkey", pubkeyHash).append("type", "$").append("status", "loaded"))) {	×
68	RegistryDB.loadNanopub(mongoSession, np, pubkeyHash, "$");	×
69	} else if (has(mongoSession, "lists", new Document("pubkey", pubkeyHash).append("type", INTRO_TYPE_HASH).append("status", "loaded"))) {	×
70	RegistryDB.loadNanopub(mongoSession, np, pubkeyHash, INTRO_TYPE, ENDORSE_TYPE);	×
71	}
72	}	×
73
74	/**
75	* Retrieve Nanopubs from the peers of this Nanopub Registry.
76	*
77	* @param typeHash The hash of the type of the Nanopub to retrieve.
78	* @param pubkeyHash The hash of the pubkey of the Nanopub to retrieve.
79	* @return A stream of MaybeNanopub objects, or an empty stream if no peer is available.
80	*/
81	public static Stream<MaybeNanopub> retrieveNanopubsFromPeers(String typeHash, String pubkeyHash) {
82	// TODO Move the code of this method to nanopub-java library.
83
84	List<String> peerUrlsToTry = new ArrayList<>(Utils.getPeerUrls());	×
85	Collections.shuffle(peerUrlsToTry);	×
86	while (!peerUrlsToTry.isEmpty()) {	×
87	String peerUrl = peerUrlsToTry.removeFirst();	×
88
89	String requestUrl = peerUrl + "list/" + pubkeyHash + "/" + typeHash + ".jelly";	×
90	log.info("Request: {}", requestUrl);	×
91	try {
92	CloseableHttpResponse resp = NanopubUtils.getHttpClient().execute(new HttpGet(requestUrl));	×
93	int httpStatus = resp.getStatusLine().getStatusCode();	×
94	if (httpStatus < 200 \|\| httpStatus >= 300) {	×
95	log.info("Request failed: {} {}", peerUrl, httpStatus);	×
96	EntityUtils.consumeQuietly(resp.getEntity());	×
97	continue;	×
98	}
99	Header nrStatus = resp.getFirstHeader("Nanopub-Registry-Status");	×
100	if (nrStatus == null) {	×
101	log.info("Nanopub-Registry-Status header not found at: {}", peerUrl);	×
102	EntityUtils.consumeQuietly(resp.getEntity());	×
103	continue;	×
104	} else if (!nrStatus.getValue().equals("ready") && !nrStatus.getValue().equals("updating")) {	×
105	log.info("Peer in non-ready state: {} {}", peerUrl, nrStatus.getValue());	×
106	EntityUtils.consumeQuietly(resp.getEntity());	×
107	continue;	×
108	}
109	InputStream is = resp.getEntity().getContent();	×
110	return NanopubStream.fromByteStream(is).getAsNanopubs();	×
111	} catch (UnsupportedOperationException \| IOException ex) {	×
112	log.info("Request failed: ", ex);	×
113	}
114	}	×
115	return Stream.empty();	×
116	}
117
118	public static Nanopub retrieveNanopub(ClientSession mongoSession, String nanopubId) {
119	Nanopub np = retrieveLocalNanopub(mongoSession, nanopubId);	×
120	int tryCount = 0;	×
121	while (np == null) {	×
122	if (tryCount > 10) {	×
123	throw new RuntimeException("Could not load nanopub: " + nanopubId);	×
124	} else if (tryCount > 0) {	×
125	try {
126	Thread.sleep(100);	×
127	} catch (InterruptedException ex) {	×
128	log.info("Thread was interrupted", ex);	×
129	}	×
130	}
131	log.info("Loading {}", nanopubId);	×
132
133	// TODO Reach out to other Nanopub Registries here:
134	np = getNanopub(nanopubId);	×
135	if (np != null) {	×
136	RegistryDB.loadNanopub(mongoSession, np);	×
137	} else {
138	tryCount = tryCount + 1;	×
139	}
140	}
141	return np;	×
142	}
143
144	public static Nanopub retrieveLocalNanopub(ClientSession mongoSession, String nanopubId) {
145	String ac = TrustyUriUtils.getArtifactCode(nanopubId);	×
146	MongoCursor<Document> cursor = RegistryDB.get(mongoSession, "nanopubs", new Document("_id", ac));	×
147	if (!cursor.hasNext()) return null;	×
148	try {
149	// Parse from Jelly, not TriG (it's faster)
150	return JellyUtils.readFromDB(((Binary) cursor.next().get("jelly")).getData());	×
151	} catch (RDF4JException \| MalformedNanopubException ex) {	×
152	log.info("Exception reading Jelly", ex);	×
153	return null;	×
154	}
155	}
156
157	// TODO Provide this method in nanopub-java (GetNanopub)
158	private static Nanopub getNanopub(String uriOrArtifactCode) {
159	List<String> peerUrls = new ArrayList<>(Utils.getPeerUrls());	×
160	Collections.shuffle(peerUrls);	×
161	String ac = GetNanopub.getArtifactCode(uriOrArtifactCode);	×
162	if (!ac.startsWith(RdfModule.MODULE_ID)) {	×
163	throw new IllegalArgumentException("Not a trusty URI of type RA");	×
164	}
165	while (!peerUrls.isEmpty()) {	×
166	String peerUrl = peerUrls.removeFirst();	×
167	try {
168	Nanopub np = get(ac, peerUrl, NanopubUtils.getHttpClient());	×
169	if (np != null) {	×
170	return np;	×
171	}
172	} catch (IOException \| RDF4JException \| MalformedNanopubException ex) {	×
173	// ignore
174	}	×
175	}	×
176	return null;	×
177	}
178
179	// TODO Provide this method in nanopub-java (GetNanopub)
180	private static Nanopub get(String artifactCode, String registryUrl, HttpClient httpClient)
181	throws IOException, RDF4JException, MalformedNanopubException {
182	HttpGet get = null;	×
183	// TODO Get in Jelly format:
184	String getUrl = registryUrl + "np/" + artifactCode;	×
185	try {
186	get = new HttpGet(getUrl);	×
187	} catch (IllegalArgumentException ex) {	×
188	throw new IOException("invalid URL: " + getUrl);	×
189	}	×
190	get.setHeader("Accept", "application/trig");	×
191	InputStream in = null;	×
192	try {
193	HttpResponse resp = httpClient.execute(get);	×
194	if (!wasSuccessful(resp)) {	×
195	EntityUtils.consumeQuietly(resp.getEntity());	×
196	throw new IOException(resp.getStatusLine().toString());	×
197	}
198	in = resp.getEntity().getContent();	×
199	Nanopub nanopub = new NanopubImpl(in, RDFFormat.TRIG);	×
200	if (!TrustyNanopubUtils.isValidTrustyNanopub(nanopub)) {	×
201	throw new MalformedNanopubException("Nanopub is not trusty");	×
202	}
203	return nanopub;	×
204	} finally {
205	if (in != null) in.close();	×
206	}
207	}
208
209	private static boolean wasSuccessful(HttpResponse resp) {
210	int c = resp.getStatusLine().getStatusCode();	×
211	return c >= 200 && c < 300;	×
212	}
213
214	}

knowledgepixels / nanopub-registry / 20413250445

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