2 * ============LICENSE_START======================================================================
3 * Copyright (C) 2023 Nordix Foundation. All rights reserved.
4 * ===============================================================================================
5 * Licensed under the Apache License, Version 2.0 (the "License");
6 * you may not use this file except in compliance with the License.
7 * You may obtain a copy of the License at
9 * http://www.apache.org/licenses/LICENSE-2.0
11 * Unless required by applicable law or agreed to in writing, software
12 * distributed under the License is distributed on an "AS IS" BASIS,
13 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
14 * See the License for the specific language governing permissions and
15 * limitations under the License.
16 * ============LICENSE_END========================================================================
19 package com.oransc.rappmanager.sme.service;
21 import com.fasterxml.jackson.core.JsonProcessingException;
22 import com.fasterxml.jackson.core.type.TypeReference;
23 import com.fasterxml.jackson.databind.ObjectMapper;
24 import com.oransc.rappmanager.models.Rapp;
25 import com.oransc.rappmanager.models.RappCsarConfigurationHandler;
26 import com.oransc.rappmanager.models.RappDeployer;
27 import com.oransc.rappmanager.models.RappEvent;
28 import com.oransc.rappmanager.models.cache.RappCacheService;
29 import com.oransc.rappmanager.models.statemachine.RappStateMachine;
30 import com.oransc.rappmanager.sme.invoker.data.APIInvokerEnrolmentDetails;
31 import com.oransc.rappmanager.sme.provider.data.APIProviderEnrolmentDetails;
32 import com.oransc.rappmanager.sme.provider.data.APIProviderFunctionDetails;
33 import com.oransc.rappmanager.sme.provider.data.ApiProviderFuncRole;
34 import com.oransc.rappmanager.sme.provider.data.RegistrationInformation;
35 import com.oransc.rappmanager.sme.publishservice.data.AefProfile;
36 import com.oransc.rappmanager.sme.publishservice.data.ServiceAPIDescription;
37 import java.util.List;
38 import java.util.Optional;
39 import java.util.stream.Collectors;
40 import lombok.RequiredArgsConstructor;
41 import org.slf4j.Logger;
42 import org.slf4j.LoggerFactory;
43 import org.springframework.stereotype.Service;
46 @RequiredArgsConstructor
47 public class SmeDeployer implements RappDeployer {
49 Logger logger = LoggerFactory.getLogger(SmeDeployer.class);
51 private final com.oransc.rappmanager.sme.provider.rest.DefaultApiClient providerDefaultApiClient;
53 private final com.oransc.rappmanager.sme.publishservice.rest.DefaultApiClient publishServiceDefaultApiClient;
55 private final com.oransc.rappmanager.sme.invoker.rest.DefaultApiClient invokerDefaultApiClient;
57 private final RappCsarConfigurationHandler rappCsarConfigurationHandler;
59 private final ObjectMapper objectMapper;
61 private final RappCacheService rappCacheService;
63 private final RappStateMachine rappStateMachine;
65 private String amfRegistrationId;
68 APIProviderEnrolmentDetails createAMF() {
69 APIProviderEnrolmentDetails responseApiEnrollmentDetails = null;
71 APIProviderFunctionDetails apiProviderFunctionDetails = new APIProviderFunctionDetails();
72 apiProviderFunctionDetails.setApiProvFuncRole(ApiProviderFuncRole.AMF);
73 apiProviderFunctionDetails.setApiProvFuncInfo("Rapp Manager as AMF");
74 apiProviderFunctionDetails.setRegInfo(new RegistrationInformation().apiProvPubKey("asd"));
76 APIProviderEnrolmentDetails apiProviderEnrolmentDetails = new APIProviderEnrolmentDetails();
77 apiProviderEnrolmentDetails.setRegSec("PSK");
78 apiProviderEnrolmentDetails.setApiProvDomInfo("Rapp Manager as AMF");
79 apiProviderEnrolmentDetails.setApiProvFuncs(List.of(apiProviderFunctionDetails));
80 responseApiEnrollmentDetails = providerDefaultApiClient.postRegistrations(apiProviderEnrolmentDetails);
81 amfRegistrationId = responseApiEnrollmentDetails.getApiProvDomId();
82 } catch (Exception e) {
83 logger.warn("Error in creating AMF", e);
85 return responseApiEnrollmentDetails;
89 deleteProviderFunc(amfRegistrationId);
94 public boolean deployRapp(Rapp rapp) {
95 logger.debug("Deploying SME functions for Rapp {}", rapp.getName());
97 boolean deployState = createProviderDomain(rapp) && createPublishApi(rapp) && createInvoker(rapp);
99 rappStateMachine.sendRappEvent(rapp, RappEvent.SMEDEPLOYED);
101 rappStateMachine.sendRappEvent(rapp, RappEvent.SMEDEPLOYFAILED);
104 } catch (JsonProcessingException e) {
105 logger.warn("Failed to deploy SME functions for Rapp {}", rapp.getName(), e);
111 public boolean undeployRapp(Rapp rapp) {
112 logger.debug("Undeploying SME functions for Rapp {}", rapp.getName());
114 rapp.getSmeInvokers().forEach(this::deleteInvoker);
115 rapp.getSmeServiceApis().forEach(s -> deletePublishApi(s, rapp.getSmeApfId()));
116 rapp.getSmeProviderFunctions().values().forEach(this::deleteProviderFunc);
117 rappStateMachine.sendRappEvent(rapp, RappEvent.SMEUNDEPLOYED);
119 } catch (Exception e) {
120 logger.warn("Failed to Undeploy SME functions for Rapp {}", rapp.getName());
125 boolean createProviderDomain(Rapp rapp) throws JsonProcessingException {
126 logger.debug("Creating provider domain for Rapp {}", rapp.getName());
128 String providerDomainPayload = rappCsarConfigurationHandler.getSmeProviderDomainPayload(rapp);
129 if (providerDomainPayload != null) {
130 APIProviderEnrolmentDetails apiProviderEnrolmentDetails =
131 objectMapper.readValue(providerDomainPayload, APIProviderEnrolmentDetails.class);
132 APIProviderEnrolmentDetails responseApiEnrollmentDetails =
133 providerDefaultApiClient.postRegistrations(apiProviderEnrolmentDetails);
134 if (responseApiEnrollmentDetails.getApiProvFuncs() != null) {
135 getProviderFuncId(responseApiEnrollmentDetails.getApiProvFuncs(),
136 ApiProviderFuncRole.APF).ifPresent(apiProviderFunctionDetails -> rapp.setSmeApfId(
137 apiProviderFunctionDetails.getApiProvFuncId()));
138 getProviderFuncId(responseApiEnrollmentDetails.getApiProvFuncs(),
139 ApiProviderFuncRole.AEF).ifPresent(apiProviderFunctionDetails -> rapp.setSmeAefId(
140 apiProviderFunctionDetails.getApiProvFuncId()));
141 rapp.setSmeProviderFunctions(responseApiEnrollmentDetails.getApiProvFuncs().stream().collect(
142 Collectors.toMap(APIProviderFunctionDetails::getApiProvFuncInfo,
143 APIProviderFunctionDetails::getApiProvFuncId)));
144 rappCacheService.putRapp(rapp);
148 } catch (Exception e) {
149 logger.warn("Error in creating provider domain", e);
154 Optional<APIProviderFunctionDetails> getProviderFuncId(List<APIProviderFunctionDetails> apiProviderFunctionDetails,
155 ApiProviderFuncRole apiProviderFuncRole) {
156 return apiProviderFunctionDetails.stream()
157 .filter(apiProviderFunctionDetail -> apiProviderFunctionDetail.getApiProvFuncRole()
158 .equals(apiProviderFuncRole)).findFirst();
161 void deleteProviderFunc(String registrationId) {
162 providerDefaultApiClient.deleteRegistrationsRegistrationId(registrationId);
166 boolean createPublishApi(Rapp rapp) throws JsonProcessingException {
167 logger.debug("Creating publish api for Rapp {}", rapp.getName());
169 String providerApiPayload = rappCsarConfigurationHandler.getSmeProviderApiPayload(rapp);
170 if (providerApiPayload != null) {
171 ServiceAPIDescription serviceAPIDescription =
172 objectMapper.readValue(providerApiPayload, ServiceAPIDescription.class);
173 serviceAPIDescription.getAefProfiles().forEach(aefProfile -> {
174 aefProfile.setAefId(rapp.getSmeProviderFunctions().get(aefProfile.getAefId()));
176 ServiceAPIDescription serviceAPIDescriptionResponse =
177 publishServiceDefaultApiClient.postApfIdServiceApis(rapp.getSmeApfId(), serviceAPIDescription);
179 if (serviceAPIDescriptionResponse.getAefProfiles() != null) {
180 rapp.setSmeServiceApis(
181 serviceAPIDescriptionResponse.getAefProfiles().stream().map(AefProfile::getAefId)
182 .collect(Collectors.toList()));
183 rappCacheService.putRapp(rapp);
187 } catch (Exception e) {
188 logger.warn("Error in creating publish api", e);
193 void deletePublishApi(String serviceApiId, String apfId) {
194 publishServiceDefaultApiClient.deleteApfIdServiceApisServiceApiId(serviceApiId, apfId);
197 boolean createInvoker(Rapp rapp) throws JsonProcessingException {
198 logger.debug("Creating provider domain for Rapp {}", rapp.getName());
200 String invokerPayload = rappCsarConfigurationHandler.getSmeInvokerPayload(rapp);
201 if (invokerPayload != null) {
202 List<APIInvokerEnrolmentDetails> apiInvokerEnrolmentDetails =
203 objectMapper.readValue(invokerPayload, new TypeReference<>() { });
204 apiInvokerEnrolmentDetails.forEach(apiInvokerEnrolmentDetail -> {
205 APIInvokerEnrolmentDetails apiInvokerEnrolmentDetailsResponse =
206 invokerDefaultApiClient.postOnboardedInvokers(apiInvokerEnrolmentDetail);
207 if (apiInvokerEnrolmentDetailsResponse.getApiList() != null) {
208 rapp.getSmeInvokers().addAll(apiInvokerEnrolmentDetailsResponse.getApiList().stream()
209 .map(com.oransc.rappmanager.sme.invoker.data.ServiceAPIDescription::getApiId)
211 rappCacheService.putRapp(rapp);
216 } catch (Exception e) {
217 logger.warn("Error in creating invoker", e);
222 void deleteInvoker(String invokerId) {
223 invokerDefaultApiClient.deleteOnboardedInvokersOnboardingId(invokerId);