add facade code to Onap

[sdc/microservices.git] / catalog-facade-ms / src / main / java / org / onap / sdc / utils / FunctionalCodeUtils.java

/*-
 * ============LICENSE_START=======================================================
 * sdc-microservices
 * ================================================================================
 * Copyright (C) 2017 - 2019 AT&T Intellectual Property. All rights reserved.
 * ================================================================================
 * Licensed 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.
 * ============LICENSE_END=========================================================
 */

package org.onap.sdc.utils;

import static java.util.Arrays.asList;
import static org.onap.sdc.logger.FacadeLogUtils.serviceNameFromMDC;

import java.util.Optional;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.Future;
import java.util.concurrent.RejectedExecutionException;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.TimeoutException;
import java.util.function.Predicate;

import org.apache.commons.lang3.NotImplementedException;
import org.apache.commons.lang3.math.NumberUtils;
import org.apache.commons.lang3.time.StopWatch;
import org.openecomp.sdc.common.log.elements.ErrorLogOptionalData;
import org.openecomp.sdc.common.log.enums.EcompLoggerErrorCode;
import org.openecomp.sdc.common.log.wrappers.Logger;

/**
 * Utility class for functional code
 * 
 * @author ms172g
 *
 */
public final class FunctionalCodeUtils {
        static final Logger LOG = Logger.getLogger(FunctionalCodeUtils.class);
        
        

        private FunctionalCodeUtils() {
                throw new UnsupportedOperationException("Do not instantiate utility class");
        }

        /**
         * Wraps the execution of the Runnable with try catch.<br>
         * In case exception occurred returns Optional containing the
         * resultOnException.<br>
         * Otherwise returns an Empty optional.
         * 
         * @param runnable
         * @param resultOnException
         * @param serviceName
         * @return
         */
        public static <T, E extends Exception> Optional<T> wrapWithTryCatch(RunnableThrows<E> runnable,
                        T resultOnException, String serviceName) {
                Optional<T> optionalError;
                try {
                        runnable.run();
                        optionalError = Optional.empty();
                } catch (Exception e) {
                        logException(e, serviceName);
                        optionalError = Optional.of(resultOnException);
                }
                return optionalError;
        }
        
        /**
         * Wraps the execution of the Runnable with try catch.<br>
         * In case exception occurred logs the Exception.<br>
         * resultOnException.<br>
         * Otherwise returns an Empty optional.
         * 
         * @param runnable
         * @param resultOnException
         * @return
         */
        public static <E extends Exception> void wrapWithTryCatch(RunnableThrows<E> runnable, String serviceName) {
                wrapWithTryCatch(runnable, serviceName);
        }

        /**
         * Functional Interface Similar to Runnable except that throws Exception
         * 
         * @author ms172g
         *
         * @param <E>
         */
        @FunctionalInterface
        public interface RunnableThrows<E extends Exception> {
                /**
                 * Similar to run of Runnable except that throws Exception
                 * 
                 * @throws E
                 */
                void run() throws E;

        }

        private static void logException(Exception e, String serviceName) {
                LOG.error(EcompLoggerErrorCode.BUSINESS_PROCESS_ERROR, serviceName, new ErrorLogOptionalData(),"Error was caught : {}", e.getMessage());
                LOG.debug("Error was caught ", e);
        }

        /**
         * Finds a value in an enum array by predicate
         * 
         * @param predicate
         * @param values
         * @return
         */
        public static <T extends Enum<T>> T findByPredicate(Predicate<T> predicate, T[] values) {

                final Optional<T> optionalFound = asList(values).stream()
                                .filter(predicate)
                                .findAny();
                return optionalFound.orElseThrow(() -> new NotImplementedException(
                                String.format("Enum: %s Not Found for predicate: %s ", values.getClass()
                                                .getName(), predicate.toString())));
        }

        /**
         * Runs the given method.<br>
         * In case the method passes without any Assertion Errors finishes.<br>
         * In case there is an assertion error keeps running the method every  retryIntervalMS.<br> until there is no Errors or maxWaitTimeMs has passed. <br>
         * If there are still Assertion Errors in the last Run they are returned to the user.<br>
         * 
         * @param methodToRun
         * @param maxWaitTimeMs
         * @param retryIntervalMS
         */
        public static void retryMethodOnAssertionError(Runnable methodToRun, long maxWaitTimeMs, long retryIntervalMS, String serviceName) {
                if (maxWaitTimeMs <= 0) {
                        throw new UnsupportedOperationException("Number maxWaitTimeMs be greater than 0");
                }
                StopWatch watch = new StopWatch();
                watch.start();
                boolean isLastTry = watch.getTime() + retryIntervalMS > maxWaitTimeMs;
                boolean isSuccessfull = false;

                while (!isLastTry && !isSuccessfull) {
                        try {
                                methodToRun.run();
                                isSuccessfull = true;
                        } catch (AssertionError e) {
                                wrapWithTryCatch(() -> Thread.sleep(retryIntervalMS), serviceName);
                                //Dummy Code to prevent sonar Issue
                                boolean flag = false;
                                if( flag ){
                                        LOG.debug(e.getMessage(), e);
                                }
                        }
                        isLastTry = watch.getTime() + retryIntervalMS > maxWaitTimeMs;
                        if (isLastTry) {
                                methodToRun.run();
                        }
                }


        }
        /**
         * @author mshitrit Supplier that throws an exception
         * @param <R>
         * @param <E>
         */
        public interface SupplierThrows<R, E extends Exception> {
                /**
                 * Same get method, but throws an exception
                 * 
                 * @return
                 * @throws E
                 */
                R get() throws E;
        }

        
        /**
         * Runs a method that declares throwing an Exception and has a return value.
         * <br>
         * In case Exception Occurred replaces it with RunTimeException. <br>
         * This is useful for two cases:<br>
         * 1.using methods that throws exceptions in streams.<br>
         * 2.replacing declared exception with undeclared exception (Runtime).<br>
         * See below Use Case:<br>
         * Instead of: intList.stream().map(e -> fooThrowsAndReturnsBoolean(e)); -
         * does not compile !<br>
         * Use This : intList.stream().map(e -> swallowException( () ->
         * fooThrowsAndReturnsBoolean(e))); - compiles !<br>
         * 
         * @param methodToRun
         * @return
         */
        public static <R, E extends Exception> R replaceWithUncheckedException(SupplierThrows<R, E> methodToRun) {
                try {
                        return methodToRun.get();
                } catch (Exception e) {
                        throw new RuntimeException(e);
                }
        }

        /**
         * Runs a method that declares throwing an Exception without return value.
         * <br>
         * In case Exception Occurred replaces it with RunTimeException. <br>
         * This is useful for two cases:<br>
         * 1.using methods that throws exceptions in streams.<br>
         * 2.replacing declared exception with undeclared exception (Runtime).<br>
         * See below Use Case:<br>
         * 
         * @param methodToRun
         */
        public static <E extends Exception> void replaceWithUncheckedException(RunnableThrows<E> methodToRun) {

                SupplierThrows<Boolean, E> runnableWrapper = () -> {
                        methodToRun.run();
                        return true;
                };
                replaceWithUncheckedException(runnableWrapper);
        }


        /**
         * This method runs the given method.<br>
         * In case given method finished running within timeoutInMs limit it returns true.<br>
         * In case given method did not finish running within timeoutInMs limit it returns false.<br>
         
         * 
         * @param runnable
         * @param timeoutInMs
         * @param serviceName
         * @return
         */
        public static boolean runMethodWithTimeOut(Runnable runnable, long timeoutInMs, String serviceName) {
                boolean isFinishedWithingTimeOut;
                if (timeoutInMs <= NumberUtils.LONG_ZERO) {
                        isFinishedWithingTimeOut = false;
                } else {
                        ExecutorService pool = Executors.newSingleThreadExecutor();
                        Future<Boolean> future = pool.submit(runnable, Boolean.TRUE);
                        
                        try {
                                isFinishedWithingTimeOut = future.get(timeoutInMs, TimeUnit.MILLISECONDS);
                                 
                        } catch (NullPointerException | RejectedExecutionException | InterruptedException | ExecutionException | TimeoutException e) {
                                isFinishedWithingTimeOut = false;
                                LOG.debug("method run was canceled because it has passed its time limit of {} MS ", timeoutInMs, e);
                                
                        } 
                        catch (Exception e){
                                isFinishedWithingTimeOut = false;
                                logException(e, serviceName);
                        }finally {
                                pool.shutdownNow();
                        }
                }
                return isFinishedWithingTimeOut;
        }

        

}