cps-ncmp-rest/src/main/java/org/onap/cps/ncmp/rest/controller/NetworkCmProxyController.java

   1 /*
   2  *  ============LICENSE_START=======================================================
   3  *  Copyright (C) 2021 Pantheon.tech
   4  *  Modifications Copyright (C) 2021-2022 Nordix Foundation
   5  *  Modifications Copyright (C) 2021 highstreet technologies GmbH
   6  *  Modifications Copyright (C) 2021-2022 Bell Canada
   7  *  ================================================================================
   8  *  Licensed under the Apache License, Version 2.0 (the "License");
   9  *  you may not use this file except in compliance with the License.
  10  *  You may obtain a copy of the License at
  11  *
  12  *        http://www.apache.org/licenses/LICENSE-2.0
  13  *
  14  *  Unless required by applicable law or agreed to in writing, software
  15  *  distributed under the License is distributed on an "AS IS" BASIS,
  16  *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  17  *  See the License for the specific language governing permissions and
  18  *  limitations under the License.
  19  *
  20  *  SPDX-License-Identifier: Apache-2.0
  21  *  ============LICENSE_END=========================================================
  22  */
  23
  24 package org.onap.cps.ncmp.rest.controller;
  25
  26 import static org.onap.cps.ncmp.api.impl.operations.DmiRequestBody.OperationEnum.CREATE;
  27 import static org.onap.cps.ncmp.api.impl.operations.DmiRequestBody.OperationEnum.DELETE;
  28 import static org.onap.cps.ncmp.api.impl.operations.DmiRequestBody.OperationEnum.PATCH;
  29 import static org.onap.cps.ncmp.api.impl.operations.DmiRequestBody.OperationEnum.UPDATE;
  30
  31 import java.util.HashMap;
  32 import java.util.List;
  33 import java.util.Map;
  34 import java.util.Set;
  35 import java.util.UUID;
  36 import java.util.stream.Collectors;
  37 import javax.validation.Valid;
  38 import javax.validation.constraints.NotNull;
  39 import lombok.RequiredArgsConstructor;
  40 import lombok.extern.slf4j.Slf4j;
  41 import org.onap.cps.ncmp.api.NetworkCmProxyDataService;
  42 import org.onap.cps.ncmp.api.impl.exception.InvalidTopicException;
  43 import org.onap.cps.ncmp.api.inventory.CompositeState;
  44 import org.onap.cps.ncmp.api.models.CmHandleQueryApiParameters;
  45 import org.onap.cps.ncmp.api.models.NcmpServiceCmHandle;
  46 import org.onap.cps.ncmp.rest.api.NetworkCmProxyApi;
  47 import org.onap.cps.ncmp.rest.executor.CpsNcmpTaskExecutor;
  48 import org.onap.cps.ncmp.rest.mapper.CmHandleStateMapper;
  49 import org.onap.cps.ncmp.rest.model.CmHandlePublicProperties;
  50 import org.onap.cps.ncmp.rest.model.CmHandleQueryParameters;
  51 import org.onap.cps.ncmp.rest.model.RestModuleReference;
  52 import org.onap.cps.ncmp.rest.model.RestOutputCmHandle;
  53 import org.onap.cps.ncmp.rest.model.RestOutputCmHandleCompositeState;
  54 import org.onap.cps.ncmp.rest.model.RestOutputCmHandlePublicProperties;
  55 import org.onap.cps.ncmp.rest.util.DeprecationHelper;
  56 import org.onap.cps.utils.CpsValidator;
  57 import org.onap.cps.utils.JsonObjectMapper;
  58 import org.springframework.beans.factory.annotation.Value;
  59 import org.springframework.http.HttpStatus;
  60 import org.springframework.http.ResponseEntity;
  61 import org.springframework.web.bind.annotation.RequestMapping;
  62 import org.springframework.web.bind.annotation.RestController;
  63
  64 @Slf4j
  65 @RestController
  66 @RequestMapping("${rest.api.ncmp-base-path}")
  67 @RequiredArgsConstructor
  68 public class NetworkCmProxyController implements NetworkCmProxyApi {
  69
  70     private static final String NO_BODY = null;
  71     private static final String NO_REQUEST_ID = null;
  72     private static final String NO_TOPIC = null;
  73     private final NetworkCmProxyDataService networkCmProxyDataService;
  74     private final JsonObjectMapper jsonObjectMapper;
  75
  76     private final DeprecationHelper deprecationHelper;
  77     private final NcmpRestInputMapper ncmpRestInputMapper;
  78     private final CmHandleStateMapper cmHandleStateMapper;
  79     private final CpsNcmpTaskExecutor cpsNcmpTaskExecutor;
  80
  81     @Value("${notification.async.executor.time-out-value-in-ms:2000}")
  82     private int timeOutInMilliSeconds;
  83
  84     /**
  85      * Get resource data from operational datastore.
  86      *
  87      * @param cmHandle cm handle identifier
  88      * @param resourceIdentifier resource identifier
  89      * @param optionsParamInQuery options query parameter
  90      * @param topicParamInQuery topic query parameter
  91      * @return {@code ResponseEntity} response from dmi plugin
  92      */
  93     @Override
  94     public ResponseEntity<Object> getResourceDataOperationalForCmHandle(final String cmHandle,
  95                                                                         final @NotNull @Valid String resourceIdentifier,
  96                                                                         final @Valid String optionsParamInQuery,
  97                                                                         final @Valid String topicParamInQuery) {
  98         if (isValidTopic(topicParamInQuery)) {
  99             final String requestId = UUID.randomUUID().toString();
 100             cpsNcmpTaskExecutor.executeTask(() ->
 101                 networkCmProxyDataService.getResourceDataOperationalForCmHandle(
 102                     cmHandle, resourceIdentifier, optionsParamInQuery, topicParamInQuery,
 103                         requestId
 104                 ), timeOutInMilliSeconds
 105             );
 106             return acknowledgeAsyncRequest(requestId);
 107         }
 108
 109         final Object responseObject = networkCmProxyDataService.getResourceDataOperationalForCmHandle(
 110             cmHandle, resourceIdentifier, optionsParamInQuery, NO_TOPIC, NO_REQUEST_ID);
 111
 112         return ResponseEntity.ok(responseObject);
 113     }
 114
 115     /**
 116      * Get resource data from pass-through running datastore.
 117      *
 118      * @param cmHandle cm handle identifier
 119      * @param resourceIdentifier resource identifier
 120      * @param optionsParamInQuery options query parameter
 121      * @param topicParamInQuery topic query parameter
 122      * @return {@code ResponseEntity} response from dmi plugin
 123      */
 124     @Override
 125     public ResponseEntity<Object> getResourceDataRunningForCmHandle(final String cmHandle,
 126                                                                     final @NotNull @Valid String resourceIdentifier,
 127                                                                     final @Valid String optionsParamInQuery,
 128                                                                     final @Valid String topicParamInQuery) {
 129         if (isValidTopic(topicParamInQuery)) {
 130             final String resourceDataRequestId = UUID.randomUUID().toString();
 131             cpsNcmpTaskExecutor.executeTask(() ->
 132                 networkCmProxyDataService.getResourceDataPassThroughRunningForCmHandle(
 133                     cmHandle, resourceIdentifier, optionsParamInQuery, topicParamInQuery,
 134                         resourceDataRequestId
 135                 ), timeOutInMilliSeconds
 136             );
 137             return acknowledgeAsyncRequest(resourceDataRequestId);
 138         }
 139
 140         final Object responseObject = networkCmProxyDataService.getResourceDataPassThroughRunningForCmHandle(
 141             cmHandle, resourceIdentifier, optionsParamInQuery, NO_TOPIC, NO_REQUEST_ID);
 142
 143         return ResponseEntity.ok(responseObject);
 144     }
 145
 146     @Override
 147     public ResponseEntity<Object> patchResourceDataRunningForCmHandle(final String resourceIdentifier,
 148         final String cmHandle,
 149         final Object requestBody, final String contentType) {
 150         final Object responseObject = networkCmProxyDataService.writeResourceDataPassThroughRunningForCmHandle(cmHandle,
 151             resourceIdentifier, PATCH, jsonObjectMapper.asJsonString(requestBody), contentType);
 152         return ResponseEntity.ok(responseObject);
 153     }
 154
 155     /**
 156      * Create resource data in datastore pass-through running for given cm-handle.
 157      *
 158      * @param resourceIdentifier resource identifier
 159      * @param cmHandle cm handle identifier
 160      * @param requestBody the request body
 161      * @param contentType content type of body
 162      * @return {@code ResponseEntity} response from dmi plugin
 163      */
 164     @Override
 165     public ResponseEntity<Void> createResourceDataRunningForCmHandle(final String resourceIdentifier,
 166         final String cmHandle, final Object requestBody, final String contentType) {
 167         networkCmProxyDataService.writeResourceDataPassThroughRunningForCmHandle(cmHandle,
 168                 resourceIdentifier, CREATE, jsonObjectMapper.asJsonString(requestBody), contentType);
 169         return new ResponseEntity<>(HttpStatus.CREATED);
 170     }
 171
 172     /**
 173      * Update resource data in datastore pass-through running for given cm-handle.
 174      *
 175      * @param resourceIdentifier resource identifier
 176      * @param cmHandle cm handle identifier
 177      * @param requestBody the request body
 178      * @param contentType content type of the body
 179      * @return response entity
 180      */
 181     @Override
 182     public ResponseEntity<Object> updateResourceDataRunningForCmHandle(final String resourceIdentifier,
 183                                                                        final String cmHandle,
 184                                                                        final Object requestBody,
 185                                                                        final String contentType) {
 186         networkCmProxyDataService.writeResourceDataPassThroughRunningForCmHandle(cmHandle,
 187                 resourceIdentifier, UPDATE, jsonObjectMapper.asJsonString(requestBody), contentType);
 188         return new ResponseEntity<>(HttpStatus.OK);
 189     }
 190
 191
 192     /**
 193      *  Delete resource data in datastore pass-through running for a given cm-handle.
 194      *
 195      * @param resourceIdentifier resource identifier
 196      * @param cmHandle cm handle identifier
 197      * @param contentType content type of the body
 198      * @return response entity no content if request is successful
 199      */
 200     @Override
 201     public ResponseEntity<Void> deleteResourceDataRunningForCmHandle(final String cmHandle,
 202                                                                      final String resourceIdentifier,
 203                                                                      final String contentType) {
 204         networkCmProxyDataService.writeResourceDataPassThroughRunningForCmHandle(cmHandle,
 205             resourceIdentifier, DELETE, NO_BODY, contentType);
 206         return new ResponseEntity<>(HttpStatus.NO_CONTENT);
 207     }
 208
 209     /**
 210      * Query and return cm handles that match the given query parameters.
 211      *
 212      * @param cmHandleQueryParameters the cm handle query parameters
 213      * @return collection of cm handles
 214      */
 215     @Override
 216     @SuppressWarnings("deprecation") // mapOldConditionProperties method will be removed in Release 12
 217     public ResponseEntity<List<RestOutputCmHandle>> searchCmHandles(
 218             final CmHandleQueryParameters cmHandleQueryParameters) {
 219         final CmHandleQueryApiParameters cmHandleQueryApiParameters =
 220                 deprecationHelper.mapOldConditionProperties(cmHandleQueryParameters);
 221         final Set<NcmpServiceCmHandle> cmHandles = networkCmProxyDataService
 222                 .executeCmHandleSearch(cmHandleQueryApiParameters);
 223         final List<RestOutputCmHandle> outputCmHandles =
 224                 cmHandles.stream().map(this::toRestOutputCmHandle).collect(Collectors.toList());
 225         return ResponseEntity.ok(outputCmHandles);
 226     }
 227
 228     /**
 229      * Query and return cm handle ids that match the given query parameters.
 230      *
 231      * @param cmHandleQueryParameters the cm handle query parameters
 232      * @return collection of cm handle ids
 233      */
 234     @Override
 235     public ResponseEntity<List<String>> searchCmHandleIds(
 236         final CmHandleQueryParameters cmHandleQueryParameters) {
 237         final CmHandleQueryApiParameters cmHandleQueryApiParameters =
 238                 jsonObjectMapper.convertToValueType(cmHandleQueryParameters, CmHandleQueryApiParameters.class);
 239         final Set<String> cmHandleIds = networkCmProxyDataService.executeCmHandleIdSearch(cmHandleQueryApiParameters);
 240         return ResponseEntity.ok(List.copyOf(cmHandleIds));
 241     }
 242
 243     /**
 244      * Search for Cm Handle and Properties by Name.
 245      * @param cmHandleId cm-handle identifier
 246      * @return cm handle and its properties
 247      */
 248     @Override
 249     public ResponseEntity<RestOutputCmHandle> retrieveCmHandleDetailsById(final String cmHandleId) {
 250         final NcmpServiceCmHandle ncmpServiceCmHandle = networkCmProxyDataService.getNcmpServiceCmHandle(cmHandleId);
 251         final RestOutputCmHandle restOutputCmHandle = toRestOutputCmHandle(ncmpServiceCmHandle);
 252         return ResponseEntity.ok(restOutputCmHandle);
 253     }
 254
 255     /**
 256      * Get Cm Handle Properties by Cm Handle Id.
 257      * @param cmHandleId cm-handle identifier
 258      * @return cm handle properties
 259      */
 260     @Override
 261     public ResponseEntity<RestOutputCmHandlePublicProperties> getCmHandlePublicPropertiesByCmHandleId(
 262         final String cmHandleId) {
 263         final CmHandlePublicProperties cmHandlePublicProperties = new CmHandlePublicProperties();
 264         cmHandlePublicProperties.add(networkCmProxyDataService.getCmHandlePublicProperties(cmHandleId));
 265         final RestOutputCmHandlePublicProperties restOutputCmHandlePublicProperties =
 266             new RestOutputCmHandlePublicProperties();
 267         restOutputCmHandlePublicProperties.setPublicCmHandleProperties(cmHandlePublicProperties);
 268         return ResponseEntity.ok(restOutputCmHandlePublicProperties);
 269     }
 270
 271     /**
 272      * Get Cm Handle State by Cm Handle Id.
 273      * @param cmHandleId cm-handle identifier
 274      * @return cm handle state
 275      */
 276     @Override
 277     public ResponseEntity<RestOutputCmHandleCompositeState> getCmHandleStateByCmHandleId(
 278         final String cmHandleId) {
 279         final CompositeState cmHandleState = networkCmProxyDataService.getCmHandleCompositeState(cmHandleId);
 280         final RestOutputCmHandleCompositeState restOutputCmHandleCompositeState =
 281             new RestOutputCmHandleCompositeState();
 282         restOutputCmHandleCompositeState.setState(cmHandleStateMapper.toCmHandleCompositeState(cmHandleState));
 283         return ResponseEntity.ok(restOutputCmHandleCompositeState);
 284     }
 285
 286     /**
 287      * Return module references for a cm handle.
 288      *
 289      * @param cmHandle the cm handle
 290      * @return module references for cm handle. Namespace will be always blank because restConf does not include this.
 291      */
 292     public ResponseEntity<List<RestModuleReference>> getModuleReferencesByCmHandle(final String cmHandle) {
 293         final List<RestModuleReference> restModuleReferences =
 294             networkCmProxyDataService.getYangResourcesModuleReferences(cmHandle).stream()
 295             .map(ncmpRestInputMapper::toRestModuleReference)
 296                 .collect(Collectors.toList());
 297         return new ResponseEntity<>(restModuleReferences, HttpStatus.OK);
 298     }
 299
 300     private RestOutputCmHandle toRestOutputCmHandle(final NcmpServiceCmHandle ncmpServiceCmHandle) {
 301         final RestOutputCmHandle restOutputCmHandle = new RestOutputCmHandle();
 302         final CmHandlePublicProperties cmHandlePublicProperties = new CmHandlePublicProperties();
 303         restOutputCmHandle.setCmHandle(ncmpServiceCmHandle.getCmHandleId());
 304         cmHandlePublicProperties.add(ncmpServiceCmHandle.getPublicProperties());
 305         restOutputCmHandle.setPublicCmHandleProperties(cmHandlePublicProperties);
 306         restOutputCmHandle.setState(cmHandleStateMapper.toCmHandleCompositeState(
 307                 ncmpServiceCmHandle.getCompositeState()));
 308         return restOutputCmHandle;
 309     }
 310
 311     private static boolean isValidTopic(final String topicName) {
 312         if (topicName == null) {
 313             return false;
 314         }
 315         if (CpsValidator.validateTopicName(topicName)) {
 316             return true;
 317         }
 318         throw new InvalidTopicException("Topic name " + topicName + " is invalid", "invalid topic");
 319     }
 320
 321     private ResponseEntity<Object> acknowledgeAsyncRequest(final String requestId) {
 322         final Map<String, Object> acknowledgeData = new HashMap<>(1);
 323         acknowledgeData.put("requestId", requestId);
 324         return ResponseEntity.ok(acknowledgeData);
 325     }
 326
 327 }
 328