diff options
Diffstat (limited to 'vid-app-common/src/main/java/org/onap/vid/utils')
3 files changed, 183 insertions, 0 deletions
diff --git a/vid-app-common/src/main/java/org/onap/vid/utils/Intersection.java b/vid-app-common/src/main/java/org/onap/vid/utils/Intersection.java new file mode 100644 index 000000000..6e0d1fc25 --- /dev/null +++ b/vid-app-common/src/main/java/org/onap/vid/utils/Intersection.java @@ -0,0 +1,31 @@ +package org.onap.vid.utils; + +import java.util.List; +import java.util.stream.Collectors; + +/** + * Created by moriya1 on 10/10/2017. + */ +public class Intersection<T> { + public List<T> intersectMultipileArray(List<List<T>> lists) { + if (lists.size() == 1) { + return lists.get(0); + } else { + List<T> intersectResult = intersectTwoArrays(lists.get(0),lists.get(1)); + + lists.remove(0); + lists.remove(0); + lists.add(0,intersectResult); + return intersectMultipileArray(lists); + } + + } + + public List<T> intersectTwoArrays(List<T> list1, List<T> list2) { + + List<T> intersect = list1.stream() + .filter(list2::contains) + .collect(Collectors.toList()); + return intersect; + } +} diff --git a/vid-app-common/src/main/java/org/onap/vid/utils/Logging.java b/vid-app-common/src/main/java/org/onap/vid/utils/Logging.java new file mode 100644 index 000000000..16dde5682 --- /dev/null +++ b/vid-app-common/src/main/java/org/onap/vid/utils/Logging.java @@ -0,0 +1,105 @@ +package org.onap.vid.utils; + +import com.att.eelf.configuration.EELFLogger; +import com.fasterxml.jackson.core.JsonProcessingException; +import com.fasterxml.jackson.databind.ObjectMapper; +import org.openecomp.portalsdk.core.logging.logic.EELFLoggerDelegate; +import org.openecomp.portalsdk.core.util.SystemProperties; +import org.springframework.http.HttpMethod; +import org.springframework.web.context.request.RequestContextHolder; +import org.springframework.web.context.request.ServletRequestAttributes; + +import javax.servlet.http.HttpServletRequest; +import javax.ws.rs.ProcessingException; +import javax.ws.rs.core.Response; +import java.util.Arrays; +import java.util.Optional; + +import static org.onap.vid.utils.Streams.not; + +public class Logging { + + private Logging() { + } + + public static final String HTTP_REQUESTS_OUTGOING = "http.requests.outgoing."; + + public static final String requestIdHeaderKey = SystemProperties.ECOMP_REQUEST_ID; + + private static ObjectMapper objectMapper = new ObjectMapper(); + + public static String getMethodName() { + return getMethodName(0); + } + + public static String getMethodCallerName() { + return getMethodName(1); + } + + private static String getMethodName(int depth) { + final StackTraceElement[] stackTrace = Thread.currentThread().getStackTrace(); + String thisClassName = stackTrace[1].getClassName(); + final Optional<String> caller = + Arrays.stream(stackTrace) + .skip(1) + .filter(not(frame -> frame.getClassName().equals(thisClassName))) + .skip(depth) + .map(StackTraceElement::getMethodName) + .findFirst(); + return caller.orElse("<unknonwn method name>"); + } + + public static EELFLogger getRequestsLogger(String serverName) { + return EELFLoggerDelegate.getLogger(HTTP_REQUESTS_OUTGOING +serverName); + } + + public static void logRequest(final EELFLogger logger, final HttpMethod method, final String url, final Object body) { + if (!logger.isDebugEnabled()) { + return; + } + + if (body == null) { + logRequest(logger, method, url); + return; + } + + try { + String bodyAsJson = objectMapper.writeValueAsString(body); + logger.debug("Sending {} {} Body: {}", method.name(), url, bodyAsJson); + } catch (JsonProcessingException e) { + logRequest(logger, method, url); + logger.debug("Failed to parse object in logRequest. {}", body); + } + } + + public static void logRequest(final EELFLogger logger, final HttpMethod method, final String url) { + logger.debug("Sending {} {}", method.name(), url); + } + + public static <T> void logResponse(final EELFLogger logger, final HttpMethod method, final String url, final Response response, final Class<T> entityClass) { + if (!logger.isDebugEnabled()) { + return; + } + if (response == null) { + logger.debug("Received {} {} response: null", method.name(), url); + return; + } + try { + response.bufferEntity(); + logger.debug("Received {} {} Status: {} . Body: {}", method.name(), url, response.getStatus(), response.readEntity(entityClass)); + } + catch (ProcessingException | IllegalStateException e) { + logger.debug("Received {} {} Status: {} . Failed to read response as {}", method.name(), url, response.getStatus(), entityClass.getName()); + } + } + + public static void logResponse(final EELFLogger logger, final HttpMethod method, final String url, final Response response) { + logResponse(logger, method, url, response, String.class); + } + + public static HttpServletRequest getHttpServletRequest(){ + return ((ServletRequestAttributes) RequestContextHolder.currentRequestAttributes()).getRequest(); + } + + +} diff --git a/vid-app-common/src/main/java/org/onap/vid/utils/Streams.java b/vid-app-common/src/main/java/org/onap/vid/utils/Streams.java new file mode 100644 index 000000000..7f81b225a --- /dev/null +++ b/vid-app-common/src/main/java/org/onap/vid/utils/Streams.java @@ -0,0 +1,47 @@ +package org.onap.vid.utils; + +import java.util.Iterator; +import java.util.Spliterator; +import java.util.Spliterators; +import java.util.function.Consumer; +import java.util.function.Predicate; +import java.util.stream.Stream; +import java.util.stream.StreamSupport; + +public class Streams { + public static <R> Predicate<R> not(Predicate<R> predicate) { + return predicate.negate(); + } + + public static <T> Stream<T> fromIterator(final Iterator<T> iterator) { + Iterable<T> iterable = () -> iterator; + return StreamSupport.<T>stream(iterable.spliterator(), false); + } + + + // https://stackoverflow.com/questions/20746429/limit-a-stream-by-a-predicate + private static <T> Spliterator<T> takeWhile( + Spliterator<T> splitr, Predicate<? super T> predicate) { + return new Spliterators.AbstractSpliterator<T>(splitr.estimateSize(), 0) { + boolean stillGoing = true; + @Override public boolean tryAdvance(Consumer<? super T> consumer) { + if (stillGoing) { + boolean hadNext = splitr.tryAdvance(elem -> { + if (predicate.test(elem)) { + consumer.accept(elem); + } else { + stillGoing = false; + } + }); + return hadNext && stillGoing; + } + return false; + } + }; + } + + public static <T> Stream<T> takeWhile(Stream<T> stream, Predicate<? super T> predicate) { + return StreamSupport.stream(takeWhile(stream.spliterator(), predicate), false); + } + +} |