From 1cfb08779ea0e00be69e072a940b3063e049fe6b Mon Sep 17 00:00:00 2001 From: Ofir Sonsino Date: Wed, 31 Jan 2018 17:19:00 +0200 Subject: org.onap migration Change-Id: I52f0b2851f2c765752b6d21f49b32136d7d72a3d Issue-ID: VID-86 Signed-off-by: Ofir Sonsino --- .../main/java/org/onap/vid/utils/Intersection.java | 31 ++++++ .../src/main/java/org/onap/vid/utils/Logging.java | 105 +++++++++++++++++++++ .../src/main/java/org/onap/vid/utils/Streams.java | 47 +++++++++ 3 files changed, 183 insertions(+) create mode 100644 vid-app-common/src/main/java/org/onap/vid/utils/Intersection.java create mode 100644 vid-app-common/src/main/java/org/onap/vid/utils/Logging.java create mode 100644 vid-app-common/src/main/java/org/onap/vid/utils/Streams.java (limited to 'vid-app-common/src/main/java/org/onap/vid/utils') 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 00000000..6e0d1fc2 --- /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 { + public List intersectMultipileArray(List> lists) { + if (lists.size() == 1) { + return lists.get(0); + } else { + List intersectResult = intersectTwoArrays(lists.get(0),lists.get(1)); + + lists.remove(0); + lists.remove(0); + lists.add(0,intersectResult); + return intersectMultipileArray(lists); + } + + } + + public List intersectTwoArrays(List list1, List list2) { + + List 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 00000000..16dde568 --- /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 caller = + Arrays.stream(stackTrace) + .skip(1) + .filter(not(frame -> frame.getClassName().equals(thisClassName))) + .skip(depth) + .map(StackTraceElement::getMethodName) + .findFirst(); + return caller.orElse(""); + } + + 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 void logResponse(final EELFLogger logger, final HttpMethod method, final String url, final Response response, final Class 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 00000000..7f81b225 --- /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 Predicate not(Predicate predicate) { + return predicate.negate(); + } + + public static Stream fromIterator(final Iterator iterator) { + Iterable iterable = () -> iterator; + return StreamSupport.stream(iterable.spliterator(), false); + } + + + // https://stackoverflow.com/questions/20746429/limit-a-stream-by-a-predicate + private static Spliterator takeWhile( + Spliterator splitr, Predicate predicate) { + return new Spliterators.AbstractSpliterator(splitr.estimateSize(), 0) { + boolean stillGoing = true; + @Override public boolean tryAdvance(Consumer 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 Stream takeWhile(Stream stream, Predicate predicate) { + return StreamSupport.stream(takeWhile(stream.spliterator(), predicate), false); + } + +} -- cgit 1.2.3-korg