org.cloudfoundry.multiapps.controller.process.steps.PollServiceOperationsExecution Maven / Gradle / Ivy

Go to download
Show more of this group Show more artifacts with this name
Show all versions of multiapps-controller-process Show documentation
There is a newer version: 1.183.0
Show newest version
package org.cloudfoundry.multiapps.controller.process.steps;

import static java.text.MessageFormat.format;

import java.util.Collection;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.Map.Entry;
import java.util.stream.Collectors;

import org.apache.commons.collections4.CollectionUtils;
import org.cloudfoundry.multiapps.common.util.JsonUtil;
import org.cloudfoundry.multiapps.controller.client.lib.domain.CloudServiceInstanceExtended;
import org.cloudfoundry.multiapps.controller.core.security.serialization.SecureSerialization;
import org.cloudfoundry.multiapps.controller.process.Messages;
import org.cloudfoundry.multiapps.controller.process.util.ServiceOperationGetter;
import org.cloudfoundry.multiapps.controller.process.util.ServiceProgressReporter;
import org.cloudfoundry.multiapps.controller.process.util.StepLogger;
import org.cloudfoundry.multiapps.controller.process.variables.Variables;

import com.sap.cloudfoundry.client.facade.CloudControllerException;
import com.sap.cloudfoundry.client.facade.CloudOperationException;
import com.sap.cloudfoundry.client.facade.domain.ServiceOperation;

public abstract class PollServiceOperationsExecution implements AsyncExecution {

    private final ServiceOperationGetter serviceOperationGetter;
    private final ServiceProgressReporter serviceProgressReporter;

    protected PollServiceOperationsExecution(ServiceOperationGetter serviceOperationGetter,
                                             ServiceProgressReporter serviceProgressReporter) {
        this.serviceOperationGetter = serviceOperationGetter;
        this.serviceProgressReporter = serviceProgressReporter;
    }

    @Override
    public AsyncExecutionState execute(ProcessContext context) {
        context.getStepLogger()
               .debug(Messages.POLLING_SERVICE_OPERATIONS);

        Map triggeredServiceOperations = context.getVariable(Variables.TRIGGERED_SERVICE_OPERATIONS);
        List servicesToPoll = getServiceOperationsToPoll(context, triggeredServiceOperations);
        if (CollectionUtils.isEmpty(servicesToPoll)) {
            return AsyncExecutionState.FINISHED;
        }

        Map servicesWithLastOperation = new HashMap<>();
        for (CloudServiceInstanceExtended service : servicesToPoll) {
            ServiceOperation lastServiceOperation = getLastServiceOperationAndHandleExceptions(context, service);
            if (lastServiceOperation != null) {
                servicesWithLastOperation.put(service, lastServiceOperation);
            }
            context.getStepLogger()
                   .debug(Messages.LAST_OPERATION_FOR_SERVICE, service.getName(), JsonUtil.toJson(lastServiceOperation, true));
        }
        reportDetailedServicesStates(context, servicesWithLastOperation);
        reportOverallProgress(context, servicesWithLastOperation.values(), triggeredServiceOperations);
        List remainingServicesToPoll = getRemainingServicesToPoll(servicesWithLastOperation);
        context.getStepLogger()
               .debug(Messages.REMAINING_SERVICES_TO_POLL, SecureSerialization.toJson(remainingServicesToPoll));
        context.setVariable(Variables.SERVICES_TO_POLL, remainingServicesToPoll);

        if (remainingServicesToPoll.isEmpty()) {
            return AsyncExecutionState.FINISHED;
        }
        return AsyncExecutionState.RUNNING;
    }

    protected List getServiceOperationsToPoll(ProcessContext context,
                                                                            Map triggeredServiceOperations) {
        List servicesToPoll = context.getVariable(Variables.SERVICES_TO_POLL);
        if (CollectionUtils.isEmpty(servicesToPoll)) {
            return computeServicesToPoll(context, triggeredServiceOperations);
        }
        return servicesToPoll;
    }

    protected List
              getServicesWithTriggeredOperations(Collection services,
                                                 Map triggeredServiceOperations) {
        return services.stream()
                       .filter(cloudService -> triggeredServiceOperations.containsKey(cloudService.getName()))
                       .collect(Collectors.toList());
    }

    protected List computeServicesToPoll(ProcessContext context,
                                                                       Map triggeredServiceOperations) {
        List servicesData = getServicesData(context);
        return getServicesWithTriggeredOperations(servicesData, triggeredServiceOperations);
    }

    private ServiceOperation getLastServiceOperationAndHandleExceptions(ProcessContext context, CloudServiceInstanceExtended service) {
        try {
            ServiceOperation lastServiceOperation = getLastServiceOperation(context, service);
            if (lastServiceOperation != null) {
                return mapOperationState(context.getStepLogger(), lastServiceOperation, service);
            }
            handleMissingOperationState(context.getStepLogger(), service);
            return null;
        } catch (CloudOperationException e) {
            String errorMessage = format(Messages.ERROR_POLLING_OF_SERVICE, service.getName(), e.getStatusText());
            throw new CloudControllerException(e.getStatusCode(), errorMessage, e.getDescription());
        }
    }

    private ServiceOperation getLastServiceOperation(ProcessContext context, CloudServiceInstanceExtended service) {
        return serviceOperationGetter.getLastServiceOperation(context.getControllerClient(), service);
    }

    protected ServiceOperation mapOperationState(StepLogger stepLogger, ServiceOperation lastServiceOperation,
                                                 CloudServiceInstanceExtended service) {
        if (lastServiceOperation.getDescription() == null && lastServiceOperation.getState() == ServiceOperation.State.FAILED) {
            return new ServiceOperation(lastServiceOperation.getType(),
                                        Messages.DEFAULT_FAILED_OPERATION_DESCRIPTION,
                                        lastServiceOperation.getState());
        }
        return lastServiceOperation;
    }

    protected void reportDetailedServicesStates(ProcessContext context,
                                                Map servicesWithLastOperation) {
        for (Entry serviceWithLastOperation : servicesWithLastOperation.entrySet()) {
            reportServiceState(context, serviceWithLastOperation.getKey(), serviceWithLastOperation.getValue());
        }
    }

    private void reportOverallProgress(ProcessContext context, Collection lastServicesOperations,
                                       Map triggeredServiceOperations) {
        serviceProgressReporter.reportOverallProgress(context, lastServicesOperations, triggeredServiceOperations);
    }

    protected List
              getRemainingServicesToPoll(Map servicesWithLastOperation) {
        return servicesWithLastOperation.entrySet()
                                        .stream()
                                        .filter(this::isOperationInProgress)
                                        .map(Map.Entry::getKey)
                                        .collect(Collectors.toList());
    }

    private boolean isOperationInProgress(Entry serviceWithLastOperation) {
        ServiceOperation.State operationState = serviceWithLastOperation.getValue()
                                                                        .getState();
        return operationState == ServiceOperation.State.INITIAL || operationState == ServiceOperation.State.IN_PROGRESS;
    }

    protected abstract List getServicesData(ProcessContext context);

    protected abstract void reportServiceState(ProcessContext context, CloudServiceInstanceExtended service,
                                               ServiceOperation lastOperation);

    protected abstract void handleMissingOperationState(StepLogger stepLogger, CloudServiceInstanceExtended service);

}