server/src/main/java/com/cloud/event/ActionEventUtils.java

// Licensed to the Apache Software Foundation (ASF) under one
// or more contributor license agreements.  See the NOTICE file
// distributed with this work for additional information
// regarding copyright ownership.  The ASF licenses this file
// to you under the Apache License, Version 2.0 (the
// "License"); you may not use this file except in compliance
// with the License.  You may obtain a copy of the License at
//
//   http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing,
// software distributed under the License is distributed on an
// "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
// KIND, either express or implied.  See the License for the
// specific language governing permissions and limitations
// under the License.

package com.cloud.event;

import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;
import java.text.SimpleDateFormat;
import java.util.Date;
import java.util.HashMap;
import java.util.List;
import java.util.Map;

import javax.annotation.PostConstruct;
import javax.inject.Inject;

import org.apache.cloudstack.api.ApiCommandResourceType;
import org.apache.cloudstack.api.Identity;
import org.apache.cloudstack.api.InternalIdentity;
import org.apache.cloudstack.context.CallContext;
import org.apache.cloudstack.framework.events.EventDistributor;
import org.apache.commons.lang3.ObjectUtils;
import org.apache.commons.lang3.StringUtils;
import org.apache.logging.log4j.LogManager;
import org.apache.logging.log4j.Logger;
import org.springframework.beans.factory.NoSuchBeanDefinitionException;

import com.cloud.event.dao.EventDao;
import com.cloud.projects.Project;
import com.cloud.projects.dao.ProjectDao;
import com.cloud.server.ManagementServer;
import com.cloud.server.ManagementService;
import com.cloud.user.Account;
import com.cloud.user.AccountVO;
import com.cloud.user.User;
import com.cloud.user.dao.AccountDao;
import com.cloud.user.dao.UserDao;
import com.cloud.utils.Pair;
import com.cloud.utils.ReflectUtil;
import com.cloud.utils.Ternary;
import com.cloud.utils.component.ComponentContext;
import com.cloud.utils.db.EntityManager;

public class ActionEventUtils {
    protected static Logger LOGGER = LogManager.getLogger(ActionEventUtils.class);

    private static EventDao s_eventDao;
    private static AccountDao s_accountDao;
    private static ProjectDao s_projectDao;
    protected static UserDao s_userDao;
    private static EventDistributor eventDistributor;
    protected static EntityManager s_entityMgr;

    public static final String EventDetails = "event_details";
    public static final String EventId = "event_id";
    public static final String EntityType = "entity_type";
    public static final String EntityUuid = "entity_uuid";
    public static final String EntityDetails = "entity_details";

    @Inject
    EventDao eventDao;
    @Inject
    AccountDao accountDao;
    @Inject
    UserDao userDao;
    @Inject
    ProjectDao projectDao;
    @Inject
    EntityManager entityMgr;

    public ActionEventUtils() {
    }

    @PostConstruct
    void init() {
        s_eventDao = eventDao;
        s_accountDao = accountDao;
        s_userDao = userDao;
        s_projectDao = projectDao;
        s_entityMgr = entityMgr;
    }

    public static Long onActionEvent(Long userId, Long accountId, Long domainId, String type, String description, Long resourceId, String resourceType) {
        Ternary<Long, String, String> resourceDetails = getResourceDetails(resourceId, resourceType, type);
        Event event = persistActionEvent(userId, accountId, domainId, null, type, Event.State.Completed,
                true, description, resourceDetails.first(), resourceDetails.third(), null);
        publishOnEventBus(event, userId, accountId, domainId, EventCategory.ACTION_EVENT.getName(), type,
                com.cloud.event.Event.State.Completed, description, resourceDetails.second(), resourceDetails.third());
        return event.getId();
    }

    /*
     * Save event after scheduling an async job
     */
    public static Long onScheduledActionEvent(Long userId, Long accountId, String type, String description, Long resourceId, String resourceType, boolean eventDisplayEnabled, long startEventId) {
        Ternary<Long, String, String> resourceDetails = getResourceDetails(resourceId, resourceType, type);
        CallContext ctx = CallContext.current();
        accountId = getOwnerAccountId(ctx, type, accountId);
        Event event = persistActionEvent(userId, accountId, null, null, type, Event.State.Scheduled,
                eventDisplayEnabled, description, resourceDetails.first(), resourceDetails.third(), startEventId);
        publishOnEventBus(event, userId, accountId, EventCategory.ACTION_EVENT.getName(), type,
                com.cloud.event.Event.State.Scheduled, description, resourceDetails.second(), resourceDetails.third());
        return event.getId();
    }

    public static void startNestedActionEvent(String eventType, String eventDescription, Long resourceId, String resourceType) {
        CallContext.setActionEventInfo(eventType, eventDescription);
        onStartedActionEventFromContext(eventType, eventDescription, resourceId, resourceType, true);
    }

    public static void onStartedActionEventFromContext(String eventType, String eventDescription, Long resourceId, String resourceType, boolean eventDisplayEnabled) {
        CallContext ctx = CallContext.current();
        long userId = ctx.getCallingUserId();
        long accountId = getOwnerAccountId(ctx, eventType, ctx.getCallingAccountId());
        long startEventId = ctx.getStartEventId();

        if (!eventType.equals(""))
            ActionEventUtils.onStartedActionEvent(userId, accountId, eventType, eventDescription, resourceId, resourceType, eventDisplayEnabled, startEventId);
    }

    /*
     * Save event after starting execution of an async job
     */
    public static Long onStartedActionEvent(Long userId, Long accountId, String type, String description, Long resourceId, String resourceType, boolean eventDisplayEnabled, long startEventId) {
        Ternary<Long, String, String> resourceDetails = getResourceDetails(resourceId, resourceType, type);
        Event event = persistActionEvent(userId, accountId, null, null, type, Event.State.Started,
                eventDisplayEnabled, description, resourceDetails.first(), resourceDetails.third(), startEventId);
        publishOnEventBus(event, userId, accountId, EventCategory.ACTION_EVENT.getName(), type,
                com.cloud.event.Event.State.Started, description, resourceDetails.second(), resourceDetails.third());
        return event.getId();
    }

    public static Long onCompletedActionEvent(Long userId, Long accountId, String level, String type, String description, Long resourceId, String resourceType, long startEventId) {

        return onCompletedActionEvent(userId, accountId, level, type, true, description, resourceId, resourceType, startEventId);
    }

    public static Long onCompletedActionEvent(Long userId, Long accountId, String level, String type, boolean eventDisplayEnabled, String description, Long resourceId, String resourceType, long startEventId) {
        Ternary<Long, String, String> resourceDetails = getResourceDetails(resourceId, resourceType, type);
        Event event = persistActionEvent(userId, accountId, null, level, type, Event.State.Completed,
                eventDisplayEnabled, description, resourceDetails.first(), resourceDetails.third(), startEventId);
        publishOnEventBus(event, userId, accountId, EventCategory.ACTION_EVENT.getName(), type,
                com.cloud.event.Event.State.Completed, description, resourceDetails.second(), resourceDetails.third());
        return event.getId();

    }

    public static Long onCreatedActionEvent(Long userId, Long accountId, String level, String type, boolean eventDisplayEnabled, String description, Long resourceId, String resourceType) {
        Ternary<Long, String, String> resourceDetails = getResourceDetails(resourceId, resourceType, type);
        Event event = persistActionEvent(userId, accountId, null, level, type, Event.State.Created,
                eventDisplayEnabled, description, resourceDetails.first(), resourceDetails.third(), null);
        publishOnEventBus(event, userId, accountId, EventCategory.ACTION_EVENT.getName(), type,
                com.cloud.event.Event.State.Created, description, resourceDetails.second(), resourceDetails.third());
        return event.getId();
    }

    private static Event persistActionEvent(Long userId, Long accountId, Long domainId, String level, String type,
                                            Event.State state, boolean eventDisplayEnabled, String description,
                                            Long resourceId, String resourceType, Long startEventId) {
        EventVO event = new EventVO();
        event.setUserId(userId);
        event.setAccountId(accountId);
        event.setType(type);
        event.setState(state);
        event.setDescription(description);
        event.setDisplay(eventDisplayEnabled);

        if (domainId != null) {
            event.setDomainId(domainId);
        } else {
            event.setDomainId(getDomainId(accountId));
        }
        if (resourceId != null) {
            event.setResourceId(resourceId);
        }
        if (resourceType != null) {
            event.setResourceType(resourceType);
        }
        if (level != null && !level.isEmpty()) {
            event.setLevel(level);
        }
        if (startEventId != null) {
            event.setStartId(startEventId);
        }
        event = s_eventDao.persist(event);
        return event;
    }

    private static void publishOnEventBus(Event eventRecord, long userId, long accountId, Long domainId,
          String eventCategory, String eventType, Event.State state, String description, String resourceUuid,
          String resourceType) {
        boolean configValue = ManagementServer.PublishActionEvent.value();
        if(!configValue)
            return;

        try {
            eventDistributor = ComponentContext.getComponent(EventDistributor.class);
        } catch (NoSuchBeanDefinitionException nbe) {
            return; // no provider is configured to provide events bus, so just return
        }

        org.apache.cloudstack.framework.events.Event event =
                new org.apache.cloudstack.framework.events.Event(ManagementService.Name, eventCategory, eventType, resourceType, resourceUuid);
        event.setEventId(eventRecord.getId());
        event.setEventUuid(eventRecord.getUuid());

        Map<String, String> eventDescription = new HashMap<String, String>();
        Project project = s_projectDao.findByProjectAccountId(accountId);
        Account account = s_accountDao.findById(accountId);
        User user = s_userDao.findById(userId);
        // if account has been deleted, this might be called during cleanup of resources and results in null pointer
        if (account == null)
            return;
        if (user == null)
            return;
        if (project != null)
            eventDescription.put("project", project.getUuid());
        event.setResourceAccountId(accountId);
        event.setResourceAccountUuid(account.getUuid());
        event.setResourceDomainId(domainId == null ? account.getDomainId() : domainId);
        eventDescription.put("user", user.getUuid());
        eventDescription.put("account", account.getUuid());
        eventDescription.put("event", eventType);
        eventDescription.put("status", state.toString());
        eventDescription.put("entity", resourceType);
        eventDescription.put("entityuuid", resourceUuid);
        //Put all the first class entities that are touched during the action. For now at least put in the vmid.
        populateFirstClassEntities(eventDescription);
        eventDescription.put("description", description);

        String eventDate = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss Z").format(new Date());
        eventDescription.put("eventDateTime", eventDate);

        event.setDescription(eventDescription);

        eventDistributor.publish(event);
    }

    private static void publishOnEventBus(Event event, long userId, long accountId, String eventCategory,
          String eventType, Event.State state, String description, String resourceUuid, String resourceType) {
        publishOnEventBus(event, userId, accountId, null, eventCategory, eventType, state, description,
                resourceUuid, resourceType);
    }

    private static Ternary<Long, String, String> getResourceDetailsUsingEntityClassAndContext(Class<?> entityClass, ApiCommandResourceType resourceType) {
        CallContext context = CallContext.current();
        ApiCommandResourceType alternateResourceType = ApiCommandResourceType.valueFromAssociatedClass(entityClass);
        if (resourceType == null ||
                (ObjectUtils.allNotNull(resourceType, alternateResourceType) &&
                        resourceType.getAssociatedClass() != alternateResourceType.getAssociatedClass())) {
            resourceType = alternateResourceType;
        }
        String entityType = resourceType == null ? entityClass.getSimpleName() : resourceType.toString();
        String entityUuid = null;
        Long entityId = null;
        Object param = context.getContextParameter(entityClass);
        if(param != null){
            try {
                entityUuid = getEntityUuid(entityClass, param);
            } catch (Exception e){
                LOGGER.debug("Caught exception while finding entityUUID, moving on");
            }
        }
        if (param instanceof Long) {
            entityId = (Long)param;
        } else if (entityUuid != null) {
            Object obj = s_entityMgr.findByUuidIncludingRemoved(entityClass, entityUuid);
            if (obj instanceof InternalIdentity) {
                entityId = ((InternalIdentity)obj).getId();
            }
        }
        return new Ternary<>(entityId, entityUuid, entityType);
    }

    private static Ternary<Long, String, String> getResourceDetailsUsingEventTypeAndContext(ApiCommandResourceType resourceType, String eventType) {
        Class<?> entityClass = EventTypes.getEntityClassForEvent(eventType);
        if (entityClass != null && s_entityMgr.validEntityType(entityClass)) {
            return getResourceDetailsUsingEntityClassAndContext(entityClass, resourceType);
        } else if (resourceType != null && resourceType.getAssociatedClass() != null && s_entityMgr.validEntityType(resourceType.getAssociatedClass())) {
            return getResourceDetailsUsingEntityClassAndContext(resourceType.getAssociatedClass(), resourceType);
        }
        return new Ternary<Long, String, String>(null, null, null);
    }

    private static String getEntityUuid(Class<?> entityType, Object entityId){

        // entityId can be internal db id or UUID so accordingly call findById or return uuid directly

        if (entityId instanceof Long){
            // Its internal db id - use findById
            if (!s_entityMgr.validEntityType(entityType)) {
                return null;
            }
            final Object objVO = s_entityMgr.findByIdIncludingRemoved(entityType, (Long)entityId);
            if (objVO != null) {
                return ((Identity) objVO).getUuid();
            }
        } else if(entityId instanceof String) {
            try{
                // In case its an async job the internal db id would be a string because of json deserialization
                Long internalId = Long.valueOf((String) entityId);
                if (!s_entityMgr.validEntityType(entityType)) {
                    return null;
                }
                final Object objVO = s_entityMgr.findByIdIncludingRemoved(entityType, internalId);
                if (objVO != null) {
                    return ((Identity) objVO).getUuid();
                }
            } catch (NumberFormatException e) {
                // It is uuid - so return it
                return (String)entityId;
            }
        }

        return null;
    }

    private static Ternary<Long, String, String> updateParentResourceCases(Ternary<Long, String, String> details) {
        if (!ObjectUtils.allNotNull(details, details.first(), details.second(), details.third())) {
            return details;
        }
        HashMap<String, Pair<ApiCommandResourceType, String>> typeParentMethodMap = new HashMap<>();
        typeParentMethodMap.put(ApiCommandResourceType.VmSnapshot.toString(), new Pair<>(ApiCommandResourceType.VirtualMachine, "getVmId"));
        if (!typeParentMethodMap.containsKey(details.third())) {
            return details;
        }
        ApiCommandResourceType type = ApiCommandResourceType.fromString(details.third());
        if (type == null || !s_entityMgr.validEntityType(type.getAssociatedClass())) {
            return details;
        }
        Object objVO = s_entityMgr.findByIdIncludingRemoved(type.getAssociatedClass(), details.first());
        if (objVO == null) {
            return details;
        }
        String methodName = typeParentMethodMap.get(type.toString()).second();
        try {
            Method m = objVO.getClass().getMethod(methodName);
            Long id = (Long)m.invoke(objVO);
            if (id == null) {
                return details;
            }
            type = typeParentMethodMap.get(type.toString()).first();
            objVO = s_entityMgr.findByIdIncludingRemoved(type.getAssociatedClass(), id);
            if (objVO == null) {
                return details;
            }
            return new Ternary<>(id, ((Identity)objVO).getUuid(), type.toString());
        } catch (NoSuchMethodException | IllegalAccessException | InvocationTargetException e) {
            LOGGER.debug(String.format("Parent resource for resource ID: %d, type: %s can not be found using method %s", details.first(), type, methodName));
        }
        return details;
    }

    private static Ternary<Long, String, String> getResourceDetails(Long resourceId, String resourceType, String eventType) {
        Ternary<Long, String, String> details;
        Class<?> clazz = null;
        ApiCommandResourceType type = null;
        if (StringUtils.isNotEmpty(resourceType)) {
            type = ApiCommandResourceType.fromString(resourceType);
            if (type != null) {
                clazz = type.getAssociatedClass();
            }
        }
        if (ObjectUtils.allNotNull(resourceId, clazz)) {
            String uuid = getEntityUuid(clazz, resourceId);
            details = new Ternary<>(resourceId, uuid, resourceType);
        } else {
            details = getResourceDetailsUsingEventTypeAndContext(type, eventType);
        }
        return updateParentResourceCases(details);
    }

    private static long getDomainId(long accountId) {
        AccountVO account = s_accountDao.findByIdIncludingRemoved(accountId);
        if (account == null) {
            LOGGER.error("Failed to find account(including removed ones) by id '" + accountId + "'");
            return 0;
        }
        return account.getDomainId();
    }

    /**
     * Retrieves the last non-archived event matching the specified criteria.
     *
     * @param type         the event type to search for
     * @param state        the event state to search for (e.g., {@link Event.State#Scheduled})
     * @param resourceId   the resource ID associated with the event
     * @param resourceType the resource type associated with the event
     * @return the most recent EventVO matching the criteria, or null if not found
     * @see EventDao#findLastEvent(String, Event.State, Long, String)
     */
    public static EventVO getLastEvent(String type, Event.State state, Long resourceId, String resourceType) {
        return s_eventDao.findLastEvent(type, state, resourceId, resourceType);
    }

    private static void populateFirstClassEntities(Map<String, String> eventDescription){

        CallContext context = CallContext.current();
        Map<Object, Object> contextMap = context.getContextParameters();

        for(Map.Entry<Object, Object> entry : contextMap.entrySet()){
            try{
                Class<?> clz = (Class<?>)entry.getKey();
                if(clz != null && Identity.class.isAssignableFrom(clz)){
                    String uuid = getEntityUuid(clz, entry.getValue());
                    eventDescription.put(ReflectUtil.getEntityName(clz), uuid);
                }
            } catch (Exception e){
                LOGGER.trace("Caught exception while populating first class entities for event bus, moving on");
            }
        }
    }

    public static long getOwnerAccountId(CallContext ctx, String eventType, long callingAccountId) {
        List<String> mainProjectEvents = List.of(EventTypes.EVENT_PROJECT_CREATE, EventTypes.EVENT_PROJECT_UPDATE, EventTypes.EVENT_PROJECT_DELETE);
        long accountId = ctx.getProject() != null && !mainProjectEvents.stream().anyMatch(eventType::equalsIgnoreCase) ? ctx.getProject().getProjectAccountId() : callingAccountId;    //This should be the entity owner id rather than the Calling User Account Id.
        return accountId;
    }
}