cps-ncmp-service/src/main/java/org/onap/cps/ncmp/api/impl/events/lcm/LcmEventsCmHandleStateHandlerImpl.java

   1 /*
   2  * ============LICENSE_START=======================================================
   3  * Copyright (C) 2022-2023 Nordix Foundation
   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
   8  *
   9  *       http://www.apache.org/licenses/LICENSE-2.0
  10  *
  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  *
  17  * SPDX-License-Identifier: Apache-2.0
  18  * ============LICENSE_END=========================================================
  19  */
  20
  21 package org.onap.cps.ncmp.api.impl.events.lcm;
  22
  23 import static org.onap.cps.ncmp.api.inventory.CmHandleState.ADVISED;
  24 import static org.onap.cps.ncmp.api.inventory.CmHandleState.DELETED;
  25 import static org.onap.cps.ncmp.api.inventory.CmHandleState.LOCKED;
  26 import static org.onap.cps.ncmp.api.inventory.CmHandleState.READY;
  27
  28 import io.micrometer.core.annotation.Timed;
  29 import java.util.ArrayList;
  30 import java.util.Collection;
  31 import java.util.LinkedHashMap;
  32 import java.util.List;
  33 import java.util.Map;
  34 import lombok.Getter;
  35 import lombok.NoArgsConstructor;
  36 import lombok.RequiredArgsConstructor;
  37 import lombok.Setter;
  38 import lombok.extern.slf4j.Slf4j;
  39 import org.onap.cps.ncmp.api.impl.utils.YangDataConverter;
  40 import org.onap.cps.ncmp.api.impl.yangmodels.YangModelCmHandle;
  41 import org.onap.cps.ncmp.api.inventory.CmHandleState;
  42 import org.onap.cps.ncmp.api.inventory.CompositeState;
  43 import org.onap.cps.ncmp.api.inventory.CompositeStateUtils;
  44 import org.onap.cps.ncmp.api.inventory.InventoryPersistence;
  45 import org.onap.cps.ncmp.api.models.NcmpServiceCmHandle;
  46 import org.onap.cps.ncmp.events.lcm.v1.LcmEvent;
  47 import org.onap.cps.ncmp.events.lcm.v1.LcmEventHeader;
  48 import org.springframework.scheduling.annotation.Async;
  49 import org.springframework.stereotype.Service;
  50
  51 @Slf4j
  52 @Service
  53 @RequiredArgsConstructor
  54 public class LcmEventsCmHandleStateHandlerImpl implements LcmEventsCmHandleStateHandler {
  55
  56     private final InventoryPersistence inventoryPersistence;
  57     private final LcmEventsCreator lcmEventsCreator;
  58     private final LcmEventsService lcmEventsService;
  59
  60     @Override
  61     public void updateCmHandleState(final YangModelCmHandle updatedYangModelCmHandle,
  62             final CmHandleState targetCmHandleState) {
  63
  64         final CompositeState compositeState = updatedYangModelCmHandle.getCompositeState();
  65
  66         if (isCompositeStateSame(compositeState, targetCmHandleState)) {
  67             log.debug("CmHandle with id : {} already in state : {}", updatedYangModelCmHandle.getId(),
  68                     targetCmHandleState);
  69         } else {
  70             final YangModelCmHandle currentYangModelCmHandle = YangModelCmHandle.deepCopyOf(updatedYangModelCmHandle);
  71             updateToSpecifiedCmHandleState(updatedYangModelCmHandle, targetCmHandleState);
  72             persistCmHandle(updatedYangModelCmHandle, currentYangModelCmHandle);
  73             publishLcmEventAsynchronously(toNcmpServiceCmHandle(updatedYangModelCmHandle),
  74                     toNcmpServiceCmHandle(currentYangModelCmHandle));
  75         }
  76     }
  77
  78     @Override
  79     @Timed(value = "cps.ncmp.cmhandle.state.update.batch",
  80             description = "Time taken to update a batch of cm handle states")
  81     public void updateCmHandleStateBatch(final Map<YangModelCmHandle, CmHandleState> cmHandleStatePerCmHandle) {
  82         final Collection<CmHandleTransitionPair> cmHandleTransitionPairs =
  83                 prepareCmHandleTransitionBatch(cmHandleStatePerCmHandle);
  84         persistCmHandleBatch(cmHandleTransitionPairs);
  85         publishLcmEventBatchAsynchronously(cmHandleTransitionPairs);
  86     }
  87
  88     @Async("notificationExecutor")
  89     @Override
  90     public void publishLcmEventAsynchronously(final NcmpServiceCmHandle targetNcmpServiceCmHandle,
  91             final NcmpServiceCmHandle currentNcmpServiceCmHandle) {
  92         publishLcmEvent(targetNcmpServiceCmHandle, currentNcmpServiceCmHandle);
  93     }
  94
  95     /**
  96      * Publish LcmEvent in batches and in asynchronous manner.
  97      *
  98      * @param cmHandleTransitionPairs Pair of existing and modified cm handle represented as YangModelCmHandle
  99      */
 100     @Async("notificationExecutor")
 101     public void publishLcmEventBatchAsynchronously(final Collection<CmHandleTransitionPair> cmHandleTransitionPairs) {
 102         cmHandleTransitionPairs.forEach(cmHandleTransitionPair -> publishLcmEvent(
 103                 toNcmpServiceCmHandle(cmHandleTransitionPair.getTargetYangModelCmHandle()),
 104                 toNcmpServiceCmHandle(cmHandleTransitionPair.getCurrentYangModelCmHandle())));
 105     }
 106
 107     private void publishLcmEvent(final NcmpServiceCmHandle targetNcmpServiceCmHandle,
 108             final NcmpServiceCmHandle existingNcmpServiceCmHandle) {
 109         final String cmHandleId = targetNcmpServiceCmHandle.getCmHandleId();
 110         final LcmEventHeader lcmEventHeader =
 111                 lcmEventsCreator.populateLcmEventHeader(cmHandleId, targetNcmpServiceCmHandle,
 112                         existingNcmpServiceCmHandle);
 113         final LcmEvent lcmEvent =
 114                 lcmEventsCreator.populateLcmEvent(cmHandleId, targetNcmpServiceCmHandle, existingNcmpServiceCmHandle);
 115         lcmEventsService.publishLcmEvent(cmHandleId, lcmEvent, lcmEventHeader);
 116     }
 117
 118     private Collection<CmHandleTransitionPair> prepareCmHandleTransitionBatch(
 119             final Map<YangModelCmHandle, CmHandleState> cmHandleStatePerCmHandle) {
 120         final List<CmHandleTransitionPair> cmHandleTransitionPairs = new ArrayList<>(cmHandleStatePerCmHandle.size());
 121         cmHandleStatePerCmHandle.forEach((yangModelCmHandle, targetCmHandleState) -> {
 122
 123             final CompositeState compositeState = yangModelCmHandle.getCompositeState();
 124
 125             if (isCompositeStateSame(compositeState, targetCmHandleState)) {
 126                 log.debug("CmHandle with id : {} already in state : {}", yangModelCmHandle.getId(),
 127                         targetCmHandleState);
 128             } else {
 129                 final CmHandleTransitionPair cmHandleTransitionPair = new CmHandleTransitionPair();
 130                 cmHandleTransitionPair.setCurrentYangModelCmHandle(YangModelCmHandle.deepCopyOf(yangModelCmHandle));
 131                 updateToSpecifiedCmHandleState(yangModelCmHandle, targetCmHandleState);
 132                 cmHandleTransitionPair.setTargetYangModelCmHandle(yangModelCmHandle);
 133                 cmHandleTransitionPairs.add(cmHandleTransitionPair);
 134             }
 135         });
 136
 137         return cmHandleTransitionPairs;
 138     }
 139
 140
 141     private void persistCmHandle(final YangModelCmHandle targetYangModelCmHandle,
 142             final YangModelCmHandle currentYangModelCmHandle) {
 143         if (isNew(currentYangModelCmHandle.getCompositeState(), targetYangModelCmHandle.getCompositeState())) {
 144             log.debug("Registering a new cm handle {}", targetYangModelCmHandle.getId());
 145             inventoryPersistence.saveCmHandle(targetYangModelCmHandle);
 146         } else if (isDeleted(targetYangModelCmHandle.getCompositeState())) {
 147             log.info("CmHandle with Id : {} is DELETED", targetYangModelCmHandle.getId());
 148         } else {
 149             inventoryPersistence.saveCmHandleState(targetYangModelCmHandle.getId(),
 150                     targetYangModelCmHandle.getCompositeState());
 151         }
 152     }
 153
 154     private void persistCmHandleBatch(final Collection<CmHandleTransitionPair> cmHandleTransitionPairs) {
 155
 156         final List<YangModelCmHandle> newCmHandles = new ArrayList<>();
 157         final Map<String, CompositeState> compositeStatePerCmHandleId = new LinkedHashMap<>();
 158
 159         cmHandleTransitionPairs.forEach(cmHandleTransitionPair -> {
 160             if (isNew(cmHandleTransitionPair.getCurrentYangModelCmHandle().getCompositeState(),
 161                     cmHandleTransitionPair.getTargetYangModelCmHandle().getCompositeState())) {
 162                 newCmHandles.add(cmHandleTransitionPair.getTargetYangModelCmHandle());
 163             } else if (!isDeleted(cmHandleTransitionPair.getTargetYangModelCmHandle().getCompositeState())) {
 164                 compositeStatePerCmHandleId.put(cmHandleTransitionPair.getTargetYangModelCmHandle().getId(),
 165                         cmHandleTransitionPair.getTargetYangModelCmHandle().getCompositeState());
 166             }
 167         });
 168
 169         inventoryPersistence.saveCmHandleBatch(newCmHandles);
 170         inventoryPersistence.saveCmHandleStateBatch(compositeStatePerCmHandleId);
 171
 172     }
 173
 174     private void updateToSpecifiedCmHandleState(final YangModelCmHandle yangModelCmHandle,
 175             final CmHandleState targetCmHandleState) {
 176
 177         if (READY == targetCmHandleState) {
 178             setInitialStates(yangModelCmHandle);
 179         } else if (ADVISED == targetCmHandleState) {
 180             if (yangModelCmHandle.getCompositeState() == null) {
 181                 registerNewCmHandle(yangModelCmHandle);
 182             } else if (yangModelCmHandle.getCompositeState().getCmHandleState() == LOCKED) {
 183                 retryCmHandle(yangModelCmHandle);
 184             }
 185         } else {
 186             setCmHandleState(yangModelCmHandle, targetCmHandleState);
 187         }
 188     }
 189
 190     private void setInitialStates(final YangModelCmHandle yangModelCmHandle) {
 191         CompositeStateUtils.setInitialDataStoreSyncState().accept(yangModelCmHandle.getCompositeState());
 192         CompositeStateUtils.setCompositeState(READY).accept(yangModelCmHandle.getCompositeState());
 193     }
 194
 195     private void retryCmHandle(final YangModelCmHandle yangModelCmHandle) {
 196         CompositeStateUtils.setCompositeStateForRetry().accept(yangModelCmHandle.getCompositeState());
 197     }
 198
 199     private void registerNewCmHandle(final YangModelCmHandle yangModelCmHandle) {
 200         yangModelCmHandle.setCompositeState(new CompositeState());
 201         setCmHandleState(yangModelCmHandle, ADVISED);
 202     }
 203
 204     private void setCmHandleState(final YangModelCmHandle yangModelCmHandle, final CmHandleState targetCmHandleState) {
 205         CompositeStateUtils.setCompositeState(targetCmHandleState).accept(yangModelCmHandle.getCompositeState());
 206     }
 207
 208     private boolean isNew(final CompositeState existingCompositeState, final CompositeState targetCompositeState) {
 209         return (existingCompositeState == null && targetCompositeState.getCmHandleState() == ADVISED);
 210     }
 211
 212     private boolean isDeleted(final CompositeState targetCompositeState) {
 213         return targetCompositeState.getCmHandleState() == DELETED;
 214     }
 215
 216     private boolean isCompositeStateSame(final CompositeState compositeState, final CmHandleState targetCmHandleState) {
 217         return (compositeState != null && compositeState.getCmHandleState() == targetCmHandleState);
 218     }
 219
 220     private NcmpServiceCmHandle toNcmpServiceCmHandle(final YangModelCmHandle yangModelCmHandle) {
 221         return YangDataConverter.convertYangModelCmHandleToNcmpServiceCmHandle(yangModelCmHandle);
 222     }
 223
 224     @Getter
 225     @Setter
 226     @NoArgsConstructor
 227     static class CmHandleTransitionPair {
 228
 229         private YangModelCmHandle currentYangModelCmHandle;
 230         private YangModelCmHandle targetYangModelCmHandle;
 231     }
 232 }