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

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