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.Rapp;
25 import com.oransc.rappmanager.models.csar.RappCsarConfigurationHandler;
26 import com.oransc.rappmanager.models.RappDeployer;
27 import com.oransc.rappmanager.models.rapp.RappEvent;
28 import com.oransc.rappmanager.models.rappinstance.RappInstance;
29 import com.oransc.rappmanager.models.cache.RappCacheService;
30 import com.oransc.rappmanager.models.statemachine.RappInstanceStateMachine;
31 import com.oransc.rappmanager.sme.invoker.data.APIInvokerEnrolmentDetails;
32 import com.oransc.rappmanager.sme.provider.data.APIProviderEnrolmentDetails;
33 import com.oransc.rappmanager.sme.provider.data.APIProviderFunctionDetails;
34 import com.oransc.rappmanager.sme.provider.data.ApiProviderFuncRole;
35 import com.oransc.rappmanager.sme.provider.data.RegistrationInformation;
36 import com.oransc.rappmanager.sme.publishservice.data.ServiceAPIDescription;
37 import java.util.List;
38 import java.util.Optional;
39 import lombok.RequiredArgsConstructor;
40 import org.slf4j.Logger;
41 import org.slf4j.LoggerFactory;
42 import org.springframework.stereotype.Service;
45 @RequiredArgsConstructor
46 public class SmeDeployer implements RappDeployer {
48 Logger logger = LoggerFactory.getLogger(SmeDeployer.class);
50 private final com.oransc.rappmanager.sme.provider.rest.DefaultApiClient providerDefaultApiClient;
52 private final com.oransc.rappmanager.sme.publishservice.rest.DefaultApiClient publishServiceDefaultApiClient;
54 private final com.oransc.rappmanager.sme.invoker.rest.DefaultApiClient invokerDefaultApiClient;
56 private final RappCsarConfigurationHandler rappCsarConfigurationHandler;
58 private final ObjectMapper objectMapper;
60 private final RappCacheService rappCacheService;
62 private final RappInstanceStateMachine rappInstanceStateMachine;
64 private String amfRegistrationId;
67 APIProviderEnrolmentDetails createAMF() {
68 APIProviderEnrolmentDetails responseApiEnrollmentDetails = null;
70 APIProviderFunctionDetails apiProviderFunctionDetails = new APIProviderFunctionDetails();
71 apiProviderFunctionDetails.setApiProvFuncRole(ApiProviderFuncRole.AMF);
72 apiProviderFunctionDetails.setApiProvFuncInfo("Rapp Manager as AMF");
73 apiProviderFunctionDetails.setRegInfo(new RegistrationInformation().apiProvPubKey("asd"));
75 APIProviderEnrolmentDetails apiProviderEnrolmentDetails = new APIProviderEnrolmentDetails();
76 apiProviderEnrolmentDetails.setRegSec("PSK");
77 apiProviderEnrolmentDetails.setApiProvDomInfo("Rapp Manager as AMF");
78 apiProviderEnrolmentDetails.setApiProvFuncs(List.of(apiProviderFunctionDetails));
79 responseApiEnrollmentDetails = providerDefaultApiClient.postRegistrations(apiProviderEnrolmentDetails);
80 amfRegistrationId = responseApiEnrollmentDetails.getApiProvDomId();
81 } catch (Exception e) {
82 logger.warn("Error in creating AMF", e);
84 return responseApiEnrollmentDetails;
88 deleteProviderFunc(amfRegistrationId);
92 public boolean deployRappInstance(Rapp rapp, RappInstance rappInstance) {
93 logger.debug("Deploying SME functions for RappInstance {}", rappInstance.getRappInstanceId());
96 createProviderDomain(rapp, rappInstance) && createPublishApi(rapp, rappInstance) && createInvoker(
99 rappInstanceStateMachine.sendRappInstanceEvent(rappInstance, RappEvent.SMEDEPLOYED);
101 rappInstanceStateMachine.sendRappInstanceEvent(rappInstance, RappEvent.SMEDEPLOYFAILED);
104 } catch (JsonProcessingException e) {
105 logger.warn("Failed to deploy SME functions for Rapp {}", rapp.getName(), e);
111 public boolean undeployRappInstance(Rapp rapp, RappInstance rappInstance) {
112 logger.debug("Undeploying SME functions for Rapp {}", rapp.getName());
114 rappInstance.getSme().getInvokerIds().forEach(this::deleteInvoker);
115 rappInstance.getSme().getServiceApiIds()
116 .forEach(s -> deletePublishApi(s, rappInstance.getSme().getApfId()));
117 rappInstance.getSme().getProviderFunctionIds().forEach(this::deleteProviderFunc);
118 rappInstanceStateMachine.sendRappInstanceEvent(rappInstance, RappEvent.SMEUNDEPLOYED);
120 } catch (Exception e) {
121 logger.warn("Failed to Undeploy SME functions for Rapp {}", rapp.getName(), e);
127 public boolean primeRapp(Rapp rapp) {
128 //If there is any priming operations on SME
133 public boolean deprimeRapp(Rapp rapp) {
134 //If there is any deprimgng operations
138 boolean createProviderDomain(Rapp rapp, RappInstance rappInstance) throws JsonProcessingException {
139 logger.debug("Creating provider domain for Rapp {}", rapp.getName());
141 String providerDomainPayload =
142 rappCsarConfigurationHandler.getSmeProviderDomainPayload(rapp, rappInstance.getSme());
143 logger.info("provider domain payload " + providerDomainPayload);
144 if (providerDomainPayload != null) {
145 APIProviderEnrolmentDetails apiProviderEnrolmentDetails =
146 objectMapper.readValue(providerDomainPayload, APIProviderEnrolmentDetails.class);
147 //TODO Fix this Temporary workaround
148 apiProviderEnrolmentDetails.setRegSec(
149 apiProviderEnrolmentDetails.getRegSec() + rappInstance.getRappInstanceId());
150 APIProviderEnrolmentDetails responseApiEnrollmentDetails =
151 providerDefaultApiClient.postRegistrations(apiProviderEnrolmentDetails);
152 if (responseApiEnrollmentDetails.getApiProvFuncs() != null) {
153 rappInstance.getSme().setProviderFunctionIds(responseApiEnrollmentDetails.getApiProvFuncs().stream()
154 .map(APIProviderFunctionDetails::getApiProvFuncId)
157 getProviderFuncId(responseApiEnrollmentDetails.getApiProvFuncs(),
158 ApiProviderFuncRole.APF).ifPresent(apiProviderFunctionDetails -> rappInstance.getSme()
160 apiProviderFunctionDetails.getApiProvFuncId()));
161 getProviderFuncId(responseApiEnrollmentDetails.getApiProvFuncs(),
162 ApiProviderFuncRole.AEF).ifPresent(apiProviderFunctionDetails -> rappInstance.getSme()
164 apiProviderFunctionDetails.getApiProvFuncId()));
168 } catch (Exception e) {
169 logger.warn("Error in creating provider domain", e);
174 Optional<APIProviderFunctionDetails> getProviderFuncId(List<APIProviderFunctionDetails> apiProviderFunctionDetails,
175 ApiProviderFuncRole apiProviderFuncRole) {
176 return apiProviderFunctionDetails.stream()
177 .filter(apiProviderFunctionDetail -> apiProviderFunctionDetail.getApiProvFuncRole()
178 .equals(apiProviderFuncRole)).findFirst();
181 void deleteProviderFunc(String registrationId) {
182 providerDefaultApiClient.deleteRegistrationsRegistrationId(registrationId);
186 boolean createPublishApi(Rapp rapp, RappInstance rappInstance) throws JsonProcessingException {
187 logger.debug("Creating publish api for Rapp {}", rapp.getName());
189 String providerApiPayload =
190 rappCsarConfigurationHandler.getSmeProviderApiPayload(rapp, rappInstance.getSme());
191 if (providerApiPayload != null) {
192 ServiceAPIDescription serviceAPIDescription =
193 objectMapper.readValue(providerApiPayload, ServiceAPIDescription.class);
194 serviceAPIDescription.getAefProfiles().forEach(aefProfile -> {
195 aefProfile.setAefId(rappInstance.getSme().getAefId());
197 ServiceAPIDescription serviceAPIDescriptionResponse =
198 publishServiceDefaultApiClient.postApfIdServiceApis(rappInstance.getSme().getApfId(),
199 serviceAPIDescription);
201 if (serviceAPIDescriptionResponse.getAefProfiles() != null) {
202 rappInstance.getSme().setServiceApiIds(List.of(serviceAPIDescriptionResponse.getApiId()));
206 } catch (Exception e) {
207 logger.warn("Error in creating publish api", e);
212 void deletePublishApi(String serviceApiId, String apfId) {
213 publishServiceDefaultApiClient.deleteApfIdServiceApisServiceApiId(serviceApiId, apfId);
216 boolean createInvoker(Rapp rapp, RappInstance rappInstance) throws JsonProcessingException {
217 logger.debug("Creating provider domain for Rapp {}", rapp.getName());
219 String invokerPayload = rappCsarConfigurationHandler.getSmeInvokerPayload(rapp, rappInstance.getSme());
220 if (invokerPayload != null) {
221 List<APIInvokerEnrolmentDetails> apiInvokerEnrolmentDetails =
222 objectMapper.readValue(invokerPayload, new TypeReference<>() { });
223 apiInvokerEnrolmentDetails.forEach(apiInvokerEnrolmentDetail -> {
224 APIInvokerEnrolmentDetails apiInvokerEnrolmentDetailsResponse =
225 invokerDefaultApiClient.postOnboardedInvokers(apiInvokerEnrolmentDetail);
226 if (apiInvokerEnrolmentDetailsResponse.getApiList() != null) {
227 rappInstance.getSme()
228 .setInvokerIds(List.of(apiInvokerEnrolmentDetailsResponse.getApiInvokerId()));
233 } catch (Exception e) {
234 logger.warn("Error in creating invoker", e);
239 void deleteInvoker(String invokerId) {
240 invokerDefaultApiClient.deleteOnboardedInvokersOnboardingId(invokerId);