FIWARE / trusted-issuers-registry / #5

Committed 06 Dec 2023 01:52PM UTC coverage: 73.938%. First build

Build # #5

Build Type

push

Committed by

Commit Message

Merge pull request #18 from FIWARE/react

make it react

Run Details

34 of 56 new or added lines in 4 files covered. (60.71%)

383 of 518 relevant lines covered (73.94%)

0.74 hits per line

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

56.0

/src/main/java/org/fiware/iam/tir/repository/InMemoryPartiesRepo.java

package org.fiware.iam.tir.repository;

import io.micronaut.http.annotation.Part;
import io.micronaut.scheduling.annotation.Scheduled;
import jakarta.inject.Singleton;
import lombok.extern.slf4j.Slf4j;
import org.fiware.iam.did.model.DIDDocumentVO;
import org.fiware.iam.satellite.model.TrustedCAVO;
import org.fiware.iam.tir.auth.CertificateMapper;
import org.fiware.iam.tir.configuration.Party;
import org.fiware.iam.tir.configuration.SatelliteProperties;
import org.fiware.iam.tir.issuers.IssuersProvider;
import org.fiware.iam.tir.issuers.TrustedIssuer;
import reactor.core.publisher.Mono;

import java.security.cert.CertificateEncodingException;
import java.security.cert.CertificateExpiredException;
import java.security.cert.CertificateNotYetValidException;
import java.security.cert.X509Certificate;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;
import java.util.Optional;
import java.util.stream.Stream;

@Slf4j
@Singleton
public class InMemoryPartiesRepo implements PartiesRepo {

    private final SatelliteProperties satelliteProperties;
    private final IssuersProvider issuersProvider;
    private final List<Party> parties;
    private final DidService didService;
    private final CertificateMapper certificateMapper;

    public InMemoryPartiesRepo(SatelliteProperties satelliteProperties, IssuersProvider issuersProvider, DidService didService, CertificateMapper certificateMapper) {
        this.parties = new ArrayList<>(satelliteProperties.getParties());
        this.satelliteProperties = satelliteProperties;
        this.issuersProvider = issuersProvider;
        this.didService = didService;
        this.certificateMapper = certificateMapper;
    }

    private Optional<TrustedCAVO> toTrustedCaVO(X509Certificate caCert) {

        try {
            String subject = caCert.getSubjectX500Principal().toString();
            String validity = isValid(caCert);
            String fingerprint = certificateMapper.getThumbprint(caCert);
            return Optional.of(new TrustedCAVO().status("granted").certificateFingerprint(fingerprint)
                    .validity(validity).subject(subject));
        } catch (CertificateEncodingException e) {
            log.warn("Was not able to get the fingerprint.");
        }
        return Optional.empty();
    }

    private String isValid(X509Certificate cert) {
        try {
            cert.checkValidity();
            return "valid";
        } catch (CertificateExpiredException | CertificateNotYetValidException e) {
            return "invalid";
        }
    }

    @Scheduled(fixedDelay = "15s")
    public void updateParties() {
        List<Party> updatedParties = new ArrayList<>(satelliteProperties.getParties());

        issuersProvider.getAllTrustedIssuers()
                .flatMap(til -> Mono.zip(til.stream().map(this::getPartyForIssuer).toList(), parties -> Arrays.stream(parties).toList()))
                .subscribe(partiesList -> {
                    for (Object partyObject : partiesList) {
                        if (partyObject instanceof Party party) {
                            updatedParties.add(party);
                        } else {
                            log.warn("Object {} is not a party.", partyObject);
                        }
                    }
                    parties.clear();
                    parties.addAll(updatedParties);
                });
    }


    private Mono<Party> getPartyForIssuer(TrustedIssuer trustedIssuer) {
        return didService.retrieveDidDocument(trustedIssuer.getIssuer())
                .filter(Optional::isPresent)
                .map(Optional::get)
                .flatMap(didDoc -> didService
                        .getCertificate(didDoc)
                        .filter(Optional::isPresent)
                        .map(Optional::get)
                        .map(cert -> new Party(didDoc.getId(), didDoc.getId(), didDoc.getId(), "Active", cert, didDoc))
                );
    }

    @Override
    public List<Party> getParties() {
        return parties;
    }

    @Override
    public List<TrustedCAVO> getTrustedCAs() {
        List<TrustedCAVO> trustedCAVOS = new ArrayList<>();

        satelliteProperties.getTrustedList().stream()
                .forEach(trustedCA -> toTrustedCaVO(certificateMapper.getCertificates(trustedCA.crt()).get(0)).ifPresent(
                        trustedCAVOS::add));

        return trustedCAVOS;
    }

    @Override
    public Optional<Party> getPartyById(String id) {
        return parties.stream().filter(party -> party.id().equals(id)).findFirst();
    }

    @Override
    public Optional<Party> getPartyByDID(String did) {
        return parties.stream().filter(party -> party.did().equals(did)).findFirst();
    }

    @Override
    public void addParty(Party party) {

    }
}

1	package org.fiware.iam.tir.repository;
2
3	import io.micronaut.http.annotation.Part;
4	import io.micronaut.scheduling.annotation.Scheduled;
5	import jakarta.inject.Singleton;
6	import lombok.extern.slf4j.Slf4j;
7	import org.fiware.iam.did.model.DIDDocumentVO;
8	import org.fiware.iam.satellite.model.TrustedCAVO;
9	import org.fiware.iam.tir.auth.CertificateMapper;
10	import org.fiware.iam.tir.configuration.Party;
11	import org.fiware.iam.tir.configuration.SatelliteProperties;
12	import org.fiware.iam.tir.issuers.IssuersProvider;
13	import org.fiware.iam.tir.issuers.TrustedIssuer;
14	import reactor.core.publisher.Mono;
15
16	import java.security.cert.CertificateEncodingException;
17	import java.security.cert.CertificateExpiredException;
18	import java.security.cert.CertificateNotYetValidException;
19	import java.security.cert.X509Certificate;
20	import java.util.ArrayList;
21	import java.util.Arrays;
22	import java.util.List;
23	import java.util.Optional;
24	import java.util.stream.Stream;
25
26	@Slf4j	1✔
27	@Singleton
28	public class InMemoryPartiesRepo implements PartiesRepo {
29
30	private final SatelliteProperties satelliteProperties;
31	private final IssuersProvider issuersProvider;
32	private final List<Party> parties;
33	private final DidService didService;
34	private final CertificateMapper certificateMapper;
35
36	public InMemoryPartiesRepo(SatelliteProperties satelliteProperties, IssuersProvider issuersProvider, DidService didService, CertificateMapper certificateMapper) {	1✔
37	this.parties = new ArrayList<>(satelliteProperties.getParties());	1✔
38	this.satelliteProperties = satelliteProperties;	1✔
39	this.issuersProvider = issuersProvider;	1✔
40	this.didService = didService;	1✔
41	this.certificateMapper = certificateMapper;	1✔
42	}	1✔
43
44	private Optional<TrustedCAVO> toTrustedCaVO(X509Certificate caCert) {
45
46	try {
47	String subject = caCert.getSubjectX500Principal().toString();	1✔
48	String validity = isValid(caCert);	1✔
49	String fingerprint = certificateMapper.getThumbprint(caCert);	1✔
50	return Optional.of(new TrustedCAVO().status("granted").certificateFingerprint(fingerprint)	1✔
51	.validity(validity).subject(subject));	1✔
52	} catch (CertificateEncodingException e) {	×
53	log.warn("Was not able to get the fingerprint.");	×
54	}
55	return Optional.empty();	×
56	}
57
58	private String isValid(X509Certificate cert) {
59	try {
60	cert.checkValidity();	1✔
61	return "valid";	1✔
62	} catch (CertificateExpiredException \| CertificateNotYetValidException e) {	×
63	return "invalid";	×
64	}
65	}
66
67	@Scheduled(fixedDelay = "15s")
68	public void updateParties() {
69	List<Party> updatedParties = new ArrayList<>(satelliteProperties.getParties());	1✔
70
71	issuersProvider.getAllTrustedIssuers()	1✔
72	.flatMap(til -> Mono.zip(til.stream().map(this::getPartyForIssuer).toList(), parties -> Arrays.stream(parties).toList()))	1✔
73	.subscribe(partiesList -> {	1✔
NEW 74	for (Object partyObject : partiesList) {	×
NEW 75	if (partyObject instanceof Party party) {	×
NEW 76	updatedParties.add(party);	×
77	} else {
NEW 78	log.warn("Object {} is not a party.", partyObject);	×
79	}
NEW 80	}	×
NEW 81	parties.clear();	×
NEW 82	parties.addAll(updatedParties);	×
NEW 83	});	×
84	}	1✔
85
86
87	private Mono<Party> getPartyForIssuer(TrustedIssuer trustedIssuer) {
NEW 88	return didService.retrieveDidDocument(trustedIssuer.getIssuer())	×
NEW 89	.filter(Optional::isPresent)	×
NEW 90	.map(Optional::get)	×
NEW 91	.flatMap(didDoc -> didService	×
NEW 92	.getCertificate(didDoc)	×
NEW 93	.filter(Optional::isPresent)	×
NEW 94	.map(Optional::get)	×
NEW 95	.map(cert -> new Party(didDoc.getId(), didDoc.getId(), didDoc.getId(), "Active", cert, didDoc))	×
96	);
97	}
98
99	@Override
100	public List<Party> getParties() {
101	return parties;	1✔
102	}
103
104	@Override
105	public List<TrustedCAVO> getTrustedCAs() {
106	List<TrustedCAVO> trustedCAVOS = new ArrayList<>();	1✔
107
108	satelliteProperties.getTrustedList().stream()	1✔
109	.forEach(trustedCA -> toTrustedCaVO(certificateMapper.getCertificates(trustedCA.crt()).get(0)).ifPresent(	1✔
110	trustedCAVOS::add));	1✔
111
112	return trustedCAVOS;	1✔
113	}
114
115	@Override
116	public Optional<Party> getPartyById(String id) {
117	return parties.stream().filter(party -> party.id().equals(id)).findFirst();	1✔
118	}
119
120	@Override
121	public Optional<Party> getPartyByDID(String did) {
122	return parties.stream().filter(party -> party.did().equals(did)).findFirst();	1✔
123	}
124
125	@Override
126	public void addParty(Party party) {
127
128	}	×
129	}

FIWARE / trusted-issuers-registry / #5

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