gerrit.onap Code Review - cps.git/blob

   1 /*
   2  * ============LICENSE_START=======================================================
   3  * Copyright (C) 2022-2025 OpenInfra Foundation Europe. 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
   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.impl.inventory.sync.lcm;
  22
  23 import static org.onap.cps.ncmp.api.inventory.models.CmHandleState.DELETED;
  24 import static org.onap.cps.ncmp.impl.inventory.sync.lcm.LcmEventType.CREATE;
  25 import static org.onap.cps.ncmp.impl.inventory.sync.lcm.LcmEventType.DELETE;
  26 import static org.onap.cps.ncmp.impl.inventory.sync.lcm.LcmEventType.UPDATE;
  27
  28 import com.google.common.collect.MapDifference;
  29 import com.google.common.collect.Maps;
  30 import java.util.HashMap;
  31 import java.util.List;
  32 import java.util.Map;
  33 import java.util.UUID;
  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.inventory.models.NcmpServiceCmHandle;
  40 import org.onap.cps.ncmp.events.lcm.v1.Event;
  41 import org.onap.cps.ncmp.events.lcm.v1.LcmEvent;
  42 import org.onap.cps.ncmp.events.lcm.v1.LcmEventHeader;
  43 import org.onap.cps.ncmp.events.lcm.v1.Values;
  44 import org.onap.cps.ncmp.impl.utils.EventDateTimeFormatter;
  45 import org.springframework.stereotype.Component;
  46
  47 /**
  48  * LcmEventsProducerHelper to create LcmEvent based on relevant operation.
  49  */
  50 @Slf4j
  51 @Component
  52 @RequiredArgsConstructor
  53 public class LcmEventsProducerHelper {
  54
  55     private final LcmEventHeaderMapper lcmEventHeaderMapper;
  56
  57     /**
  58      * Populate Lifecycle Management Event.
  59      *
  60      * @param cmHandleId                  cm handle identifier
  61      * @param targetNcmpServiceCmHandle   target ncmp service cmhandle
  62      * @param existingNcmpServiceCmHandle existing ncmp service cmhandle
  63      * @return Populated LcmEvent
  64      */
  65     public LcmEvent populateLcmEvent(final String cmHandleId, final NcmpServiceCmHandle targetNcmpServiceCmHandle,
  66             final NcmpServiceCmHandle existingNcmpServiceCmHandle) {
  67         return createLcmEvent(cmHandleId, targetNcmpServiceCmHandle, existingNcmpServiceCmHandle);
  68     }
  69
  70     /**
  71      * Populate Lifecycle Management Event Header.
  72      *
  73      * @param cmHandleId                  cm handle identifier
  74      * @param targetNcmpServiceCmHandle   target ncmp service cmhandle
  75      * @param existingNcmpServiceCmHandle existing ncmp service cmhandle
  76      * @return Populated LcmEventHeader
  77      */
  78     public LcmEventHeader populateLcmEventHeader(final String cmHandleId,
  79             final NcmpServiceCmHandle targetNcmpServiceCmHandle,
  80             final NcmpServiceCmHandle existingNcmpServiceCmHandle) {
  81         return createLcmEventHeader(cmHandleId, targetNcmpServiceCmHandle, existingNcmpServiceCmHandle);
  82     }
  83
  84     private LcmEvent createLcmEvent(final String cmHandleId, final NcmpServiceCmHandle targetNcmpServiceCmHandle,
  85             final NcmpServiceCmHandle existingNcmpServiceCmHandle) {
  86         final LcmEventType lcmEventType =
  87                 determineEventType(targetNcmpServiceCmHandle, existingNcmpServiceCmHandle);
  88         final LcmEvent lcmEvent = lcmEventHeader(cmHandleId, lcmEventType);
  89         lcmEvent.setEvent(
  90                 lcmEventPayload(cmHandleId, targetNcmpServiceCmHandle, existingNcmpServiceCmHandle, lcmEventType));
  91         return lcmEvent;
  92     }
  93
  94     private LcmEventHeader createLcmEventHeader(final String cmHandleId,
  95             final NcmpServiceCmHandle targetNcmpServiceCmHandle,
  96             final NcmpServiceCmHandle existingNcmpServiceCmHandle) {
  97         final LcmEventType lcmEventType =
  98                 determineEventType(targetNcmpServiceCmHandle, existingNcmpServiceCmHandle);
  99         final LcmEvent lcmEventWithHeaderInformation = lcmEventHeader(cmHandleId, lcmEventType);
 100         return lcmEventHeaderMapper.toLcmEventHeader(lcmEventWithHeaderInformation);
 101     }
 102
 103     private static LcmEventType determineEventType(final NcmpServiceCmHandle targetNcmpServiceCmHandle,
 104                                                    final NcmpServiceCmHandle existingNcmpServiceCmHandle) {
 105
 106         if (existingNcmpServiceCmHandle.getCompositeState() == null) {
 107             return CREATE;
 108         } else if (targetNcmpServiceCmHandle.getCompositeState().getCmHandleState() == DELETED) {
 109             return DELETE;
 110         }
 111         return UPDATE;
 112     }
 113
 114     private static CmHandleValuesHolder determineEventValues(
 115             final NcmpServiceCmHandle targetNcmpServiceCmHandle, final NcmpServiceCmHandle existingNcmpServiceCmHandle,
 116             final LcmEventType lcmEventType) {
 117
 118         if (CREATE == lcmEventType) {
 119             return determineCreateEventValues(targetNcmpServiceCmHandle);
 120         } else if (UPDATE == lcmEventType) {
 121             return determineUpdateEventValues(targetNcmpServiceCmHandle, existingNcmpServiceCmHandle);
 122         }
 123         return new CmHandleValuesHolder();
 124
 125     }
 126
 127     private Event lcmEventPayload(final String eventCorrelationId, final NcmpServiceCmHandle targetNcmpServiceCmHandle,
 128             final NcmpServiceCmHandle existingNcmpServiceCmHandle, final LcmEventType lcmEventType) {
 129         final Event event = new Event();
 130         event.setCmHandleId(eventCorrelationId);
 131         event.setAlternateId(targetNcmpServiceCmHandle.getAlternateId());
 132         event.setModuleSetTag(targetNcmpServiceCmHandle.getModuleSetTag());
 133         event.setDataProducerIdentifier(targetNcmpServiceCmHandle.getDataProducerIdentifier());
 134         final CmHandleValuesHolder cmHandleValuesHolder =
 135                 determineEventValues(targetNcmpServiceCmHandle, existingNcmpServiceCmHandle,
 136                         lcmEventType);
 137         event.setOldValues(cmHandleValuesHolder.getOldValues());
 138         event.setNewValues(cmHandleValuesHolder.getNewValues());
 139
 140         return event;
 141     }
 142
 143     private LcmEvent lcmEventHeader(final String eventCorrelationId, final LcmEventType lcmEventType) {
 144         final LcmEvent lcmEvent = new LcmEvent();
 145         lcmEvent.setEventId(UUID.randomUUID().toString());
 146         lcmEvent.setEventCorrelationId(eventCorrelationId);
 147         lcmEvent.setEventTime(EventDateTimeFormatter.getCurrentIsoFormattedDateTime());
 148         lcmEvent.setEventSource("org.onap.ncmp");
 149         lcmEvent.setEventType(lcmEventType.getEventType());
 150         lcmEvent.setEventSchema("org.onap.ncmp:cmhandle-lcm-event");
 151         lcmEvent.setEventSchemaVersion("1.0");
 152         return lcmEvent;
 153     }
 154
 155
 156     private static CmHandleValuesHolder determineCreateEventValues(
 157             final NcmpServiceCmHandle ncmpServiceCmHandle) {
 158         final CmHandleValuesHolder cmHandleValuesHolder = new CmHandleValuesHolder();
 159         cmHandleValuesHolder.setNewValues(new Values());
 160         cmHandleValuesHolder.getNewValues().setDataSyncEnabled(getDataSyncEnabledFlag(ncmpServiceCmHandle));
 161         cmHandleValuesHolder.getNewValues()
 162                 .setCmHandleState(mapCmHandleStateToLcmEventCmHandleState(ncmpServiceCmHandle));
 163         cmHandleValuesHolder.getNewValues().setCmHandleProperties(List.of(ncmpServiceCmHandle.getPublicProperties()));
 164         return cmHandleValuesHolder;
 165     }
 166
 167     private static CmHandleValuesHolder determineUpdateEventValues(
 168             final NcmpServiceCmHandle targetNcmpServiceCmHandle,
 169             final NcmpServiceCmHandle existingNcmpServiceCmHandle) {
 170
 171         final boolean hasDataSyncFlagEnabledChanged =
 172                 hasDataSyncEnabledFlagChanged(targetNcmpServiceCmHandle, existingNcmpServiceCmHandle);
 173         final boolean hasCmHandleStateChanged =
 174                 hasCmHandleStateChanged(targetNcmpServiceCmHandle, existingNcmpServiceCmHandle);
 175         final boolean arePublicCmHandlePropertiesEqual =
 176                 arePublicCmHandlePropertiesEqual(targetNcmpServiceCmHandle.getPublicProperties(),
 177                         existingNcmpServiceCmHandle.getPublicProperties());
 178
 179         final CmHandleValuesHolder cmHandleValuesHolder = new CmHandleValuesHolder();
 180
 181         if (hasDataSyncFlagEnabledChanged || hasCmHandleStateChanged || (!arePublicCmHandlePropertiesEqual)) {
 182             cmHandleValuesHolder.setOldValues(new Values());
 183             cmHandleValuesHolder.setNewValues(new Values());
 184         } else {
 185             return cmHandleValuesHolder;
 186         }
 187
 188         if (hasDataSyncFlagEnabledChanged) {
 189             setDataSyncEnabledFlag(targetNcmpServiceCmHandle, existingNcmpServiceCmHandle, cmHandleValuesHolder);
 190         }
 191
 192         if (hasCmHandleStateChanged) {
 193             setCmHandleStateChange(targetNcmpServiceCmHandle, existingNcmpServiceCmHandle, cmHandleValuesHolder);
 194         }
 195
 196         if (!arePublicCmHandlePropertiesEqual) {
 197             setPublicCmHandlePropertiesChange(targetNcmpServiceCmHandle, existingNcmpServiceCmHandle,
 198                     cmHandleValuesHolder);
 199         }
 200
 201         return cmHandleValuesHolder;
 202
 203     }
 204
 205     private static void setDataSyncEnabledFlag(final NcmpServiceCmHandle targetNcmpServiceCmHandle,
 206                                                final NcmpServiceCmHandle existingNcmpServiceCmHandle,
 207                                                final CmHandleValuesHolder cmHandleValuesHolder) {
 208
 209         cmHandleValuesHolder.getOldValues().setDataSyncEnabled(getDataSyncEnabledFlag(existingNcmpServiceCmHandle));
 210         cmHandleValuesHolder.getNewValues().setDataSyncEnabled(getDataSyncEnabledFlag(targetNcmpServiceCmHandle));
 211
 212     }
 213
 214     private static void setCmHandleStateChange(final NcmpServiceCmHandle targetNcmpServiceCmHandle,
 215                                                final NcmpServiceCmHandle existingNcmpServiceCmHandle,
 216                                                final CmHandleValuesHolder cmHandleValuesHolder) {
 217         cmHandleValuesHolder.getOldValues()
 218                 .setCmHandleState(mapCmHandleStateToLcmEventCmHandleState(existingNcmpServiceCmHandle));
 219         cmHandleValuesHolder.getNewValues()
 220                 .setCmHandleState(mapCmHandleStateToLcmEventCmHandleState(targetNcmpServiceCmHandle));
 221     }
 222
 223     private static void setPublicCmHandlePropertiesChange(final NcmpServiceCmHandle targetNcmpServiceCmHandle,
 224                                                           final NcmpServiceCmHandle existingNcmpServiceCmHandle,
 225                                                           final CmHandleValuesHolder cmHandleValuesHolder) {
 226
 227         final Map<String, Map<String, String>> publicCmHandlePropertiesDifference =
 228                 getPublicCmHandlePropertiesDifference(targetNcmpServiceCmHandle.getPublicProperties(),
 229                         existingNcmpServiceCmHandle.getPublicProperties());
 230         cmHandleValuesHolder.getOldValues()
 231                 .setCmHandleProperties(List.of(publicCmHandlePropertiesDifference.get("oldValues")));
 232         cmHandleValuesHolder.getNewValues()
 233                 .setCmHandleProperties(List.of(publicCmHandlePropertiesDifference.get("newValues")));
 234
 235     }
 236
 237     private static Values.CmHandleState mapCmHandleStateToLcmEventCmHandleState(
 238             final NcmpServiceCmHandle ncmpServiceCmHandle) {
 239         return Values.CmHandleState.fromValue(ncmpServiceCmHandle.getCompositeState().getCmHandleState().name());
 240     }
 241
 242     private static Boolean getDataSyncEnabledFlag(final NcmpServiceCmHandle ncmpServiceCmHandle) {
 243         return ncmpServiceCmHandle.getCompositeState().getDataSyncEnabled();
 244     }
 245
 246     private static boolean hasDataSyncEnabledFlagChanged(final NcmpServiceCmHandle targetNcmpServiceCmHandle,
 247                                                          final NcmpServiceCmHandle existingNcmpServiceCmHandle) {
 248
 249         final Boolean targetDataSyncFlag = targetNcmpServiceCmHandle.getCompositeState().getDataSyncEnabled();
 250         final Boolean existingDataSyncFlag = existingNcmpServiceCmHandle.getCompositeState().getDataSyncEnabled();
 251
 252         if (targetDataSyncFlag == null) {
 253             return existingDataSyncFlag != null;
 254         }
 255
 256         return !targetDataSyncFlag.equals(existingDataSyncFlag);
 257     }
 258
 259     private static boolean hasCmHandleStateChanged(final NcmpServiceCmHandle targetNcmpServiceCmHandle,
 260                                                    final NcmpServiceCmHandle existingNcmpServiceCmHandle) {
 261
 262         return targetNcmpServiceCmHandle.getCompositeState().getCmHandleState()
 263                 != existingNcmpServiceCmHandle.getCompositeState().getCmHandleState();
 264     }
 265
 266     private static boolean arePublicCmHandlePropertiesEqual(final Map<String, String> targetCmHandleProperties,
 267                                                             final Map<String, String> existingCmHandleProperties) {
 268         if (targetCmHandleProperties.size() != existingCmHandleProperties.size()) {
 269             return false;
 270         }
 271
 272         return targetCmHandleProperties.equals(existingCmHandleProperties);
 273     }
 274
 275     private static Map<String, Map<String, String>> getPublicCmHandlePropertiesDifference(
 276             final Map<String, String> targetCmHandleProperties, final Map<String, String> existingCmHandleProperties) {
 277         final Map<String, Map<String, String>> oldAndNewPropertiesDifferenceMap = new HashMap<>(2);
 278
 279         final MapDifference<String, String> cmHandlePropertiesDifference =
 280                 Maps.difference(targetCmHandleProperties, existingCmHandleProperties);
 281
 282         final Map<String, String> newValues = new HashMap<>(cmHandlePropertiesDifference.entriesOnlyOnLeft());
 283         final Map<String, String> oldValues = new HashMap<>(cmHandlePropertiesDifference.entriesOnlyOnRight());
 284
 285         cmHandlePropertiesDifference.entriesDiffering().keySet().forEach(cmHandlePropertyName -> {
 286             oldValues.put(cmHandlePropertyName, existingCmHandleProperties.get(cmHandlePropertyName));
 287             newValues.put(cmHandlePropertyName, targetCmHandleProperties.get(cmHandlePropertyName));
 288         });
 289
 290         oldAndNewPropertiesDifferenceMap.put("oldValues", oldValues);
 291         oldAndNewPropertiesDifferenceMap.put("newValues", newValues);
 292
 293         return oldAndNewPropertiesDifferenceMap;
 294     }
 295
 296
 297     @NoArgsConstructor
 298     @Getter
 299     @Setter
 300     static class CmHandleValuesHolder {
 301
 302         private Values oldValues;
 303         private Values newValues;
 304     }
 305
 306 }