Add failure handling support in Intermediary

Add Failure handling support in Intermediary,
and refactor the communication between Participant and Intermediary.

Issue-ID: POLICY-4707
Change-Id: Ica22e0e820efda372886d6d8da9c3526633321e2
Signed-off-by: FrancescoFioraEst <francesco.fiora@est.tech>

4 files changed, 161 insertions, 501 deletions

diff --git a/participant/participant-intermediary/src/main/java/org/onap/policy/clamp/acm/participant/intermediary/api/ParticipantIntermediaryApi.java b/participant/participant-intermediary/src/main/java/org/onap/policy/clamp/acm/participant/intermediary/api/ParticipantIntermediaryApi.java
index 1677f5486..c75750c0d 100644
--- a/participant/participant-intermediary/src/main/java/org/onap/policy/clamp/acm/participant/intermediary/api/ParticipantIntermediaryApi.java
+++ b/participant/participant-intermediary/src/main/java/org/onap/policy/clamp/acm/participant/intermediary/api/ParticipantIntermediaryApi.java
@@ -35,14 +35,6 @@ import org.onap.policy.clamp.models.acm.concepts.StateChangeResult;
 public interface ParticipantIntermediaryApi {
 
     /**
-     * Register a listener for automation composition elements that are mediated by the intermediary.
-     *
-     * @param automationCompositionElementListener The automation composition element listener to register
-     */
-    void registerAutomationCompositionElementListener(
-            AutomationCompositionElementListener automationCompositionElementListener);
-
-    /**
      * Update the state of a automation composition element.
      *
      * @param automationCompositionId the ID of the automation composition to update the state on
diff --git a/participant/participant-intermediary/src/main/java/org/onap/policy/clamp/acm/participant/intermediary/api/impl/ParticipantIntermediaryApiImpl.java b/participant/participant-intermediary/src/main/java/org/onap/policy/clamp/acm/participant/intermediary/api/impl/ParticipantIntermediaryApiImpl.java
index 14a653113..592513258 100644
--- a/participant/participant-intermediary/src/main/java/org/onap/policy/clamp/acm/participant/intermediary/api/impl/ParticipantIntermediaryApiImpl.java
+++ b/participant/participant-intermediary/src/main/java/org/onap/policy/clamp/acm/participant/intermediary/api/impl/ParticipantIntermediaryApiImpl.java
@@ -23,9 +23,10 @@ package org.onap.policy.clamp.acm.participant.intermediary.api.impl;
 
 import java.util.Map;
 import java.util.UUID;
-import org.onap.policy.clamp.acm.participant.intermediary.api.AutomationCompositionElementListener;
+import lombok.RequiredArgsConstructor;
 import org.onap.policy.clamp.acm.participant.intermediary.api.ParticipantIntermediaryApi;
-import org.onap.policy.clamp.acm.participant.intermediary.handler.AutomationCompositionHandler;
+import org.onap.policy.clamp.acm.participant.intermediary.handler.AutomationCompositionOutHandler;
+import org.onap.policy.clamp.acm.participant.intermediary.handler.CacheProvider;
 import org.onap.policy.clamp.models.acm.concepts.AcTypeState;
 import org.onap.policy.clamp.models.acm.concepts.AutomationComposition;
 import org.onap.policy.clamp.models.acm.concepts.DeployState;
@@ -38,31 +39,19 @@ import org.springframework.stereotype.Component;
  * This class is api implementation used by participant intermediary.
  */
 @Component
+@RequiredArgsConstructor
 public class ParticipantIntermediaryApiImpl implements ParticipantIntermediaryApi {
 
     // The handler for the automationComposition intermediary
-    private final AutomationCompositionHandler automationCompositionHandler;
+    private final AutomationCompositionOutHandler automationCompositionHandler;
+    private final CacheProvider cacheProvider;
 
-    /**
-     * Constructor.
-     *
-     * @param automationCompositionHandler AutomationCompositionHandler
-     */
-    public ParticipantIntermediaryApiImpl(AutomationCompositionHandler automationCompositionHandler) {
-        this.automationCompositionHandler = automationCompositionHandler;
-    }
-
-    @Override
-    public void registerAutomationCompositionElementListener(
-            AutomationCompositionElementListener automationCompositionElementListener) {
-        automationCompositionHandler.registerAutomationCompositionElementListener(automationCompositionElementListener);
-    }
 
     @Override
-    public void updateAutomationCompositionElementState(UUID automationCompositionId, UUID id, DeployState deployState,
+    public void updateAutomationCompositionElementState(UUID automationCompositionId, UUID id, DeployState newState,
             LockState lockState, StateChangeResult stateChangeResult, String message) {
-        automationCompositionHandler.updateAutomationCompositionElementState(automationCompositionId, id, deployState,
-                lockState, message);
+        automationCompositionHandler.updateAutomationCompositionElementState(automationCompositionId, id, newState,
+                lockState, stateChangeResult, message);
     }
 
     @Override
@@ -74,12 +63,12 @@ public class ParticipantIntermediaryApiImpl implements ParticipantIntermediaryAp
 
     @Override
     public Map<UUID, AutomationComposition> getAutomationCompositions() {
-        return PfUtils.mapMap(automationCompositionHandler.getAutomationCompositionMap(), AutomationComposition::new);
+        return PfUtils.mapMap(cacheProvider.getAutomationCompositions(), AutomationComposition::new);
     }
 
     @Override
     public void updateCompositionState(UUID compositionId, AcTypeState state, StateChangeResult stateChangeResult,
             String message) {
-        // Auto-generated method stub
+        // TODO Auto-generated method stub
     }
 }
diff --git a/participant/participant-intermediary/src/main/java/org/onap/policy/clamp/acm/participant/intermediary/handler/AutomationCompositionHandler.java b/participant/participant-intermediary/src/main/java/org/onap/policy/clamp/acm/participant/intermediary/handler/AutomationCompositionHandler.java
index 045677704..0fcd5ecc4 100644
--- a/participant/participant-intermediary/src/main/java/org/onap/policy/clamp/acm/participant/intermediary/handler/AutomationCompositionHandler.java
+++ b/participant/participant-intermediary/src/main/java/org/onap/policy/clamp/acm/participant/intermediary/handler/AutomationCompositionHandler.java
@@ -21,41 +21,24 @@
 
 package org.onap.policy.clamp.acm.participant.intermediary.handler;
 
-import java.util.ArrayList;
 import java.util.HashMap;
-import java.util.LinkedHashMap;
 import java.util.List;
-import java.util.Map;
 import java.util.UUID;
-import lombok.Getter;
 import org.onap.policy.clamp.acm.participant.intermediary.api.AutomationCompositionElementListener;
 import org.onap.policy.clamp.acm.participant.intermediary.comm.ParticipantMessagePublisher;
-import org.onap.policy.clamp.acm.participant.intermediary.parameters.ParticipantParameters;
 import org.onap.policy.clamp.models.acm.concepts.AcElementDeploy;
-import org.onap.policy.clamp.models.acm.concepts.AcElementDeployAck;
 import org.onap.policy.clamp.models.acm.concepts.AutomationComposition;
-import org.onap.policy.clamp.models.acm.concepts.AutomationCompositionElement;
-import org.onap.policy.clamp.models.acm.concepts.AutomationCompositionElementDefinition;
-import org.onap.policy.clamp.models.acm.concepts.AutomationCompositionElementInfo;
-import org.onap.policy.clamp.models.acm.concepts.AutomationCompositionInfo;
-import org.onap.policy.clamp.models.acm.concepts.DeployState;
-import org.onap.policy.clamp.models.acm.concepts.LockState;
 import org.onap.policy.clamp.models.acm.concepts.ParticipantDeploy;
-import org.onap.policy.clamp.models.acm.concepts.ParticipantState;
-import org.onap.policy.clamp.models.acm.concepts.ParticipantSupportedElementType;
 import org.onap.policy.clamp.models.acm.concepts.ParticipantUtils;
 import org.onap.policy.clamp.models.acm.messages.dmaap.participant.AutomationCompositionDeploy;
 import org.onap.policy.clamp.models.acm.messages.dmaap.participant.AutomationCompositionDeployAck;
 import org.onap.policy.clamp.models.acm.messages.dmaap.participant.AutomationCompositionStateChange;
 import org.onap.policy.clamp.models.acm.messages.dmaap.participant.ParticipantMessageType;
-import org.onap.policy.clamp.models.acm.messages.dmaap.participant.ParticipantStatus;
 import org.onap.policy.clamp.models.acm.messages.dmaap.participant.PropertiesUpdate;
 import org.onap.policy.clamp.models.acm.messages.rest.instantiation.DeployOrder;
 import org.onap.policy.clamp.models.acm.messages.rest.instantiation.LockOrder;
 import org.onap.policy.clamp.models.acm.persistence.provider.AcInstanceStateResolver;
 import org.onap.policy.models.base.PfModelException;
-import org.onap.policy.models.tosca.authorative.concepts.ToscaConceptIdentifier;
-import org.onap.policy.models.tosca.authorative.concepts.ToscaNodeTemplate;
 import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;
 import org.springframework.stereotype.Component;
@@ -67,125 +50,44 @@ import org.springframework.stereotype.Component;
 public class AutomationCompositionHandler {
     private static final Logger LOGGER = LoggerFactory.getLogger(AutomationCompositionHandler.class);
 
-    private final UUID participantId;
+    private final CacheProvider cacheProvider;
     private final ParticipantMessagePublisher publisher;
+    private final AutomationCompositionElementListener listener;
     private final AcInstanceStateResolver acInstanceStateResolver;
-    private final List<ParticipantSupportedElementType> supportedAcElementTypes;
-    private final List<AutomationCompositionElementListener> listeners = new ArrayList<>();
-
-    @Getter
-    private final Map<UUID, AutomationComposition> automationCompositionMap = new LinkedHashMap<>();
 
     /**
      * Constructor, set the participant ID and messageSender.
      *
-     * @param parameters the parameters of the participant
+     * @param cacheProvider the Cache Provider
      * @param publisher the ParticipantMessage Publisher
+     * @param listener the ThreadHandler Listener
      */
-    public AutomationCompositionHandler(ParticipantParameters parameters, ParticipantMessagePublisher publisher) {
-        this.participantId = parameters.getIntermediaryParameters().getParticipantId();
+    public AutomationCompositionHandler(CacheProvider cacheProvider, ParticipantMessagePublisher publisher,
+            AutomationCompositionElementListener listener) {
+        this.cacheProvider = cacheProvider;
         this.publisher = publisher;
+        this.listener = listener;
         this.acInstanceStateResolver = new AcInstanceStateResolver();
-        this.supportedAcElementTypes = parameters.getIntermediaryParameters().getParticipantSupportedElementTypes();
-    }
-
-    public void registerAutomationCompositionElementListener(AutomationCompositionElementListener listener) {
-        listeners.add(listener);
-    }
-
-    /**
-     * Handle a automation composition element state change message.
-     *
-     * @param automationCompositionId the automationComposition Id
-     * @param id the automationComposition UUID
-     * @param deployState the DeployState state
-     * @param lockState the LockState state
-     */
-    public void updateAutomationCompositionElementState(UUID automationCompositionId, UUID id, DeployState deployState,
-            LockState lockState, String message) {
-
-        if (automationCompositionId == null || id == null) {
-            LOGGER.error("Cannot update Automation composition element state, id is null");
-            return;
-        }
-
-        if ((deployState != null && lockState != null) || (deployState == null && lockState == null)) {
-            LOGGER.error("state error {} and {} cannot be handled", deployState, lockState);
-            return;
-        }
-
-        var automationComposition = automationCompositionMap.get(automationCompositionId);
-        if (automationComposition == null) {
-            LOGGER.error("Cannot update Automation composition element state, Automation composition id {} not present",
-                    automationComposition);
-            return;
-        }
-
-        var element = automationComposition.getElements().get(id);
-        if (element == null) {
-            var msg = "Cannot update Automation composition element state, AC Element id {} not present";
-            LOGGER.error(msg, automationComposition);
-            return;
-        }
-
-        if (deployState != null) {
-            element.setDeployState(deployState);
-            element.setLockState(
-                    DeployState.DEPLOYED.equals(element.getDeployState()) ? LockState.LOCKED : LockState.NONE);
-            var checkOpt = automationComposition.getElements().values().stream()
-                    .filter(acElement -> !deployState.equals(acElement.getDeployState())).findAny();
-            if (checkOpt.isEmpty()) {
-                automationComposition.setDeployState(deployState);
-                automationComposition.setLockState(element.getLockState());
-
-                if (DeployState.DELETED.equals(deployState)) {
-                    automationCompositionMap.remove(automationComposition.getInstanceId());
-                }
-            }
-        }
-        if (lockState != null) {
-            element.setLockState(lockState);
-            var checkOpt = automationComposition.getElements().values().stream()
-                    .filter(acElement -> !lockState.equals(acElement.getLockState())).findAny();
-            if (checkOpt.isEmpty()) {
-                automationComposition.setLockState(lockState);
-            }
-        }
-
-        var automationCompositionStateChangeAck =
-                new AutomationCompositionDeployAck(ParticipantMessageType.AUTOMATION_COMPOSITION_STATECHANGE_ACK);
-        automationCompositionStateChangeAck.setParticipantId(participantId);
-        automationCompositionStateChangeAck.setMessage(message);
-        automationCompositionStateChangeAck.setAutomationCompositionId(automationCompositionId);
-        automationCompositionStateChangeAck.getAutomationCompositionResultMap().put(element.getId(),
-                new AcElementDeployAck(element.getDeployState(), element.getLockState(), element.getOperationalState(),
-                        element.getUseState(), element.getOutProperties(), true,
-                        "Automation composition element {} state changed to {}\", id, newState)"));
-        LOGGER.debug("Automation composition element {} state changed to {}", id, deployState);
-        automationCompositionStateChangeAck.setResult(true);
-        publisher.sendAutomationCompositionAck(automationCompositionStateChangeAck);
     }
 
     /**
      * Handle a automation composition state change message.
      *
      * @param stateChangeMsg the state change message
-     * @param acElementDefinitions the list of AutomationCompositionElementDefinition
      */
-    public void handleAutomationCompositionStateChange(AutomationCompositionStateChange stateChangeMsg,
-            List<AutomationCompositionElementDefinition> acElementDefinitions) {
+    public void handleAutomationCompositionStateChange(AutomationCompositionStateChange stateChangeMsg) {
         if (stateChangeMsg.getAutomationCompositionId() == null) {
             return;
         }
 
-        var automationComposition = automationCompositionMap.get(stateChangeMsg.getAutomationCompositionId());
+        var automationComposition = cacheProvider.getAutomationComposition(stateChangeMsg.getAutomationCompositionId());
 
         if (automationComposition == null) {
             var automationCompositionAck =
                     new AutomationCompositionDeployAck(ParticipantMessageType.AUTOMATION_COMPOSITION_STATECHANGE_ACK);
-            automationCompositionAck.setParticipantId(participantId);
+            automationCompositionAck.setParticipantId(cacheProvider.getParticipantId());
             automationCompositionAck.setMessage("Automation composition " + stateChangeMsg.getAutomationCompositionId()
-                    + " does not use this participant " + participantId);
+                    + " does not use this participant " + cacheProvider.getParticipantId());
             automationCompositionAck.setResult(false);
             automationCompositionAck.setResponseTo(stateChangeMsg.getMessageId());
             automationCompositionAck.setAutomationCompositionId(stateChangeMsg.getAutomationCompositionId());
@@ -204,17 +106,17 @@ public class AutomationCompositionHandler {
 
         if (DeployOrder.NONE.equals(stateChangeMsg.getDeployOrderedState())) {
             handleLockOrderState(automationComposition, stateChangeMsg.getLockOrderedState(),
-                    stateChangeMsg.getStartPhase(), acElementDefinitions);
+                    stateChangeMsg.getStartPhase());
         } else {
             handleDeployOrderState(automationComposition, stateChangeMsg.getDeployOrderedState(),
-                    stateChangeMsg.getStartPhase(), acElementDefinitions);
+                    stateChangeMsg.getStartPhase());
         }
     }
 
     private boolean checkConsistantOrderState(AutomationComposition automationComposition, DeployOrder deployOrder,
             LockOrder lockOrder) {
         if (DeployOrder.UPDATE.equals(deployOrder)) {
-            return true;
+            return false;
         }
         return acInstanceStateResolver.resolve(deployOrder, lockOrder, automationComposition.getDeployState(),
                 automationComposition.getLockState(), automationComposition.getStateChangeResult()) != null;
@@ -226,21 +128,20 @@ public class AutomationCompositionHandler {
      * @param automationComposition participant response
      * @param orderedState automation composition ordered state
      * @param startPhaseMsg startPhase from message
-     * @param acElementDefinitions the list of AutomationCompositionElementDefinition
      */
     private void handleDeployOrderState(final AutomationComposition automationComposition, DeployOrder orderedState,
-            Integer startPhaseMsg, List<AutomationCompositionElementDefinition> acElementDefinitions) {
+            Integer startPhaseMsg) {
 
         switch (orderedState) {
             case UNDEPLOY:
-                handleUndeployState(automationComposition, startPhaseMsg, acElementDefinitions);
+                handleUndeployState(automationComposition, startPhaseMsg);
                 break;
             case DELETE:
-                handleDeleteState(automationComposition, startPhaseMsg, acElementDefinitions);
+                handleDeleteState(automationComposition, startPhaseMsg);
                 break;
 
             default:
-                LOGGER.debug("StateChange message has no state, state is null {}", automationComposition.getKey());
+                LOGGER.error("StateChange message has no state, state is null {}", automationComposition.getKey());
                 break;
         }
     }
@@ -251,20 +152,19 @@ public class AutomationCompositionHandler {
      * @param automationComposition participant response
      * @param orderedState automation composition ordered state
      * @param startPhaseMsg startPhase from message
-     * @param acElementDefinitions the list of AutomationCompositionElementDefinition
      */
     private void handleLockOrderState(final AutomationComposition automationComposition, LockOrder orderedState,
-            Integer startPhaseMsg, List<AutomationCompositionElementDefinition> acElementDefinitions) {
+            Integer startPhaseMsg) {
 
         switch (orderedState) {
             case LOCK:
-                handleLockState(automationComposition, startPhaseMsg, acElementDefinitions);
+                handleLockState(automationComposition, startPhaseMsg);
                 break;
             case UNLOCK:
-                handleUnlockState(automationComposition, startPhaseMsg, acElementDefinitions);
+                handleUnlockState(automationComposition, startPhaseMsg);
                 break;
             default:
-                LOGGER.debug("StateChange message has no state, state is null {}", automationComposition.getKey());
+                LOGGER.error("StateChange message has no state, state is null {}", automationComposition.getKey());
                 break;
         }
     }
@@ -273,10 +173,8 @@ public class AutomationCompositionHandler {
      * Handle a automation composition properties update message.
      *
      * @param updateMsg the properties update message
-     * @param acElementDefinitions the list of AutomationCompositionElementDefinition
      */
-    public void handleAcPropertyUpdate(PropertiesUpdate updateMsg,
-            List<AutomationCompositionElementDefinition> acElementDefinitions) {
+    public void handleAcPropertyUpdate(PropertiesUpdate updateMsg) {
 
         if (updateMsg.getParticipantUpdatesList().isEmpty()) {
             LOGGER.warn("No AutomationCompositionElement updates in message {}",
@@ -285,12 +183,11 @@ public class AutomationCompositionHandler {
         }
 
         for (var participantDeploy : updateMsg.getParticipantUpdatesList()) {
-            if (participantId.equals(participantDeploy.getParticipantId())) {
+            if (cacheProvider.getParticipantId().equals(participantDeploy.getParticipantId())) {
 
-                initializeDeploy(updateMsg.getMessageId(), updateMsg.getAutomationCompositionId(), participantDeploy,
-                        DeployState.UPDATING);
+                updateExistingElementsOnThisParticipant(updateMsg.getAutomationCompositionId(), participantDeploy);
 
-                callParticipantUpdateProperty(participantDeploy.getAcElementList(), acElementDefinitions,
+                callParticipantUpdateProperty(participantDeploy.getAcElementList(),
                         updateMsg.getAutomationCompositionId());
             }
         }
@@ -299,128 +196,60 @@ public class AutomationCompositionHandler {
     /**
      * Handle a automation composition Deploy message.
      *
-     * @param updateMsg the Deploy message
-     * @param acElementDefinitions the list of AutomationCompositionElementDefinition
+     * @param deployMsg the Deploy message
      */
-    public void handleAutomationCompositionDeploy(AutomationCompositionDeploy updateMsg,
-            List<AutomationCompositionElementDefinition> acElementDefinitions) {
+    public void handleAutomationCompositionDeploy(AutomationCompositionDeploy deployMsg) {
 
-        if (updateMsg.getParticipantUpdatesList().isEmpty()) {
-            LOGGER.warn("No AutomationCompositionElement updates in message {}",
-                    updateMsg.getAutomationCompositionId());
+        if (deployMsg.getParticipantUpdatesList().isEmpty()) {
+            LOGGER.warn("No AutomationCompositionElement deploy in message {}",
+                    deployMsg.getAutomationCompositionId());
             return;
         }
 
-        for (var participantDeploy : updateMsg.getParticipantUpdatesList()) {
-            if (participantId.equals(participantDeploy.getParticipantId())) {
-                if (updateMsg.isFirstStartPhase()) {
-                    initializeDeploy(updateMsg.getMessageId(), updateMsg.getAutomationCompositionId(),
-                            participantDeploy, DeployState.DEPLOYING);
+        for (var participantDeploy : deployMsg.getParticipantUpdatesList()) {
+            if (cacheProvider.getParticipantId().equals(participantDeploy.getParticipantId())) {
+                if (deployMsg.isFirstStartPhase()) {
+                    cacheProvider.initializeAutomationComposition(deployMsg.getCompositionId(),
+                            deployMsg.getAutomationCompositionId(), participantDeploy);
                 }
-                callParticipantDeploy(participantDeploy.getAcElementList(), acElementDefinitions,
-                        updateMsg.getStartPhase(), updateMsg.getAutomationCompositionId());
+                callParticipanDeploy(participantDeploy.getAcElementList(), deployMsg.getStartPhase(),
+                        deployMsg.getAutomationCompositionId());
             }
         }
     }
 
-    private void initializeDeploy(UUID messageId, UUID instanceId, ParticipantDeploy participantDeploy,
-            DeployState deployState) {
-        if (automationCompositionMap.containsKey(instanceId)) {
-            updateExistingElementsOnThisParticipant(instanceId, participantDeploy, deployState);
-        } else {
-            var automationComposition = new AutomationComposition();
-            automationComposition.setInstanceId(instanceId);
-            var acElements = storeElementsOnThisParticipant(participantDeploy, deployState);
-            automationComposition.setElements(prepareAcElementMap(acElements));
-            automationCompositionMap.put(instanceId, automationComposition);
-        }
-    }
-
-    private void callParticipantDeploy(List<AcElementDeploy> acElements,
-            List<AutomationCompositionElementDefinition> acElementDefinitions, Integer startPhaseMsg,
-            UUID automationCompositionId) {
+    private void callParticipanDeploy(List<AcElementDeploy> acElements, Integer startPhaseMsg, UUID instanceId) {
         try {
             for (var element : acElements) {
-                var acElementNodeTemplate = getAcElementNodeTemplate(acElementDefinitions, element.getDefinition());
-                if (acElementNodeTemplate != null) {
-                    int startPhase = ParticipantUtils.findStartPhase(acElementNodeTemplate.getProperties());
-                    if (startPhaseMsg.equals(startPhase)) {
-                        for (var acElementListener : listeners) {
-                            var map = new HashMap<>(acElementNodeTemplate.getProperties());
-                            map.putAll(element.getProperties());
-                            acElementListener.deploy(automationCompositionId, element, map);
-                        }
-                    }
+                var commonProperties = cacheProvider.getCommonProperties(instanceId, element.getId());
+                int startPhase = ParticipantUtils.findStartPhase(commonProperties);
+                if (startPhaseMsg.equals(startPhase)) {
+                    var map = new HashMap<>(commonProperties);
+                    map.putAll(element.getProperties());
+                    listener.deploy(instanceId, element, map);
                 }
             }
         } catch (PfModelException e) {
-            LOGGER.debug("Automation composition element update failed {}", automationCompositionId);
+            LOGGER.debug("Automation composition element Deploy failed {}", instanceId);
         }
-
     }
 
-    private void callParticipantUpdateProperty(List<AcElementDeploy> acElements,
-            List<AutomationCompositionElementDefinition> acElementDefinitions, UUID automationCompositionId) {
+    private void callParticipantUpdateProperty(List<AcElementDeploy> acElements, UUID instanceId) {
         try {
             for (var element : acElements) {
-                var acElementNodeTemplate = getAcElementNodeTemplate(acElementDefinitions, element.getDefinition());
-                if (acElementNodeTemplate != null) {
-                    for (var acElementListener : listeners) {
-                        var map = new HashMap<>(acElementNodeTemplate.getProperties());
-                        map.putAll(element.getProperties());
-                        acElementListener.update(automationCompositionId, element, map);
-                    }
-                }
+                listener.update(instanceId, element, element.getProperties());
             }
         } catch (PfModelException e) {
-            LOGGER.error("Automation composition element update failed for {} {}", automationCompositionId, e);
+            LOGGER.debug("Automation composition element update failed {}", instanceId);
         }
-
-    }
-
-    private ToscaNodeTemplate getAcElementNodeTemplate(
-            List<AutomationCompositionElementDefinition> acElementDefinitions, ToscaConceptIdentifier acElementDefId) {
-
-        for (var acElementDefinition : acElementDefinitions) {
-            if (acElementDefId.getName().contains(acElementDefinition.getAcElementDefinitionId().getName())) {
-                return acElementDefinition.getAutomationCompositionElementToscaNodeTemplate();
-            }
-        }
-        return null;
     }
 
-    private List<AutomationCompositionElement> storeElementsOnThisParticipant(ParticipantDeploy participantDeploy,
-            DeployState deployState) {
-        List<AutomationCompositionElement> acElementList = new ArrayList<>();
+    private void updateExistingElementsOnThisParticipant(UUID instanceId, ParticipantDeploy participantDeploy) {
+        var acElementList = cacheProvider.getAutomationComposition(instanceId).getElements();
         for (var element : participantDeploy.getAcElementList()) {
-            var acElement = new AutomationCompositionElement();
-            acElement.setId(element.getId());
-            acElement.setParticipantId(participantDeploy.getParticipantId());
-            acElement.setDefinition(element.getDefinition());
-            acElement.setDeployState(deployState);
-            acElement.setLockState(LockState.NONE);
-            acElementList.add(acElement);
+            var acElement = acElementList.get(element.getId());
+            acElement.getProperties().putAll(element.getProperties());
         }
-        return acElementList;
-    }
-
-    private void updateExistingElementsOnThisParticipant(UUID instanceId, ParticipantDeploy participantDeploy,
-            DeployState deployState) {
-
-        Map<UUID, AutomationCompositionElement> elementList = automationCompositionMap.get(instanceId).getElements();
-        for (var element : participantDeploy.getAcElementList()) {
-            automationCompositionMap.get(instanceId).getElements().get(element.getId()).getProperties()
-                    .putAll(element.getProperties());
-            automationCompositionMap.get(instanceId).getElements().get(element.getId()).setDeployState(deployState);
-        }
-    }
-
-    private Map<UUID, AutomationCompositionElement> prepareAcElementMap(List<AutomationCompositionElement> acElements) {
-        Map<UUID, AutomationCompositionElement> acElementMap = new LinkedHashMap<>();
-        for (var element : acElements) {
-            acElementMap.put(element.getId(), element);
-        }
-        return acElementMap;
     }
 
     /**
@@ -428,214 +257,72 @@ public class AutomationCompositionHandler {
      *
      * @param automationComposition participant response
      * @param startPhaseMsg startPhase from message
-     * @param acElementDefinitions the list of AutomationCompositionElementDefinition
-     */
-    private void handleUndeployState(final AutomationComposition automationComposition, Integer startPhaseMsg,
-            List<AutomationCompositionElementDefinition> acElementDefinitions) {
-
-        automationComposition.getElements().values().stream()
-                .forEach(acElement -> automationCompositionElementUndeploy(automationComposition.getInstanceId(),
-                        acElement, startPhaseMsg, acElementDefinitions));
-    }
-
-    private void handleDeleteState(final AutomationComposition automationComposition, Integer startPhaseMsg,
-            List<AutomationCompositionElementDefinition> acElementDefinitions) {
-
-        automationComposition.getElements().values().stream()
-                .forEach(acElement -> automationCompositionElementDelete(automationComposition.getInstanceId(),
-                        acElement, startPhaseMsg, acElementDefinitions));
-    }
-
-    /**
-     * Method to handle when the new state from participant is PASSIVE state.
-     *
-     * @param automationComposition participant response
-     * @param startPhaseMsg startPhase from message
-     * @param acElementDefinitions the list of AutomationCompositionElementDefinition
-     */
-    private void handleLockState(final AutomationComposition automationComposition, Integer startPhaseMsg,
-            List<AutomationCompositionElementDefinition> acElementDefinitions) {
-        automationComposition.getElements().values().stream()
-                .forEach(acElement -> automationCompositionElementLock(automationComposition.getInstanceId(), acElement,
-                        startPhaseMsg, acElementDefinitions));
-    }
-
-    /**
-     * Method to handle when the new state from participant is RUNNING state.
-     *
-     * @param automationComposition participant response
-     * @param startPhaseMsg startPhase from message
-     * @param acElementDefinitions the list of AutomationCompositionElementDefinition
      */
-    private void handleUnlockState(final AutomationComposition automationComposition, Integer startPhaseMsg,
-            List<AutomationCompositionElementDefinition> acElementDefinitions) {
-        automationComposition.getElements().values().stream()
-                .forEach(acElement -> automationCompositionElementUnlock(automationComposition.getInstanceId(),
-                        acElement, startPhaseMsg, acElementDefinitions));
-    }
-
-    private void automationCompositionElementLock(UUID instanceId, AutomationCompositionElement acElement,
-            Integer startPhaseMsg, List<AutomationCompositionElementDefinition> acElementDefinitions) {
-        var acElementNodeTemplate = getAcElementNodeTemplate(acElementDefinitions, acElement.getDefinition());
-        if (acElementNodeTemplate != null) {
-            int startPhase = ParticipantUtils.findStartPhase(acElementNodeTemplate.getProperties());
-            if (startPhaseMsg.equals(startPhase)) {
-                for (var acElementListener : listeners) {
-                    try {
-                        acElementListener.lock(instanceId, acElement.getId());
-                    } catch (PfModelException e) {
-                        LOGGER.error("Automation composition element lock failed {}", instanceId);
-                    }
-                }
-            }
-        }
-    }
-
-    private void automationCompositionElementUnlock(UUID instanceId, AutomationCompositionElement acElement,
-            Integer startPhaseMsg, List<AutomationCompositionElementDefinition> acElementDefinitions) {
-        var acElementNodeTemplate = getAcElementNodeTemplate(acElementDefinitions, acElement.getDefinition());
-        if (acElementNodeTemplate != null) {
-            int startPhase = ParticipantUtils.findStartPhase(acElementNodeTemplate.getProperties());
-            if (startPhaseMsg.equals(startPhase)) {
-                for (var acElementListener : listeners) {
-                    try {
-                        acElementListener.unlock(instanceId, acElement.getId());
-                    } catch (PfModelException e) {
-                        LOGGER.error("Automation composition element unlock failed {}", instanceId);
-                    }
+    private void handleUndeployState(final AutomationComposition automationComposition, Integer startPhaseMsg) {
+        try {
+            for (var acElement : automationComposition.getElements().values()) {
+                int startPhase = ParticipantUtils.findStartPhase(
+                        cacheProvider.getCommonProperties(automationComposition.getInstanceId(), acElement.getId()));
+                if (startPhaseMsg.equals(startPhase)) {
+                    listener.undeploy(automationComposition.getInstanceId(), acElement.getId());
                 }
             }
+        } catch (PfModelException e) {
+            LOGGER.debug("Automation composition element Undeploy failed {}", automationComposition.getInstanceId());
         }
     }
 
-    private void automationCompositionElementUndeploy(UUID instanceId, AutomationCompositionElement acElement,
-            Integer startPhaseMsg, List<AutomationCompositionElementDefinition> acElementDefinitions) {
-        var acElementNodeTemplate = getAcElementNodeTemplate(acElementDefinitions, acElement.getDefinition());
-        if (acElementNodeTemplate != null) {
-            int startPhase = ParticipantUtils.findStartPhase(acElementNodeTemplate.getProperties());
-            if (startPhaseMsg.equals(startPhase)) {
-                undeployInstanceElements(instanceId, acElement.getId());
-            }
-        }
-    }
-
-    private void automationCompositionElementDelete(UUID instanceId, AutomationCompositionElement acElement,
-            Integer startPhaseMsg, List<AutomationCompositionElementDefinition> acElementDefinitions) {
-        var acElementNodeTemplate = getAcElementNodeTemplate(acElementDefinitions, acElement.getDefinition());
-        if (acElementNodeTemplate != null) {
-            int startPhase = ParticipantUtils.findStartPhase(acElementNodeTemplate.getProperties());
-            if (startPhaseMsg.equals(startPhase)) {
-                for (var acElementListener : listeners) {
-                    try {
-                        acElementListener.delete(instanceId, acElement.getId());
-                    } catch (PfModelException e) {
-                        LOGGER.error("Automation composition element unlock failed {}", instanceId);
-                    }
+    private void handleDeleteState(final AutomationComposition automationComposition, Integer startPhaseMsg) {
+        try {
+            for (var acElement : automationComposition.getElements().values()) {
+                int startPhase = ParticipantUtils.findStartPhase(
+                        cacheProvider.getCommonProperties(automationComposition.getInstanceId(), acElement.getId()));
+                if (startPhaseMsg.equals(startPhase)) {
+                    listener.delete(automationComposition.getInstanceId(), acElement.getId());
                 }
             }
+        } catch (PfModelException e) {
+            LOGGER.debug("Automation composition element Delete failed {}", automationComposition.getInstanceId());
         }
     }
 
     /**
-     * Undeploy Instance Elements On Participant.
-     */
-    public void undeployInstances() {
-        automationCompositionMap.values().forEach(this::undeployInstance);
-    }
-
-    private void undeployInstance(AutomationComposition automationComposition) {
-        automationComposition.getElements().values().forEach(element -> {
-            if (element.getParticipantId().equals(participantId)) {
-                undeployInstanceElements(automationComposition.getInstanceId(), element.getId());
-            }
-        });
-    }
-
-    private void undeployInstanceElements(UUID instanceId, UUID elementId) {
-        for (var acElementListener : listeners) {
-            try {
-                acElementListener.undeploy(instanceId, elementId);
-            } catch (PfModelException e) {
-                LOGGER.error("Automation composition element update failed {}", instanceId);
-            }
-        }
-    }
-
-    /**
-     * Send Ac Element Info.
+     * Method to handle when the new state from participant is PASSIVE state.
      *
-     * @param automationCompositionId the automationComposition Id
-     * @param elementId the automationComposition Element id
-     * @param useState the use State
-     * @param operationalState the operational State
-     * @param outProperties the output Properties Map
+     * @param automationComposition participant response
+     * @param startPhaseMsg startPhase from message
      */
-    public void sendAcElementInfo(UUID automationCompositionId, UUID elementId, String useState,
-            String operationalState, Map<String, Object> outProperties) {
-
-        if (automationCompositionId == null || elementId == null) {
-            LOGGER.error("Cannot update Automation composition element state, id is null");
-            return;
-        }
-
-        var automationComposition = automationCompositionMap.get(automationCompositionId);
-        if (automationComposition == null) {
-            LOGGER.error("Cannot update Automation composition element state, Automation composition id {} not present",
-                    automationComposition);
-            return;
-        }
-
-        var element = automationComposition.getElements().get(elementId);
-        if (element == null) {
-            var msg = "Cannot update Automation composition element state, AC Element id {} not present";
-            LOGGER.error(msg, automationComposition);
-            return;
+    private void handleLockState(final AutomationComposition automationComposition, Integer startPhaseMsg) {
+        try {
+            for (var acElement : automationComposition.getElements().values()) {
+                int startPhase = ParticipantUtils.findStartPhase(
+                        cacheProvider.getCommonProperties(automationComposition.getInstanceId(), acElement.getId()));
+                if (startPhaseMsg.equals(startPhase)) {
+                    listener.lock(automationComposition.getInstanceId(), acElement.getId());
+                }
+            }
+        } catch (PfModelException e) {
+            LOGGER.debug("Automation composition element Lock failed {}", automationComposition.getInstanceId());
         }
-        element.setOperationalState(operationalState);
-        element.setUseState(useState);
-        element.setOutProperties(outProperties);
-
-        var statusMsg = new ParticipantStatus();
-        statusMsg.setParticipantId(participantId);
-        statusMsg.setState(ParticipantState.ON_LINE);
-        statusMsg.setParticipantSupportedElementType(new ArrayList<>(supportedAcElementTypes));
-        var acInfo = new AutomationCompositionInfo();
-        acInfo.setAutomationCompositionId(automationCompositionId);
-        acInfo.setDeployState(automationComposition.getDeployState());
-        acInfo.setLockState(automationComposition.getLockState());
-        acInfo.setElements(List.of(getAutomationCompositionElementInfo(element)));
-        statusMsg.setAutomationCompositionInfoList(List.of(acInfo));
-        publisher.sendParticipantStatus(statusMsg);
     }
 
     /**
-     * get AutomationComposition Info List.
+     * Method to handle when the new state from participant is RUNNING state.
      *
-     * @return list of AutomationCompositionInfo
+     * @param automationComposition participant response
+     * @param startPhaseMsg startPhase from message
      */
-    public List<AutomationCompositionInfo> getAutomationCompositionInfoList() {
-        List<AutomationCompositionInfo> automationCompositionInfoList = new ArrayList<>();
-        for (var entry : automationCompositionMap.entrySet()) {
-            var acInfo = new AutomationCompositionInfo();
-            acInfo.setAutomationCompositionId(entry.getKey());
-            acInfo.setDeployState(entry.getValue().getDeployState());
-            acInfo.setLockState(entry.getValue().getLockState());
-            for (var element : entry.getValue().getElements().values()) {
-                acInfo.getElements().add(getAutomationCompositionElementInfo(element));
+    private void handleUnlockState(final AutomationComposition automationComposition, Integer startPhaseMsg) {
+        try {
+            for (var acElement : automationComposition.getElements().values()) {
+                int startPhase = ParticipantUtils.findStartPhase(
+                        cacheProvider.getCommonProperties(automationComposition.getInstanceId(), acElement.getId()));
+                if (startPhaseMsg.equals(startPhase)) {
+                    listener.unlock(automationComposition.getInstanceId(), acElement.getId());
+                }
             }
-            automationCompositionInfoList.add(acInfo);
+        } catch (PfModelException e) {
+            LOGGER.debug("Automation composition element Unlock failed {}", automationComposition.getInstanceId());
         }
-        return automationCompositionInfoList;
-    }
-
-    private AutomationCompositionElementInfo getAutomationCompositionElementInfo(AutomationCompositionElement element) {
-        var elementInfo = new AutomationCompositionElementInfo();
-        elementInfo.setAutomationCompositionElementId(element.getId());
-        elementInfo.setDeployState(element.getDeployState());
-        elementInfo.setLockState(element.getLockState());
-        elementInfo.setOperationalState(element.getOperationalState());
-        elementInfo.setUseState(element.getUseState());
-        elementInfo.setOutProperties(element.getOutProperties());
-        return elementInfo;
     }
 }
diff --git a/participant/participant-intermediary/src/main/java/org/onap/policy/clamp/acm/participant/intermediary/handler/ParticipantHandler.java b/participant/participant-intermediary/src/main/java/org/onap/policy/clamp/acm/participant/intermediary/handler/ParticipantHandler.java
index 9e1216cec..1e5caad15 100644
--- a/participant/participant-intermediary/src/main/java/org/onap/policy/clamp/acm/participant/intermediary/handler/ParticipantHandler.java
+++ b/participant/participant-intermediary/src/main/java/org/onap/policy/clamp/acm/participant/intermediary/handler/ParticipantHandler.java
@@ -24,17 +24,14 @@ package org.onap.policy.clamp.acm.participant.intermediary.handler;
 
 import io.micrometer.core.annotation.Timed;
 import java.util.ArrayList;
-import java.util.HashMap;
 import java.util.List;
-import java.util.Map;
 import java.util.UUID;
-import lombok.Getter;
+import lombok.RequiredArgsConstructor;
 import org.onap.policy.clamp.acm.participant.intermediary.comm.ParticipantMessagePublisher;
-import org.onap.policy.clamp.acm.participant.intermediary.parameters.ParticipantParameters;
 import org.onap.policy.clamp.models.acm.concepts.AutomationCompositionElementDefinition;
+import org.onap.policy.clamp.models.acm.concepts.AutomationCompositionInfo;
 import org.onap.policy.clamp.models.acm.concepts.ParticipantDefinition;
 import org.onap.policy.clamp.models.acm.concepts.ParticipantState;
-import org.onap.policy.clamp.models.acm.concepts.ParticipantSupportedElementType;
 import org.onap.policy.clamp.models.acm.messages.dmaap.participant.AutomationCompositionDeploy;
 import org.onap.policy.clamp.models.acm.messages.dmaap.participant.AutomationCompositionStateChange;
 import org.onap.policy.clamp.models.acm.messages.dmaap.participant.ParticipantAckMessage;
@@ -56,33 +53,14 @@ import org.springframework.stereotype.Component;
  * This class is responsible for managing the state of a participant.
  */
 @Component
+@RequiredArgsConstructor
 public class ParticipantHandler {
     private static final Logger LOGGER = LoggerFactory.getLogger(ParticipantHandler.class);
 
-    @Getter
-    private final UUID participantId;
-
     private final AutomationCompositionHandler automationCompositionHandler;
+    private final AutomationCompositionOutHandler automationCompositionOutHandler;
     private final ParticipantMessagePublisher publisher;
-
-    private final Map<UUID, List<AutomationCompositionElementDefinition>> acElementDefsMap = new HashMap<>();
-
-    private final List<ParticipantSupportedElementType> supportedAcElementTypes;
-
-    /**
-     * Constructor, set the participant ID and sender.
-     *
-     * @param parameters the parameters of the participant
-     * @param publisher the publisher for sending responses to messages
-     * @param automationCompositionHandler the publisher for sending responses to messages
-     */
-    public ParticipantHandler(ParticipantParameters parameters, ParticipantMessagePublisher publisher,
-            AutomationCompositionHandler automationCompositionHandler) {
-        this.participantId = parameters.getIntermediaryParameters().getParticipantId();
-        this.publisher = publisher;
-        this.automationCompositionHandler = automationCompositionHandler;
-        this.supportedAcElementTypes = parameters.getIntermediaryParameters().getParticipantSupportedElementTypes();
-    }
+    private final CacheProvider cacheProvider;
 
     /**
      * Method which handles a participant health check event from clamp.
@@ -104,8 +82,7 @@ public class ParticipantHandler {
             value = "listener.automation_composition_update",
             description = "AUTOMATION_COMPOSITION_UPDATE messages received")
     public void handleAutomationCompositionDeploy(AutomationCompositionDeploy updateMsg) {
-        automationCompositionHandler.handleAutomationCompositionDeploy(updateMsg,
-                acElementDefsMap.get(updateMsg.getCompositionId()));
+        automationCompositionHandler.handleAutomationCompositionDeploy(updateMsg);
     }
 
     /**
@@ -117,8 +94,7 @@ public class ParticipantHandler {
             value = "listener.automation_composition_state_change",
             description = "AUTOMATION_COMPOSITION_STATE_CHANGE messages received")
     public void handleAutomationCompositionStateChange(AutomationCompositionStateChange stateChangeMsg) {
-        automationCompositionHandler.handleAutomationCompositionStateChange(stateChangeMsg,
-                acElementDefsMap.get(stateChangeMsg.getCompositionId()));
+        automationCompositionHandler.handleAutomationCompositionStateChange(stateChangeMsg);
     }
 
     /**
@@ -126,12 +102,9 @@ public class ParticipantHandler {
      *
      * @param propertyUpdateMsg the property update message
      */
-    @Timed(
-            value = "listener.properties_update",
-            description = "PROPERTIES_UPDATE message received")
+    @Timed(value = "listener.properties_update", description = "PROPERTIES_UPDATE message received")
     public void handleAcPropertyUpdate(PropertiesUpdate propertyUpdateMsg) {
-        automationCompositionHandler.handleAcPropertyUpdate(propertyUpdateMsg,
-                acElementDefsMap.get(propertyUpdateMsg.getCompositionId()));
+        automationCompositionHandler.handleAcPropertyUpdate(propertyUpdateMsg);
     }
 
     /**
@@ -141,7 +114,7 @@ public class ParticipantHandler {
      * @return true if it applies, false otherwise
      */
     public boolean appliesTo(ParticipantMessage participantMsg) {
-        return participantMsg.appliesTo(participantId);
+        return participantMsg.appliesTo(cacheProvider.getParticipantId());
     }
 
     /**
@@ -151,7 +124,7 @@ public class ParticipantHandler {
      * @return true if it applies, false otherwise
      */
     public boolean appliesTo(ParticipantAckMessage participantMsg) {
-        return participantMsg.appliesTo(participantId);
+        return participantMsg.appliesTo(cacheProvider.getParticipantId());
     }
 
     /**
@@ -159,8 +132,8 @@ public class ParticipantHandler {
      */
     public void sendParticipantRegister() {
         var participantRegister = new ParticipantRegister();
-        participantRegister.setParticipantId(participantId);
-        participantRegister.setParticipantSupportedElementType(supportedAcElementTypes);
+        participantRegister.setParticipantId(cacheProvider.getParticipantId());
+        participantRegister.setParticipantSupportedElementType(cacheProvider.getSupportedAcElementTypes());
 
         publisher.sendParticipantRegister(participantRegister);
     }
@@ -182,9 +155,8 @@ public class ParticipantHandler {
      */
     public void sendParticipantDeregister() {
         var participantDeregister = new ParticipantDeregister();
-        participantDeregister.setParticipantId(participantId);
+        participantDeregister.setParticipantId(cacheProvider.getParticipantId());
         publisher.sendParticipantDeregister(participantDeregister);
-        automationCompositionHandler.undeployInstances();
     }
 
     /**
@@ -205,22 +177,20 @@ public class ParticipantHandler {
      */
     @Timed(value = "listener.participant_prime", description = "PARTICIPANT_PRIME messages received")
     public void handleParticipantPrime(ParticipantPrime participantPrimeMsg) {
-        LOGGER.debug("ParticipantPrime message received for participantId {}",
-                participantPrimeMsg.getParticipantId());
+        LOGGER.debug("ParticipantPrime message received for participantId {}", participantPrimeMsg.getParticipantId());
 
-        acElementDefsMap.putIfAbsent(participantPrimeMsg.getCompositionId(), new ArrayList<>());
         if (!participantPrimeMsg.getParticipantDefinitionUpdates().isEmpty()) {
-            // This message is to commission the automation composition
+            // prime
+            List<AutomationCompositionElementDefinition> list = new ArrayList<>();
             for (var participantDefinition : participantPrimeMsg.getParticipantDefinitionUpdates()) {
-                if (participantDefinition.getParticipantId().equals(participantId)) {
-                    acElementDefsMap.get(participantPrimeMsg.getCompositionId())
-                            .addAll(participantDefinition.getAutomationCompositionElementDefinitionList());
-                    break;
+                if (participantDefinition.getParticipantId().equals(cacheProvider.getParticipantId())) {
+                    list.addAll(participantDefinition.getAutomationCompositionElementDefinitionList());
                 }
             }
+            cacheProvider.addElementDefinition(participantPrimeMsg.getCompositionId(), list);
         } else {
-            // This message is to decommission the automation composition
-            acElementDefsMap.get(participantPrimeMsg.getCompositionId()).clear();
+            // deprime
+            cacheProvider.removeElementDefinition(participantPrimeMsg.getCompositionId());
         }
         sendParticipantPrimeAck(participantPrimeMsg.getMessageId(), participantPrimeMsg.getCompositionId());
     }
@@ -234,7 +204,7 @@ public class ParticipantHandler {
         participantPrimeAck.setCompositionId(compositionId);
         participantPrimeAck.setMessage("Participant Prime Ack message");
         participantPrimeAck.setResult(true);
-        participantPrimeAck.setParticipantId(participantId);
+        participantPrimeAck.setParticipantId(cacheProvider.getParticipantId());
         participantPrimeAck.setState(ParticipantState.ON_LINE);
         publisher.sendParticipantPrimeAck(participantPrimeAck);
     }
@@ -251,17 +221,19 @@ public class ParticipantHandler {
      */
     public ParticipantStatus makeHeartbeat(boolean responseToParticipantStatusReq) {
         var heartbeat = new ParticipantStatus();
-        heartbeat.setParticipantId(participantId);
+        heartbeat.setParticipantId(cacheProvider.getParticipantId());
         heartbeat.setState(ParticipantState.ON_LINE);
-        heartbeat.setAutomationCompositionInfoList(automationCompositionHandler.getAutomationCompositionInfoList());
-        heartbeat.setParticipantSupportedElementType(new ArrayList<>(this.supportedAcElementTypes));
+        heartbeat.setAutomationCompositionInfoList(getAutomationCompositionInfoList());
+        heartbeat.setParticipantSupportedElementType(cacheProvider.getSupportedAcElementTypes());
 
         if (responseToParticipantStatusReq) {
+            var acElementDefsMap = cacheProvider.getAcElementsDefinitions();
             List<ParticipantDefinition> participantDefinitionList = new ArrayList<>(acElementDefsMap.size());
-            for (var acElementDefsOnThisParticipant : acElementDefsMap.values()) {
+            for (var acElementDefs : acElementDefsMap.values()) {
                 var participantDefinition = new ParticipantDefinition();
-                participantDefinition.setParticipantId(participantId);
-                participantDefinition.setAutomationCompositionElementDefinitionList(acElementDefsOnThisParticipant);
+                participantDefinition.setParticipantId(cacheProvider.getParticipantId());
+                participantDefinition
+                        .setAutomationCompositionElementDefinitionList(new ArrayList<>(acElementDefs.values()));
                 participantDefinitionList.add(participantDefinition);
             }
             heartbeat.setParticipantDefinitionUpdates(participantDefinitionList);
@@ -269,4 +241,24 @@ public class ParticipantHandler {
 
         return heartbeat;
     }
+
+    /**
+     * get AutomationComposition Info List.
+     *
+     * @return list of AutomationCompositionInfo
+     */
+    private List<AutomationCompositionInfo> getAutomationCompositionInfoList() {
+        List<AutomationCompositionInfo> automationCompositionInfoList = new ArrayList<>();
+        for (var entry : cacheProvider.getAutomationCompositions().entrySet()) {
+            var acInfo = new AutomationCompositionInfo();
+            acInfo.setAutomationCompositionId(entry.getKey());
+            acInfo.setDeployState(entry.getValue().getDeployState());
+            acInfo.setLockState(entry.getValue().getLockState());
+            for (var element : entry.getValue().getElements().values()) {
+                acInfo.getElements().add(automationCompositionOutHandler.getAutomationCompositionElementInfo(element));
+            }
+            automationCompositionInfoList.add(acInfo);
+        }
+        return automationCompositionInfoList;
+    }
 }