September release

Merge request reports

Loading
+1 −1
Changes for src/main/java/org/etsi/osl/hypo/clients/oss/kafka/incoming/OssClientListener.java: 1 added line, 1 removed line.
Original line number Diff line number Diff line
@@ -6,7 +6,7 @@ import static org.etsi.osl.hypo.core.common.constants.SonataKafkaTriggersConstan
import static org.etsi.osl.hypo.core.common.constants.SonataKafkaTriggersConstants.OSS_CLIENT_SERVICE_TERMINATION;

import com.fasterxml.jackson.core.JsonProcessingException;
import io.smallrye.reactive.messaging.annotations.Blocking;
import io.smallrye.common.annotation.Blocking;
import jakarta.enterprise.context.ApplicationScoped;
import jakarta.inject.Inject;
import java.util.UUID;
+2 −2
Changes for src/main/java/org/etsi/osl/hypo/clients/oss/model/OssLifecycleData.java: 2 added lines, 2 removed lines.
Original line number Diff line number Diff line
@@ -18,7 +18,7 @@ import lombok.ToString;
    "oauth2ClientId",
    "oauth2ClientSecret",
    "oauth2Scopes",
    "oauth2TokenUri",
    "authUrl",
    "username",
    "password"
})
@@ -38,7 +38,7 @@ public class OssLifecycleData {

    private String oauth2Scopes;

    private String oauth2TokenUri;
    private String authUrl;

    private String username;

+14 −13
Changes for src/main/java/org/etsi/osl/hypo/clients/oss/oss/external/OidcClientCreator.java: 14 added lines, 13 removed lines.
Original line number Diff line number Diff line
package org.etsi.osl.hypo.clients.oss.oss.external;

import io.quarkus.oidc.client.OidcClient;
import io.quarkus.oidc.client.OidcClientConfig;
import io.quarkus.oidc.client.OidcClientConfig.Grant.Type;
import io.quarkus.oidc.client.OidcClientConfigBuilder;
import io.quarkus.oidc.client.OidcClients;
import io.quarkus.oidc.client.runtime.OidcClientConfig;
import io.smallrye.mutiny.Uni;
import jakarta.enterprise.context.ApplicationScoped;
import jakarta.inject.Inject;
import java.util.Map;
import org.etsi.osl.hypo.clients.oss.util.OssConstants;

@ApplicationScoped
public class OidcClientCreator {

    private final OidcClients oidcClients;
    private static final String OIDC_TOKEN_PATH = "/protocol/openid-connect/token";

    @Inject
    public OidcClientCreator(OidcClients oidcClients) {
@@ -22,20 +22,21 @@ public class OidcClientCreator {

    public Uni<OidcClient> createOidcClient(
            String name,
            String url,
            String clientId,
            String secret,
            String username,
            String password,
            String tokenPath) {
        OidcClientConfig cfg = new OidcClientConfig();
        cfg.setId(name);
        cfg.setAuthServerUrl(url + OssConstants.OPEN_SLICE_REALM);
        cfg.setClientId(clientId);
        cfg.getCredentials().setSecret(secret);
        cfg.getGrant().setType(Type.PASSWORD);
        cfg.setGrantOptions(Map.of("password", Map.of("username", username, "password", password)));
        cfg.setTokenPath(tokenPath);
            String authUrl) {
        OidcClientConfig cfg =
                new OidcClientConfigBuilder()
                        .id(name)
                        .authServerUrl(authUrl)
                        .clientId(clientId)
                        .credentials(secret)
                        .grant(OidcClientConfig.Grant.Type.PASSWORD)
                        .grantOptions(Map.of("password", Map.of("username", username, "password", password)))
                        .tokenPath(authUrl + OIDC_TOKEN_PATH)
                        .build();
        return oidcClients.newClient(cfg);
    }
}
+73 −42
Changes for src/main/java/org/etsi/osl/hypo/clients/oss/oss/external/OpenSliceRestClientImpl.java: 73 added lines, 42 removed lines.
Original line number Diff line number Diff line
@@ -3,11 +3,10 @@ package org.etsi.osl.hypo.clients.oss.oss.external;
import com.fasterxml.jackson.core.JsonProcessingException;
import com.fasterxml.jackson.databind.DeserializationFeature;
import com.fasterxml.jackson.databind.ObjectMapper;
import io.quarkus.oidc.client.OidcClient;
import io.quarkus.oidc.client.Tokens;
import io.quarkus.oidc.client.runtime.TokensHelper;
import io.quarkus.rest.client.reactive.QuarkusRestClientBuilder;
import io.smallrye.mutiny.Uni;
import io.smallrye.mutiny.infrastructure.Infrastructure;
import jakarta.enterprise.context.ApplicationScoped;
import jakarta.inject.Inject;
import jakarta.ws.rs.core.Response;
@@ -47,33 +46,45 @@ public class OpenSliceRestClientImpl {
     */
    public Uni<ServiceOrder> createServiceOrderAsUni(
            ServiceOrder serviceOrder, OssLifecycleData ossLifecycleData) {
        return getOssAccessToken(ossLifecycleData)
                .emitOn(Infrastructure.getDefaultWorkerPool())
                .map(
                        token -> {
                            try {
                                ServiceOrder serviceOrderResponse;
            String token = getOssAccessToken(ossLifecycleData);
                                String serviceOrderAsString =
                    objectMapper.writer().withDefaultPrettyPrinter().writeValueAsString(serviceOrder);
            logger.infof("Will submit service order creation request with body %s", serviceOrderAsString);
                                        objectMapper
                                                .writer()
                                                .withDefaultPrettyPrinter()
                                                .writeValueAsString(serviceOrder);
                                logger.infof(
                                        "Will submit service order creation request with body %s",
                                        serviceOrderAsString);
                                OpenSliceRestClient openSliceRestClient =
                                        createDynamicRestClient(ossLifecycleData.getBaseUrl());
                                String serviceOrderResponseBodyAsString;
            try (Response response = openSliceRestClient.submitServiceOrder(token, serviceOrder)) {
                                try (Response response =
                                        openSliceRestClient.submitServiceOrder(token, serviceOrder)) {
                                    serviceOrderResponseBodyAsString = response.readEntity(String.class);
                                }
                                serviceOrderResponse =
                                        objectMapper.readValue(serviceOrderResponseBodyAsString, ServiceOrder.class);
                                if (logger.isDebugEnabled()) {
                                    logger.debugf(
                                            "Returning service order created %s ",
                                            objectMapper
                                                    .writer()
                                                    .withDefaultPrettyPrinter()
                                                    .writeValueAsString(serviceOrderResponse));
            return Uni.createFrom().item(serviceOrderResponse);

                                }
                                return serviceOrderResponse;
                            } catch (Exception e) {
                                logger.errorf(
                    "service order creation failed with message %s and exception %s", e.getMessage(), e);
            return Uni.createFrom().failure(e);
                                        "service order creation failed with message %s and exception %s",
                                        e.getMessage(), e);
                                throw new OssException(e.getMessage());
                            }
                        });
    }

    /**
@@ -84,24 +95,30 @@ public class OpenSliceRestClientImpl {
     */
    public Uni<ServiceOrder> getServiceOrderByIdAsUni(
            String serviceOrderId, OssLifecycleData ossLifecycleData) {
        return getOssAccessToken(ossLifecycleData)
                .emitOn(Infrastructure.getDefaultWorkerPool()) // Safely move off the event loop thread
                .map(
                        token -> {
                            try {
                                logger.debugf("Will submit request GET service order with id %s", serviceOrderId);
                                OpenSliceRestClient openSliceRestClient =
                                        createDynamicRestClient(ossLifecycleData.getBaseUrl());
                                createDynamicRestClient(ossLifecycleData.getBaseUrl());
            String token = getOssAccessToken(ossLifecycleData);
                                Response response = openSliceRestClient.getServiceOrderById(token, serviceOrderId);
                                String serviceOrderResponseBodyAsString = response.readEntity(String.class);
                                ServiceOrder serviceOrder =
                                        objectMapper.readValue(serviceOrderResponseBodyAsString, ServiceOrder.class);
                                if (logger.isDebugEnabled()) {
                                    logger.debugf("Returning the retrieved Service Order %s", serviceOrder);
            return Uni.createFrom().item(serviceOrder);

                                }
                                return serviceOrder;
                            } catch (Exception e) {
                                logger.errorf(
                    "service order GET request failed with message %s and exception %s", e.getMessage(), e);
            return Uni.createFrom().failure(e);
                                        "service order GET request failed with message %s and exception %s",
                                        e.getMessage(), e);
                                throw new OssException(e.getMessage());
                            }
                        });
    }

    /**
@@ -112,23 +129,31 @@ public class OpenSliceRestClientImpl {
     * @return Service as Uni
     */
    public Uni<Service> getServiceByIdAsUni(String serviceId, OssLifecycleData ossLifecycleData) {
        return getOssAccessToken(ossLifecycleData)
                .emitOn(Infrastructure.getDefaultWorkerPool())
                .map(
                        token -> {
                            try {
                                logger.debugf("Will submit GET service request with id %s", serviceId);
                                OpenSliceRestClient openSliceRestClient =
                                        createDynamicRestClient(ossLifecycleData.getBaseUrl());
            String token = getOssAccessToken(ossLifecycleData);
                                Response response =
                                        openSliceRestClient.getServiceFromServiceInventoryApiById(token, serviceId);
                                String serviceResponseBodyAsString = response.readEntity(String.class);
            Service service = objectMapper.readValue(serviceResponseBodyAsString, Service.class);
                                Service service =
                                        objectMapper.readValue(serviceResponseBodyAsString, Service.class);
                                if (logger.isDebugEnabled()) {
                                    logger.debugf("Returning the retrieved Service %s", service);
            return Uni.createFrom().item(service);
                                }
                                return service;

                            } catch (Exception e) {
                                logger.errorf(
                    "service GET request failed with message %s and exception %s", e.getMessage(), e);
            return Uni.createFrom().failure(e);
                                        "service GET request failed with message %s and exception %s",
                                        e.getMessage(), e);
                                throw new OssException(e.getMessage());
                            }
                        });
    }

    /**
@@ -139,23 +164,31 @@ public class OpenSliceRestClientImpl {
     * @return Resource as Uni
     */
    public Uni<Resource> getResourceByIdAsUni(String resourceId, OssLifecycleData ossLifecycleData) {
        return getOssAccessToken(ossLifecycleData)
                .emitOn(Infrastructure.getDefaultWorkerPool()) // Safely move off the event loop thread
                .map(
                        token -> {
                            try {
                                logger.debugf("Will submit GET resource request with id %s", resourceId);
                                OpenSliceRestClient openSliceRestClient =
                                        createDynamicRestClient(ossLifecycleData.getBaseUrl());
            String token = getOssAccessToken(ossLifecycleData);
                                Response response =
                                        openSliceRestClient.getResourceFromResourceInventoryById(token, resourceId);
                                String serviceResponseBodyAsString = response.readEntity(String.class);
            Resource resource = objectMapper.readValue(serviceResponseBodyAsString, Resource.class);
                                Resource resource =
                                        objectMapper.readValue(serviceResponseBodyAsString, Resource.class);
                                if (logger.isDebugEnabled()) {
                                    logger.debugf("Returning the retrieved Resource %s", resource);
            return Uni.createFrom().item(resource);
                                }
                                return resource;

                            } catch (Exception e) {
                                logger.errorf(
                    "resource GET request failed with message %s and exception %s", e.getMessage(), e);
            return Uni.createFrom().failure(e);
                                        "resource GET request failed with message %s and exception %s",
                                        e.getMessage(), e);
                                throw new OssException(e.getMessage());
                            }
                        });
    }

    /**
@@ -168,7 +201,7 @@ public class OpenSliceRestClientImpl {
            throws MalformedURLException {
        OpenSliceRestClient openSliceRestClient =
                createDynamicRestClient(ossLifecycleData.getBaseUrl());
        String token = getOssAccessToken(ossLifecycleData);
        String token = getOssAccessToken(ossLifecycleData).await().indefinitely();
        Response response = openSliceRestClient.getServiceOrderById(token, serviceOrderId);
        String serviceOrderResponseBodyAsString = response.readEntity(String.class);
        ServiceOrder serviceOrder;
@@ -192,7 +225,7 @@ public class OpenSliceRestClientImpl {
     */
    public ServiceOrder createServiceOrder(
            ServiceOrder serviceOrder, OssLifecycleData ossLifecycleData) throws JsonProcessingException {
        String token = getOssAccessToken(ossLifecycleData);
        String token = getOssAccessToken(ossLifecycleData).await().indefinitely();
        ServiceOrder serviceOrderResponse;

        String serviceOrderAsString =
@@ -240,7 +273,7 @@ public class OpenSliceRestClientImpl {
            ServiceOrder serviceOrder, OssLifecycleData ossLifecycleData) throws MalformedURLException {
        OpenSliceRestClient openSliceRestClient =
                createDynamicRestClient(ossLifecycleData.getBaseUrl());
        String token = getOssAccessToken(ossLifecycleData);
        String token = getOssAccessToken(ossLifecycleData).await().indefinitely();

        ServiceOrder serviceOrderResponse;
        try (Response response =
@@ -260,14 +293,14 @@ public class OpenSliceRestClientImpl {
     * This method is used to make an HTTP call to Open Slice to update a service
     *
     * @param service - the updated service
     * @param serviceId
     * @param serviceId - the service id
     */
    public void updateService(
            ServiceUpdateRequestBody service, OssLifecycleData ossLifecycleData, String serviceId)
            throws MalformedURLException {
        OpenSliceRestClient openSliceRestClient =
                createDynamicRestClient(ossLifecycleData.getBaseUrl());
        String token = getOssAccessToken(ossLifecycleData);
        String token = getOssAccessToken(ossLifecycleData).await().indefinitely();

        try (Response response = openSliceRestClient.updateService(token, service, serviceId)) {
            String serviceOrderResponseBodyAsString = response.readEntity(String.class);
@@ -292,7 +325,7 @@ public class OpenSliceRestClientImpl {
            throws MalformedURLException {
        OpenSliceRestClient openSliceRestClient =
                createDynamicRestClient(ossLifecycleData.getBaseUrl());
        String token = getOssAccessToken(ossLifecycleData);
        String token = getOssAccessToken(ossLifecycleData).await().indefinitely();
        Response response = openSliceRestClient.getServiceFromServiceInventoryApiById(token, serviceId);
        String inventoryResponseBodyAsString = response.readEntity(String.class);
        Service service;
@@ -317,7 +350,7 @@ public class OpenSliceRestClientImpl {
            throws MalformedURLException {
        OpenSliceRestClient openSliceRestClient =
                createDynamicRestClient(ossLifecycleData.getBaseUrl());
        String token = getOssAccessToken(ossLifecycleData);
        String token = getOssAccessToken(ossLifecycleData).await().indefinitely();
        Response response = openSliceRestClient.getResourceFromResourceInventoryById(token, resourceId);
        String resourceResponseBodyAsString = response.readEntity(String.class);
        Resource resource;
@@ -331,26 +364,24 @@ public class OpenSliceRestClientImpl {
        return resource;
    }

    private String getOssAccessToken(OssLifecycleData ossLifecycleData) {
    private Uni<String> getOssAccessToken(OssLifecycleData ossLifecycleData) {
        TokensHelper tokenHelper = new TokensHelper();
        Uni<OidcClient> oidcClientUni =
                oidcClientCreator.createOidcClient(
        return oidcClientCreator
                .createOidcClient(
                        ossLifecycleData.getName(),
                        ossLifecycleData.getBaseUrl(),
                        ossLifecycleData.getOauth2ClientId(),
                        ossLifecycleData.getOauth2ClientSecret(),
                        ossLifecycleData.getUsername(),
                        ossLifecycleData.getPassword(),
                        ossLifecycleData.getOauth2TokenUri());

        Tokens tokens =
                tokenHelper.getTokens(oidcClientUni.await().indefinitely()).await().indefinitely();

        return "Bearer " + tokens.getAccessToken();
                        ossLifecycleData.getAuthUrl())
                .chain(tokenHelper::getTokens)
                .map(tokens -> "Bearer " + tokens.getAccessToken());
    }

    public OpenSliceRestClient createDynamicRestClient(String baseUrl) throws MalformedURLException {
        if (logger.isDebugEnabled()) {
            logger.debugf("Request directed to OpenSlice with URL: " + baseUrl);
        }
        return QuarkusRestClientBuilder.newBuilder()
                .baseUrl(new URL(baseUrl))
                .build(OpenSliceRestClient.class);
+21 −8
Changes for src/main/java/org/etsi/osl/hypo/clients/oss/poller/OpenSlicePoller.java: 21 added lines, 8 removed lines.
Original line number Diff line number Diff line
@@ -2,6 +2,7 @@ package org.etsi.osl.hypo.clients.oss.poller;

import io.smallrye.mutiny.Multi;
import io.smallrye.mutiny.Uni;
import io.smallrye.mutiny.infrastructure.Infrastructure;
import jakarta.enterprise.context.ApplicationScoped;
import jakarta.inject.Inject;
import java.time.Duration;
@@ -39,11 +40,14 @@ public class OpenSlicePoller {
        logger.infof("Started looping open slice for service order id %s", serviceOrderId);
        return Multi.createBy()
                .repeating()
                .supplier(
                .uni(
                        () ->
                                new ServiceOrderResponseSupplier(
                                serviceOrderId, openSliceRestClientImpl, ossLifecycleData))
                                                serviceOrderId, openSliceRestClientImpl, ossLifecycleData)
                                        .get())
                .withDelay(Duration.ofMillis(openSlicePollDelay))
                .whilst(Objects::isNull)
                .runSubscriptionOn(Infrastructure.getDefaultWorkerPool())
                .collect()
                .last();
    }
@@ -58,11 +62,14 @@ public class OpenSlicePoller {
        logger.infof("Started looping open slice for service order id %s", serviceOrderId);
        return Multi.createBy()
                .repeating()
                .supplier(
                .uni(
                        () ->
                                new OssServiceOrderResponseSupplier(
                                openSliceRestClientImpl, serviceOrderId, ossLifecycleData))
                                                openSliceRestClientImpl, serviceOrderId, ossLifecycleData)
                                        .get())
                .withDelay(Duration.ofMillis(openSlicePollDelay))
                .whilst(Objects::isNull)
                .runSubscriptionOn(Infrastructure.getDefaultWorkerPool())
                .collect()
                .last();
    }
@@ -76,10 +83,13 @@ public class OpenSlicePoller {
        logger.infof("Started looping open slice for service id %s", serviceId);
        return Multi.createBy()
                .repeating()
                .supplier(
                        new ServiceInventorySupplier(serviceId, openSliceRestClientImpl, ossLifecycleData))
                .uni(
                        () ->
                                new ServiceInventorySupplier(serviceId, openSliceRestClientImpl, ossLifecycleData)
                                        .get())
                .withDelay(Duration.ofMillis(openSlicePollDelay))
                .whilst(Objects::isNull)
                .runSubscriptionOn(Infrastructure.getDefaultWorkerPool())
                .collect()
                .last();
    }
@@ -95,10 +105,13 @@ public class OpenSlicePoller {
        logger.infof("Started looping open slice for resource id %s", resourceId);
        return Multi.createBy()
                .repeating()
                .supplier(
                        new ResourceInventorySupplier(resourceId, openSliceRestClientImpl, ossLifecycleData))
                .uni(
                        () ->
                                new ResourceInventorySupplier(resourceId, openSliceRestClientImpl, ossLifecycleData)
                                        .get())
                .withDelay(Duration.ofMillis(openSlicePollDelay))
                .whilst(Objects::isNull)
                .runSubscriptionOn(Infrastructure.getDefaultWorkerPool())
                .collect()
                .last();
    }
Loading
Loading