<parent>
<groupId>org.onap.aai.aai-common</groupId>
<artifactId>aai-parent</artifactId>
- <version>1.15.5-SNAPSHOT</version>
+ <version>1.16.0-SNAPSHOT</version>
<relativePath>../aai-parent/pom.xml</relativePath>
</parent>
<artifactId>aai-annotations</artifactId>
<parent>
<groupId>org.onap.aai.aai-common</groupId>
<artifactId>aai-parent</artifactId>
- <version>1.15.5-SNAPSHOT</version>
+ <version>1.16.0-SNAPSHOT</version>
<relativePath>../aai-parent/pom.xml</relativePath>
</parent>
<artifactId>aai-auth</artifactId>
<dependencies>
<dependency>
- <groupId>org.apache.httpcomponents</groupId>
- <artifactId>httpclient</artifactId>
+ <groupId>org.apache.httpcomponents.client5</groupId>
+ <artifactId>httpclient5</artifactId>
</dependency>
<dependency>
<groupId>com.fasterxml.jackson.core</groupId>
package org.onap.aaiauth.auth;
-import org.apache.http.cookie.Cookie;
+import org.apache.hc.client5.http.cookie.Cookie;
public class Auth {
<parent>
<groupId>org.onap.aai.aai-common</groupId>
<artifactId>aai-common-docker</artifactId>
- <version>1.15.5-SNAPSHOT</version>
+ <version>1.16.0-SNAPSHOT</version>
</parent>
<artifactId>aai-common-images</artifactId>
- <version>1.15.5-SNAPSHOT</version>
+ <version>1.16.0-SNAPSHOT</version>
<packaging>pom</packaging>
<name>aai-aai-common-images</name>
<description>Contains dockerfiles for aai-common images (alpine and ubuntu based).</description>
<parent>
<groupId>org.onap.aai.aai-common</groupId>
<artifactId>aai-common-docker</artifactId>
- <version>1.15.5-SNAPSHOT</version>
+ <version>1.16.0-SNAPSHOT</version>
</parent>
<artifactId>aai-haproxy-image</artifactId>
- <version>1.15.5-SNAPSHOT</version>
+ <version>1.16.0-SNAPSHOT</version>
<packaging>pom</packaging>
<name>aai-aai-haproxy-image</name>
<description>Contains dockerfiles for aai-haproxy image.</description>
<parent>
<groupId>org.onap.aai.aai-common</groupId>
<artifactId>aai-parent</artifactId>
- <version>1.15.5-SNAPSHOT</version>
+ <version>1.16.0-SNAPSHOT</version>
<relativePath>../aai-parent/pom.xml</relativePath>
</parent>
<parent>
<groupId>org.onap.aai.aai-common</groupId>
<artifactId>aai-parent</artifactId>
- <version>1.15.5-SNAPSHOT</version>
+ <version>1.16.0-SNAPSHOT</version>
<relativePath>../aai-parent/pom.xml</relativePath>
</parent>
<artifactId>aai-core</artifactId>
</dependency>
<dependency>
<groupId>org.glassfish</groupId>
- <artifactId>javax.json</artifactId>
- <version>1.1.4</version>
- </dependency>
- <dependency>
- <groupId>javax.servlet</groupId>
- <artifactId>javax.servlet-api</artifactId>
+ <artifactId>jakarta.json</artifactId>
+ <version>2.0.1</version>
</dependency>
<dependency>
<groupId>org.janusgraph</groupId>
<scope>test</scope>
</dependency>
<dependency>
- <groupId>com.fasterxml.jackson.jaxrs</groupId>
- <artifactId>jackson-jaxrs-json-provider</artifactId>
+ <groupId>com.fasterxml.jackson.jakarta.rs</groupId>
+ <artifactId>jackson-jakarta-rs-json-provider</artifactId>
</dependency>
<dependency>
<groupId>org.springframework.kafka</groupId>
</dependency>
<dependency>
<groupId>com.fasterxml.jackson.module</groupId>
- <artifactId>jackson-module-jaxb-annotations</artifactId>
+ <artifactId>jackson-module-jakarta-xmlbind-annotations</artifactId>
</dependency>
<dependency>
<groupId>org.glassfish.jersey.core</groupId>
</dependency>
<dependency>
<groupId>org.springframework.boot</groupId>
- <artifactId>spring-boot-test</artifactId>
+ <artifactId>spring-boot-starter-test</artifactId>
<scope>test</scope>
</dependency>
<dependency>
</exclusions>
</dependency>
<dependency>
- <groupId>org.apache.httpcomponents</groupId>
- <artifactId>httpclient</artifactId>
+ <groupId>org.apache.httpcomponents.client5</groupId>
+ <artifactId>httpclient5</artifactId>
</dependency>
<dependency>
<groupId>org.apache.tinkerpop</groupId>
import org.springframework.web.context.annotation.RequestScope;
import com.fasterxml.jackson.databind.ObjectMapper;
-import com.fasterxml.jackson.module.jaxb.JaxbAnnotationModule;
+import com.fasterxml.jackson.module.jakarta.xmlbind.JakartaXmlBindAnnotationModule;
@Configuration
public class RestBeanConfig {
@Bean
public ObjectMapper objectMapper() {
ObjectMapper objectMapper = new ObjectMapper();
- objectMapper.registerModule(new JaxbAnnotationModule());
+ objectMapper.registerModule(new JakartaXmlBindAnnotationModule());
return objectMapper;
}
if (supportsTx && counter.incrementAndGet() % batchSize == 0)
graphToWriteTo.tx().commit();
} catch (Exception ex) {
- LOGGER.info(String.format("Error in reading vertex from graphson%s", vertex.toString()));
+ LOGGER.info("Error in reading vertex from graphson%s".formatted(vertex.toString()));
}
});
: cachedOutV.addEdge(e.label(), cachedInV);
e.properties().forEachRemaining(p -> newEdge.property(p.key(), p.value()));
} else {
- LOGGER.debug(String.format("Ghost edges from %s to %s", cachedOutV, cachedInV));
+ LOGGER.debug("Ghost edges from %s to %s".formatted(cachedOutV, cachedInV));
}
if (supportsTx && counter.incrementAndGet() % batchSize == 0)
graphToWriteTo.tx().commit();
} catch (Exception ex) {
- LOGGER.info(String.format("Error in writing vertex into graph%s", e.toString()));
+ LOGGER.info("Error in writing vertex into graph%s".formatted(e.toString()));
}
}));
final JsonNode root = mapper.readTree(inputStream);
final JsonNode vertices = root.get(GraphSONTokens.VERTICES);
if (!vertices.getNodeType().equals(JsonNodeType.ARRAY))
- throw new IOException(String.format("The '%s' key must be an array", GraphSONTokens.VERTICES));
+ throw new IOException("The '%s' key must be an array".formatted(GraphSONTokens.VERTICES));
return IteratorUtils.stream(vertices.elements()).map(Object::toString);
} else {
final BufferedReader br = new BufferedReader(new InputStreamReader(inputStream));
transaction.tx().commit();
logger.info("Snapshot loaded to inmemory graph.");
} catch (Exception e) {
- logger.info(String.format("ERROR: Could not load datasnapshot to in memory graph. %n%s",
+ logger.info("ERROR: Could not load datasnapshot to in memory graph. %n%s".formatted(
ExceptionUtils.getStackTrace(e)));
throw new RuntimeException(e);
}
}
} catch (Exception e) {
- LOGGER.error(String.format("ERROR: Could not load datasnapshot to in memory graph. %n%s",
+ LOGGER.error("ERROR: Could not load datasnapshot to in memory graph. %n%s".formatted(
LogFormatTools.getStackTop(e)));
throw new IllegalStateException("Could not load datasnapshot to in memory graph");
*/
package org.onap.aai.domain.notificationEvent;
-import javax.xml.bind.annotation.*;
+import jakarta.xml.bind.annotation.*;
import com.fasterxml.jackson.annotation.JsonProperty;
package org.onap.aai.domain.notificationEvent;
-import javax.xml.bind.annotation.XmlRegistry;
+import jakarta.xml.bind.annotation.XmlRegistry;
/**
* This object contains factory methods for each
package org.onap.aai.domain.responseMessage;
-import javax.xml.bind.annotation.*;
+import jakarta.xml.bind.annotation.*;
@XmlAccessorType(XmlAccessType.FIELD)
@XmlType(
import java.util.ArrayList;
import java.util.List;
-import javax.xml.bind.annotation.*;
+import jakarta.xml.bind.annotation.*;
@XmlAccessorType(XmlAccessType.FIELD)
@XmlType(name = "", propOrder = {"aaiResponseMessageDatum", "any"})
package org.onap.aai.domain.responseMessage;
-import javax.xml.bind.annotation.*;
+import jakarta.xml.bind.annotation.*;
@XmlAccessorType(XmlAccessType.FIELD)
@XmlType(name = "", propOrder = {"aaiResponseMessageDatumKey", "aaiResponseMessageDatumValue",
import java.util.ArrayList;
import java.util.List;
-import javax.xml.bind.annotation.*;
+import jakarta.xml.bind.annotation.*;
/**
* <p>
// Generated on: 2015.06.15 at 03:03:58 PM EDT
//
-@javax.xml.bind.annotation.XmlSchema(
+@jakarta.xml.bind.annotation.XmlSchema(
namespace = "http://org.onap.aai.inventory",
- elementFormDefault = javax.xml.bind.annotation.XmlNsForm.QUALIFIED)
+ elementFormDefault = jakarta.xml.bind.annotation.XmlNsForm.QUALIFIED)
package org.onap.aai.domain.responseMessage;
import java.util.ArrayList;
import java.util.List;
-import javax.xml.bind.annotation.XmlAccessType;
-import javax.xml.bind.annotation.XmlAccessorType;
-import javax.xml.bind.annotation.XmlRootElement;
-import javax.xml.bind.annotation.XmlType;
+import jakarta.xml.bind.annotation.XmlAccessType;
+import jakarta.xml.bind.annotation.XmlAccessorType;
+import jakarta.xml.bind.annotation.XmlRootElement;
+import jakarta.xml.bind.annotation.XmlType;
/**
* <p>
package org.onap.aai.domain.translog;
-import javax.xml.bind.annotation.*;
+import jakarta.xml.bind.annotation.*;
import org.eclipse.persistence.oxm.annotations.XmlCDATA;
import java.util.ArrayList;
import java.util.HashMap;
-import javax.servlet.http.HttpServletRequest;
-import javax.ws.rs.core.HttpHeaders;
-import javax.ws.rs.core.UriInfo;
+import jakarta.servlet.http.HttpServletRequest;
+import jakarta.ws.rs.core.HttpHeaders;
+import jakarta.ws.rs.core.UriInfo;
import org.apache.tinkerpop.gremlin.structure.Graph;
import org.apache.tinkerpop.gremlin.structure.Vertex;
// -----------------------------------------------------------------------
// postExtErrorCallback | java.lang.reflect.Method (RW)
// -----------------------------------------------------------------------
- // servletRequest | javax.servlet.http.HttpServletRequest (RO)
+ // servletRequest | jakarta.servlet.http.HttpServletRequest (RO)
// -----------------------------------------------------------------------
- // headers | javax.ws.rs.core.HttpHeaders (RO)
+ // headers | jakarta.ws.rs.core.HttpHeaders (RO)
// -----------------------------------------------------------------------
// objFromRequestType | String (ex. ?org.onap.aai.domain.yang.Vce?) (RO)
// -----------------------------------------------------------------------
import java.util.Set;
import java.util.stream.Collectors;
-import javax.xml.bind.JAXBException;
-import javax.xml.bind.Unmarshaller;
+import jakarta.xml.bind.JAXBException;
+import jakarta.xml.bind.Unmarshaller;
import javax.xml.transform.stream.StreamSource;
import org.eclipse.persistence.dynamic.DynamicEntity;
/**
* {@inheritDoc}
- *
+ *
* @throws AAIUnknownObjectException
*/
@Override
import java.util.Map.Entry;
import java.util.Set;
-import javax.xml.bind.JAXBException;
-import javax.xml.bind.Marshaller;
+import jakarta.xml.bind.JAXBException;
+import jakarta.xml.bind.Marshaller;
import org.eclipse.persistence.descriptors.ClassDescriptor;
import org.eclipse.persistence.dynamic.DynamicEntity;
package org.onap.aai.introspection.exceptions;
+import java.io.Serial;
+
import org.onap.aai.exceptions.AAIException;
public class AAIUnknownObjectException extends AAIException {
+ @Serial
private static final long serialVersionUID = -504200228742133774L;
public AAIUnknownObjectException() {
package org.onap.aai.introspection.exceptions;
+import java.io.Serial;
+
import org.onap.aai.exceptions.AAIException;
public class AAIUnmarshallingException extends AAIException {
+ @Serial
private static final long serialVersionUID = -5615651557821878103L;
private static final String AAI_MSG = "AAI_3000";
import java.util.Objects;
import java.util.Optional;
-import javax.ws.rs.core.MultivaluedMap;
+import jakarta.ws.rs.core.MultivaluedMap;
import org.apache.tinkerpop.gremlin.structure.Vertex;
import org.onap.aai.exceptions.AAIException;
import java.util.Optional;
import java.util.regex.Matcher;
-import javax.ws.rs.core.MultivaluedMap;
+import jakarta.ws.rs.core.MultivaluedMap;
import org.apache.tinkerpop.gremlin.structure.Vertex;
import org.onap.aai.db.props.AAIProperties;
import java.util.Map.Entry;
import java.util.Optional;
-import javax.ws.rs.core.MultivaluedMap;
+import jakarta.ws.rs.core.MultivaluedMap;
import org.apache.tinkerpop.gremlin.structure.Vertex;
import org.onap.aai.db.props.AAIProperties;
import java.util.Map.Entry;
import java.util.Optional;
-import javax.ws.rs.core.MultivaluedMap;
+import jakarta.ws.rs.core.MultivaluedMap;
import org.apache.tinkerpop.gremlin.structure.Edge;
import org.apache.tinkerpop.gremlin.structure.Vertex;
Multimap<String, EdgeRule> edgeRulesMap = edgeIngestor.getRules(edgeQuery);
if (edgeRulesMap.isEmpty()) {
- String message = String.format("Unable to find edge between %s and %s", obj.getName(),
+ String message = "Unable to find edge between %s and %s".formatted(obj.getName(),
otherVProperty.value().toString());
throw new AAIException("AAI_6127", message);
} else if (edgeRulesMap.size() > 1) {
- String message = String.format("Found multiple edges between %s and %s", obj.getName(),
+ String message = "Found multiple edges between %s and %s".formatted(obj.getName(),
otherVProperty.value().toString());
throw new EdgeMultiplicityException(message);
}
package org.onap.aai.introspection.sideeffect.exceptions;
+import java.io.Serial;
+
import org.onap.aai.exceptions.AAIException;
public class AAIMissingRequiredPropertyException extends AAIException {
+ @Serial
private static final long serialVersionUID = -8907079650472014019L;
public AAIMissingRequiredPropertyException() {
package org.onap.aai.introspection.sideeffect.exceptions;
+import java.io.Serial;
+
import org.onap.aai.exceptions.AAIException;
public class AAIMultiplePropertiesException extends AAIException {
+ @Serial
private static final long serialVersionUID = 2098371383166008345L;
public AAIMultiplePropertiesException() {
package org.onap.aai.parsers.exceptions;
+import java.io.Serial;
+
import org.onap.aai.exceptions.AAIException;
public class AAIIdentityMapParseException extends AAIException {
+ @Serial
private static final long serialVersionUID = -888876613879411865L;
public AAIIdentityMapParseException(String message) {
package org.onap.aai.parsers.exceptions;
+import java.io.Serial;
+
import org.onap.aai.exceptions.AAIException;
public class AmbiguousMapAAIException extends AAIException {
+ @Serial
private static final long serialVersionUID = -878581771971431246L;
public AmbiguousMapAAIException(String message) {
package org.onap.aai.parsers.exceptions;
+import java.io.Serial;
+
import org.onap.aai.exceptions.AAIException;
public class DoesNotStartWithValidNamespaceException extends AAIException {
+ @Serial
private static final long serialVersionUID = -888876613879411865L;
public DoesNotStartWithValidNamespaceException(String message) {
import java.util.*;
import java.util.Map.Entry;
-import javax.ws.rs.core.MultivaluedMap;
+import jakarta.ws.rs.core.MultivaluedMap;
import org.onap.aai.edges.enums.EdgeType;
import org.onap.aai.exceptions.AAIException;
import java.io.UnsupportedEncodingException;
import java.net.URI;
-import javax.ws.rs.core.MultivaluedMap;
+import jakarta.ws.rs.core.MultivaluedMap;
import org.onap.aai.exceptions.AAIException;
import org.onap.aai.introspection.Introspector;
import java.io.UnsupportedEncodingException;
import java.net.URI;
-import javax.ws.rs.core.MultivaluedMap;
+import jakarta.ws.rs.core.MultivaluedMap;
import org.onap.aai.exceptions.AAIException;
import org.onap.aai.introspection.Introspector;
import java.io.UnsupportedEncodingException;
import java.net.URI;
-import javax.ws.rs.core.MultivaluedMap;
+import jakarta.ws.rs.core.MultivaluedMap;
import org.onap.aai.exceptions.AAIException;
import org.onap.aai.introspection.Introspector;
import java.io.UnsupportedEncodingException;
import java.net.URI;
-import javax.ws.rs.core.MultivaluedMap;
-import javax.ws.rs.core.UriBuilder;
+import jakarta.ws.rs.core.MultivaluedMap;
+import jakarta.ws.rs.core.UriBuilder;
import org.onap.aai.edges.enums.EdgeType;
import org.onap.aai.exceptions.AAIException;
import java.util.List;
import java.util.Optional;
-import javax.ws.rs.core.UriBuilder;
+import jakarta.ws.rs.core.UriBuilder;
import org.apache.tinkerpop.gremlin.structure.Direction;
import org.onap.aai.config.SpringContextAware;
package org.onap.aai.parsers.uri;
-import javax.ws.rs.core.MultivaluedMap;
+import jakarta.ws.rs.core.MultivaluedMap;
import org.onap.aai.edges.enums.EdgeType;
import org.onap.aai.exceptions.AAIException;
import java.net.URISyntaxException;
import java.util.Set;
-import javax.ws.rs.core.MultivaluedHashMap;
-import javax.ws.rs.core.MultivaluedMap;
-import javax.ws.rs.core.UriBuilder;
+import jakarta.ws.rs.core.MultivaluedHashMap;
+import jakarta.ws.rs.core.MultivaluedMap;
+import jakarta.ws.rs.core.UriBuilder;
import org.onap.aai.edges.enums.EdgeType;
import org.onap.aai.exceptions.AAIException;
import java.util.ArrayList;
import java.util.List;
-import javax.ws.rs.core.MultivaluedMap;
+import jakarta.ws.rs.core.MultivaluedMap;
import org.onap.aai.edges.enums.EdgeType;
import org.onap.aai.exceptions.AAIException;
import java.util.ArrayList;
import java.util.List;
-import javax.ws.rs.core.MultivaluedMap;
+import jakarta.ws.rs.core.MultivaluedMap;
import org.onap.aai.edges.enums.EdgeType;
import org.onap.aai.exceptions.AAIException;
import java.util.List;
import java.util.Map;
-import javax.ws.rs.core.MultivaluedMap;
+import jakarta.ws.rs.core.MultivaluedMap;
import org.onap.aai.edges.enums.EdgeType;
import org.onap.aai.exceptions.AAIException;
import java.net.URISyntaxException;
import java.util.List;
-import javax.ws.rs.core.MultivaluedMap;
+import jakarta.ws.rs.core.MultivaluedMap;
import org.onap.aai.config.SpringContextAware;
import org.onap.aai.edges.enums.EdgeType;
package org.onap.aai.parsers.uri;
-import javax.ws.rs.core.MultivaluedMap;
+import jakarta.ws.rs.core.MultivaluedMap;
import org.onap.aai.edges.enums.EdgeType;
import org.onap.aai.exceptions.AAIException;
import java.util.regex.Pattern;
import java.util.stream.Collectors;
-import javax.annotation.PostConstruct;
+import jakarta.annotation.PostConstruct;
-import org.apache.http.conn.ConnectTimeoutException;
+import org.apache.hc.client5.http.ConnectTimeoutException;
import org.onap.aai.domain.notificationEvent.NotificationEvent;
import org.onap.aai.domain.notificationEvent.NotificationEvent.EventHeader;
import org.onap.aai.exceptions.AAIException;
// resources microservice shouldn't be blocked because of validation service
// is taking too long or if the validation service is down
// Any other exception it should block the request from passing?
- if (e.getCause() instanceof SocketTimeoutException) {
+ if (e.getCause() instanceof ConnectTimeoutException) {
+ LOGGER.error(CONNECTION_TIMEOUT_STRING, e.getCause());
+ } else if (e.getCause() instanceof SocketTimeoutException) {
LOGGER.error(REQUEST_TIMEOUT_STRING, e.getCause());
} else if (e.getCause() instanceof ConnectException) {
LOGGER.error(CONNECTION_REFUSED_STRING, e.getCause());
- } else if (e.getCause() instanceof ConnectTimeoutException) {
- LOGGER.error(CONNECTION_TIMEOUT_STRING, e.getCause());
} else {
LOGGER.error("Unknown exception thrown please investigate", e.getCause());
}
protected HttpComponentsClientHttpRequestFactory getHttpRequestFactory() throws Exception {
HttpComponentsClientHttpRequestFactory requestFactory = super.getHttpRequestFactory();
requestFactory.setConnectionRequestTimeout(timeout);
+ // Manual migration to `SocketConfig.Builder.setSoTimeout(Timeout)` necessary; see: https://docs.spring.io/spring-framework/docs/6.0.0/javadoc-api/org/springframework/http/client/HttpComponentsClientHttpRequestFactory.html#setReadTimeout(int)
requestFactory.setReadTimeout(timeout);
requestFactory.setConnectTimeout(timeout);
return requestFactory;
protected HttpComponentsClientHttpRequestFactory getHttpRequestFactory() throws Exception {
HttpComponentsClientHttpRequestFactory requestFactory = super.getHttpRequestFactory();
requestFactory.setConnectionRequestTimeout(timeout);
+ // Manual migration to `SocketConfig.Builder.setSoTimeout(Timeout)` necessary; see: https://docs.spring.io/spring-framework/docs/6.0.0/javadoc-api/org/springframework/http/client/HttpComponentsClientHttpRequestFactory.html#setReadTimeout(int)
requestFactory.setReadTimeout(timeout);
requestFactory.setConnectTimeout(timeout);
return requestFactory;
protected HttpComponentsClientHttpRequestFactory getHttpRequestFactory() throws Exception {
HttpComponentsClientHttpRequestFactory requestFactory = super.getHttpRequestFactory();
requestFactory.setConnectionRequestTimeout(timeout);
+ // Manual migration to `SocketConfig.Builder.setSoTimeout(Timeout)` necessary; see: https://docs.spring.io/spring-framework/docs/6.0.0/javadoc-api/org/springframework/http/client/HttpComponentsClientHttpRequestFactory.html#setReadTimeout(int)
requestFactory.setReadTimeout(timeout);
requestFactory.setConnectTimeout(timeout);
return requestFactory;
if (value instanceof String) {// "true"
bValue = Boolean.valueOf(value.toString());
- } else if (value instanceof Boolean) {// true
- bValue = (Boolean) value;
+ } else if (value instanceof Boolean boolean1) {// true
+ bValue = boolean1;
}
this.vertexHas(key, bValue);
} else if (vertices instanceof Vertex) {
results = Collections.singletonList((E) vertices);
} else {
- String msg = String.format("Results must be a list or a vertex, but was %s", vertices.getClass().getName());
+ String msg = "Results must be a list or a vertex, but was %s".formatted(vertices.getClass().getName());
LOGGER.error(msg);
throw new IllegalArgumentException(msg);
}
}
private long parseCount(Object count) {
- if(count instanceof String) {
- return Long.parseLong((String) count);
- } else if(count instanceof Integer) {
- return Long.valueOf((int) count);
- } else if (count instanceof Long) {
- return (long) count;
+ if(count instanceof String string) {
+ return Long.parseLong(string);
+ } else if(count instanceof Integer integer) {
+ return Long.valueOf(integer);
+ } else if (count instanceof Long long1) {
+ return long1;
} else {
throw new IllegalArgumentException("Count must be a string, integer, or long");
}
boolean bValue = false;
if (value instanceof String) {
bValue = Boolean.valueOf(value.toString());
- } else if (value instanceof Boolean) {
- bValue = (Boolean) value;
+ } else if (value instanceof Boolean boolean1) {
+ bValue = boolean1;
}
this.vertexHas(key, bValue);
import java.util.ArrayList;
import java.util.List;
-import javax.ws.rs.core.MultivaluedMap;
+import jakarta.ws.rs.core.MultivaluedMap;
import org.apache.tinkerpop.gremlin.process.traversal.dsl.graph.GraphTraversalSource;
import org.apache.tinkerpop.gremlin.structure.Vertex;
import java.util.ArrayList;
import java.util.List;
-import javax.ws.rs.core.MultivaluedMap;
+import jakarta.ws.rs.core.MultivaluedMap;
import org.apache.tinkerpop.gremlin.process.traversal.dsl.graph.GraphTraversalSource;
import org.apache.tinkerpop.gremlin.structure.Vertex;
import java.util.ArrayList;
import java.util.List;
-import javax.ws.rs.core.MultivaluedMap;
+import jakarta.ws.rs.core.MultivaluedMap;
import org.apache.tinkerpop.gremlin.process.traversal.dsl.graph.GraphTraversalSource;
import org.apache.tinkerpop.gremlin.structure.Vertex;
import java.util.List;
import java.util.Map;
-import javax.ws.rs.core.MultivaluedMap;
+import jakarta.ws.rs.core.MultivaluedMap;
import org.apache.tinkerpop.gremlin.process.traversal.Path;
import org.apache.tinkerpop.gremlin.process.traversal.Pop;
import java.util.List;
import java.util.stream.Collectors;
-import javax.ws.rs.core.MultivaluedMap;
+import jakarta.ws.rs.core.MultivaluedMap;
import org.apache.tinkerpop.gremlin.process.traversal.Step;
import org.apache.tinkerpop.gremlin.process.traversal.dsl.graph.GraphTraversal;
: start;
for (int i = start; i < end - 1; i++) {
Step step = steps.get(start);
- if (step instanceof HasStep) {
- List<HasContainer> hasContainers = ((HasStep) step).getHasContainers();
+ if (step instanceof HasStep hasStep) {
+ List<HasContainer> hasContainers = hasStep.getHasContainers();
int hasContainerSize = hasContainers.size();
boolean isEndWithinHasContainer = isEndWithinHasContainer(end, i, hasContainers);
if (isEndWithinHasContainer) {
int adjustedIndex = start;
for (int i = 0; i < start; i++) {
Step step = steps.get(i);
- if (step instanceof HasStep) {
- if(isEndWithinHasContainer(adjustedIndex, i, ((HasStep) step).getHasContainers())){
+ if (step instanceof HasStep hasStep) {
+ if(isEndWithinHasContainer(adjustedIndex, i, hasStep.getHasContainers())){
adjustedIndex -= 1;
}
- adjustedIndex -= ((HasStep) step).getHasContainers().size();
+ adjustedIndex -= hasStep.getHasContainers().size();
}
}
return adjustedIndex;
for (int i = adjustedIndex; i < steps.size(); i++) {
Step step = steps.get(i);
boolean isFirstStep = i == adjustedIndex;
- if (isFirstStep && step instanceof HasStep) {
+ if (isFirstStep && step instanceof HasStep<?> hasStep) {
int splitPosition = indexAndStepCountTuple.getValue();
- List<HasContainer> newContainers = ((HasStep<?>) step).getHasContainers().stream()
+ List<HasContainer> newContainers = hasStep.getHasContainers().stream()
.skip(splitPosition)
.collect(Collectors.toList());
traversalAdminStart
int stepCount = 0;
for (int j = 0; j <= lastURIStepIndex; j++) {
Step step = steps.get(j);
- if (step instanceof HasStep) {
- stepCount += ((HasStep<?>) step).getHasContainers().size();
+ if (step instanceof HasStep<?> hasStep) {
+ stepCount += hasStep.getHasContainers().size();
} else {
stepCount++;
}
import java.net.URI;
import java.util.Optional;
-import javax.ws.rs.core.HttpHeaders;
-import javax.ws.rs.core.UriInfo;
+import jakarta.ws.rs.core.HttpHeaders;
+import jakarta.ws.rs.core.UriInfo;
import org.onap.aai.aailog.logs.DBRequestWrapper;
import org.onap.aai.introspection.Introspector;
import java.util.*;
import java.util.stream.Collectors;
-import javax.ws.rs.core.*;
-import javax.ws.rs.core.Response.Status;
+import jakarta.ws.rs.core.*;
+import jakarta.ws.rs.core.Response.Status;
import org.apache.tinkerpop.gremlin.structure.Vertex;
import org.janusgraph.core.JanusGraphException;
// The format is purposefully %s/%s%s due to the fact
// that every aai-uri will have a slash at the beginning
// If that assumption isn't true, then its best to change this code
- String curUri = String.format("%s/%s%s", basePath, version, entry.getKey());
+ String curUri = "%s/%s%s".formatted(basePath, version, entry.getKey());
Introspector curObj = entry.getValue().getValue0();
HashMap<String, Introspector> curObjRelated = entry.getValue().getValue1();
notification.createNotificationEvent(transactionId, sourceOfTruth,
import java.util.Set;
import java.util.stream.Collectors;
-import javax.ws.rs.core.Response.Status;
+import jakarta.ws.rs.core.Response.Status;
import org.apache.tinkerpop.gremlin.structure.Vertex;
import org.onap.aai.db.props.AAIProperties;
Introspector curObj = serializer.getLatestVersionView(vertex, eventDepth);
String aaiUri = vertex.<String>property(AAIProperties.AAI_URI).value();
- String uri = String.format("%s/%s%s", basePath, schemaVersion, aaiUri);
+ String uri = "%s/%s%s".formatted(basePath, schemaVersion, aaiUri);
HashMap<String, Introspector> curRelatedObjs = new HashMap<>();
if (!curObj.isTopLevel()) {
curRelatedObjs = serializer.getRelatedObjects(queryEngine, vertex, curObj, loaderFactory.getMoxyLoaderInstance().get(schemaVersion));
import java.util.List;
import java.util.Map;
-import javax.ws.rs.core.Response.Status;
+import jakarta.ws.rs.core.Response.Status;
import org.onap.aai.domain.notificationEvent.NotificationEvent;
import org.onap.aai.domain.notificationEvent.NotificationEvent.EventHeader;
import com.fasterxml.jackson.databind.DeserializationFeature;
import com.fasterxml.jackson.databind.ObjectMapper;
import com.fasterxml.jackson.databind.SerializationFeature;
-import com.fasterxml.jackson.jaxrs.json.JacksonJaxbJsonProvider;
-import com.fasterxml.jackson.module.jaxb.JaxbAnnotationModule;
+import com.fasterxml.jackson.jakarta.rs.json.JacksonXmlBindJsonProvider;
+import com.fasterxml.jackson.module.jakarta.xmlbind.JakartaXmlBindAnnotationModule;
-import javax.ws.rs.ext.Provider;
+import jakarta.ws.rs.ext.Provider;
/**
* The Class CustomJacksonJaxBJsonProvider.
*/
@Provider
-public class CustomJacksonJaxBJsonProvider extends JacksonJaxbJsonProvider {
+public class CustomJacksonJaxBJsonProvider extends JacksonXmlBindJsonProvider {
private static ObjectMapper commonMapper = null;
mapper.configure(DeserializationFeature.FAIL_ON_UNKNOWN_PROPERTIES, false);
mapper.configure(DeserializationFeature.UNWRAP_ROOT_VALUE, false);
- mapper.registerModule(new JaxbAnnotationModule());
+ mapper.registerModule(new JakartaXmlBindAnnotationModule());
commonMapper = mapper;
}
import java.util.concurrent.TimeUnit;
import java.util.concurrent.TimeoutException;
-import javax.ws.rs.core.HttpHeaders;
-import javax.ws.rs.core.MediaType;
-import javax.ws.rs.core.Response;
-import javax.ws.rs.core.UriInfo;
+import jakarta.ws.rs.core.HttpHeaders;
+import jakarta.ws.rs.core.MediaType;
+import jakarta.ws.rs.core.Response;
+import jakarta.ws.rs.core.UriInfo;
import org.onap.aai.db.props.AAIProperties;
import org.onap.aai.exceptions.AAIException;
response = handler.get(timeoutLimit, TimeUnit.MILLISECONDS);
} catch (TimeoutException e) {
AAIException ex = new AAIException("AAI_7406",
- String.format("Timeout limit of %s seconds reached.", timeoutLimit / 1000));
+ "Timeout limit of %s seconds reached.".formatted(timeoutLimit / 1000));
response = consumerExceptionResponseGenerator(headers, info, method, ex);
handler.cancel(true);
} catch (InterruptedException e) {
import java.util.regex.Matcher;
import java.util.regex.Pattern;
-import javax.ws.rs.core.MultivaluedHashMap;
-import javax.ws.rs.core.MultivaluedMap;
+import jakarta.ws.rs.core.MultivaluedHashMap;
+import jakarta.ws.rs.core.MultivaluedMap;
import org.onap.aai.introspection.Introspector;
import org.onap.aai.introspection.sideeffect.exceptions.AAIMissingRequiredPropertyException;
import java.util.regex.Matcher;
import java.util.regex.Pattern;
-import javax.ws.rs.core.UriBuilder;
+import jakarta.ws.rs.core.UriBuilder;
import org.apache.commons.lang3.StringUtils;
import org.apache.tinkerpop.gremlin.process.traversal.Path;
List<Vertex> results = parser.getQueryBuilder().toList();
if (results.isEmpty()) {
final AAIException ex =
- new AAIException(AAI_6129, String.format("Node of type %s. Could not find object at: %s",
+ new AAIException(AAI_6129, "Node of type %s. Could not find object at: %s".formatted(
parser.getResultType(), parser.getUri()));
ex.getTemplateVars().add(parser.getResultType());
ex.getTemplateVars().add(parser.getUri().toString());
// rule
}
throw new AAIException("AAI_6120",
- String.format("No EdgeRule found for passed nodeTypes: %s, %s.", aNodeType, bNodeType));
+ "No EdgeRule found for passed nodeTypes: %s, %s.".formatted(aNodeType, bNodeType));
} else {
try {
final List<EdgeRule> rules = new ArrayList<>(edgeIngestor.getRules(ruleQuery).values());
if (!edgeRules.hasRule(baseQ.build())) {
throw new AAIException("AAI_6120",
- String.format("No EdgeRule found for passed nodeTypes: %s, %s%s.", aNodeType, cousinType,
+ "No EdgeRule found for passed nodeTypes: %s, %s%s.".formatted(aNodeType, cousinType,
label != null ? (" with label " + label) : ""));
} else if (edgeRules.hasRule(baseQ.edgeType(EdgeType.TREE).build())
&& !edgeRules.hasRule(baseQ.edgeType(EdgeType.COUSIN).build())) {
package org.onap.aai.serialization.db;
+import java.io.Serial;
import java.util.HashMap;
import java.util.regex.Matcher;
import java.util.regex.Pattern;
public class EdgePropertyMap<K, V> extends HashMap<K, V> {
+ @Serial
private static final long serialVersionUID = -8298355506617458683L;
private static final Pattern variablePattern = Pattern.compile("(!)?\\$\\{(\\w+)\\}");
package org.onap.aai.serialization.db.exceptions;
+import java.io.Serial;
+
import org.onap.aai.exceptions.AAIException;
public class EdgeMultiplicityException extends AAIException {
+ @Serial
private static final long serialVersionUID = -5575661036426538012L;
public EdgeMultiplicityException(String message) {
package org.onap.aai.serialization.db.exceptions;
+import java.io.Serial;
+
import org.onap.aai.exceptions.AAIException;
public class MultipleEdgeRuleFoundException extends AAIException {
+ @Serial
private static final long serialVersionUID = -906843868234976763L;
public MultipleEdgeRuleFoundException(String message) {
package org.onap.aai.serialization.db.exceptions;
+import java.io.Serial;
+
import org.onap.aai.exceptions.AAIException;
public class NoEdgeRuleFoundException extends AAIException {
+ @Serial
private static final long serialVersionUID = -906843868234976763L;
public NoEdgeRuleFoundException(String message) {
JsonArray inner = new JsonArray();
for (Vertex o : (ArrayList<Vertex>) l) {
if (o instanceof Vertex) {
- Optional<JsonObject> obj = this.getJsonFromVertex((Vertex) o, properties);
+ Optional<JsonObject> obj = this.getJsonFromVertex(o, properties);
if (obj.isPresent()) {
inner.add(obj.get());
} else {
Pair<String, Long> pair = null;
- if (o instanceof Vertex) {
- Vertex v = (Vertex) o;
+ if (o instanceof Vertex v) {
pair = Pair.with(v.property(AAIProperties.NODE_TYPE).value().toString(), 1L);
} else if (o instanceof Tree) {
pair = Pair.with("trees", 1L);
} else if (o instanceof Path) {
pair = Pair.with("paths", 1L);
- } else if (o instanceof Long) {
- pair = Pair.with("count", (Long) o);
+ } else if (o instanceof Long long1) {
+ pair = Pair.with("count", long1);
}
if (pair == null) {
package org.onap.aai.serialization.queryformats;
-import javax.ws.rs.core.MultivaluedHashMap;
-import javax.ws.rs.core.MultivaluedMap;
+import jakarta.ws.rs.core.MultivaluedHashMap;
+import jakarta.ws.rs.core.MultivaluedMap;
import org.onap.aai.exceptions.AAIException;
import org.onap.aai.introspection.Loader;
import java.util.Optional;
import java.util.stream.Stream;
-import javax.ws.rs.core.MultivaluedMap;
+import jakarta.ws.rs.core.MultivaluedMap;
import org.onap.aai.logging.LogFormatTools;
import org.onap.aai.serialization.queryformats.exceptions.AAIFormatQueryResultFormatNotSupported;
}
protected JsonObject mapPropertyValues(JsonObject json, String propertyKey, Object propertyValue) {
- if (propertyValue instanceof String) {
- json.addProperty(propertyKey, (String) propertyValue);
- } else if (propertyValue instanceof Boolean) {
- json.addProperty(propertyKey, (Boolean) propertyValue);
- } else if (propertyValue instanceof Number) {
- json.addProperty(propertyKey, (Number) propertyValue);
+ if (propertyValue instanceof String string) {
+ json.addProperty(propertyKey, string);
+ } else if (propertyValue instanceof Boolean boolean1) {
+ json.addProperty(propertyKey, boolean1);
+ } else if (propertyValue instanceof Number number) {
+ json.addProperty(propertyKey, number);
} else {
if (!(propertyValue instanceof List)) {
return json;
import java.util.Map;
import java.util.Optional;
-import javax.ws.rs.core.MultivaluedMap;
+import jakarta.ws.rs.core.MultivaluedMap;
import org.apache.tinkerpop.gremlin.structure.Vertex;
import org.onap.aai.db.props.AAIProperties;
@Override
public Optional<JsonObject> formatObject(Object input)
throws AAIFormatVertexException, AAIFormatQueryResultFormatNotSupported {
- if (input instanceof Vertex) {
+ if (input instanceof Vertex vertex) {
logger.debug("Formatting vertex object");
- return this.getJsonFromVertex((Vertex) input);
- } else if (input instanceof Tree) {
+ return this.getJsonFromVertex(vertex);
+ } else if (input instanceof Tree<?> tree) {
logger.debug("Formatting tree object");
if (isTree) {
- return this.getRelatedNodesFromTree((Tree<?>) input, null);
+ return this.getRelatedNodesFromTree(tree, null);
} else {
- return this.getJsonFromTree((Tree<?>) input);
+ return this.getJsonFromTree(tree);
}
- } else if (input instanceof Path) {
+ } else if (input instanceof Path path) {
logger.debug("Formatting path object");
- return this.getJsonFromPath((Path) input);
+ return this.getJsonFromPath(path);
} else {
throw new AAIFormatQueryResultFormatNotSupported();
}
@Override
public Optional<JsonObject> formatObject(Object input, Map<String, List<String>> properties)
throws AAIFormatVertexException, AAIFormatQueryResultFormatNotSupported {
- if (input instanceof Vertex) {
+ if (input instanceof Vertex vertex) {
logger.debug("Formatting vertex object with properties map filter");
- return this.getJsonFromVertex((Vertex) input, properties);
- } else if (input instanceof Tree) {
+ return this.getJsonFromVertex(vertex, properties);
+ } else if (input instanceof Tree<?> tree) {
logger.debug("Formatting tree object with properties map filter");
if (isTree) {
- return this.getRelatedNodesFromTree((Tree<?>) input, properties);
+ return this.getRelatedNodesFromTree(tree, properties);
} else {
- return this.getJsonFromTree((Tree<?>) input);
+ return this.getJsonFromTree(tree);
}
- } else if (input instanceof Path) {
+ } else if (input instanceof Path path) {
logger.debug("Formatting path object");
- return this.getJsonFromPath((Path) input);
+ return this.getJsonFromPath(path);
} else {
throw new AAIFormatQueryResultFormatNotSupported();
}
JsonArray ja = new JsonArray();
for (Object o : path) {
- if (o instanceof Vertex) {
- Optional<JsonObject> obj = this.getJsonFromVertex((Vertex) o);
+ if (o instanceof Vertex vertex) {
+ Optional<JsonObject> obj = this.getJsonFromVertex(vertex);
obj.ifPresent(ja::add);
}
}
import java.util.Map;
import java.util.Optional;
-import javax.ws.rs.core.MultivaluedMap;
+import jakarta.ws.rs.core.MultivaluedMap;
import org.apache.tinkerpop.gremlin.structure.Vertex;
import org.onap.aai.db.props.AAIProperties;
import java.util.Optional;
import java.util.Set;
-import javax.ws.rs.core.MultivaluedMap;
+import jakarta.ws.rs.core.MultivaluedMap;
import org.apache.tinkerpop.gremlin.process.traversal.step.util.Tree;
import org.apache.tinkerpop.gremlin.structure.Vertex;
}
}
// Gremlin Query
- else if (o instanceof Vertex) {
- Optional<JsonObject> obj = this.getJsonFromVertex((Vertex) o);
+ else if (o instanceof Vertex vertex) {
+ Optional<JsonObject> obj = this.getJsonFromVertex(vertex);
if (obj.isPresent()) {
jsonObject = obj.get();
for (Map.Entry<String, JsonElement> mapEntry : jsonObject.entrySet()) {
for (Map.Entry<Object, Tree<Object>> entry : tree.entrySet()) {
Object o = entry.getKey();
- if (o instanceof Vertex) {
- processVertex(relatedNodes, entry, (Vertex) o);
+ if (o instanceof Vertex vertex) {
+ processVertex(relatedNodes, entry, vertex);
}
}
return Optional.of(relatedNodes);
package org.onap.aai.serialization.queryformats.exceptions;
+import java.io.Serial;
+
public class AAIFormatQueryResultFormatNotSupported extends Exception {
+ @Serial
private static final long serialVersionUID = -5814240842844624097L;
public AAIFormatQueryResultFormatNotSupported() {
package org.onap.aai.serialization.queryformats.exceptions;
+import java.io.Serial;
+
public class AAIFormatVertexException extends Exception {
+ @Serial
private static final long serialVersionUID = -5814240841844624097L;
public AAIFormatVertexException() {
package org.onap.aai.serialization.queryformats.exceptions;
+import java.io.Serial;
+
import org.onap.aai.exceptions.AAIException;
public class QueryParamInjectionException extends AAIException {
+ @Serial
private static final long serialVersionUID = -5575661036426538012L;
public QueryParamInjectionException(String message) {
import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;
-import javax.ws.rs.core.MultivaluedMap;
+import jakarta.ws.rs.core.MultivaluedMap;
import org.onap.aai.serialization.queryformats.exceptions.QueryParamInjectionException;
import org.onap.aai.serialization.queryformats.params.*;
package org.onap.aai.serialization.tinkerpop;
+import java.io.Serial;
import java.util.Iterator;
import org.apache.tinkerpop.gremlin.structure.Direction;
* These objects are not mutable and can only be used to read information out.
*
*/
-public class TreeBackedEdge extends DetachedEdge implements Edge {
+public class TreeBackedEdge extends DetachedEdge {
+ @Serial
private static final long serialVersionUID = 5419650145562077538L;
private TreeBackedVertex inVertex;
private TreeBackedVertex outVertex;
package org.onap.aai.serialization.tinkerpop;
+import java.io.Serial;
import java.util.ArrayList;
import java.util.Collections;
import java.util.Iterator;
*
*/
-public class TreeBackedVertex extends DetachedVertex implements Vertex {
+public class TreeBackedVertex extends DetachedVertex {
+ @Serial
private static final long serialVersionUID = -976854460992756953L;
private final transient Tree<Element> tree;
private final transient Vertex self;
package org.onap.aai.service;
-import javax.annotation.PostConstruct;
+import jakarta.annotation.PostConstruct;
import org.onap.aai.validation.nodes.NodeValidator;
import org.slf4j.Logger;
import java.util.List;
import java.util.Map;
-import javax.annotation.Generated;
+import jakarta.annotation.Generated;
import org.apache.commons.lang3.builder.EqualsBuilder;
import org.apache.commons.lang3.builder.HashCodeBuilder;
import java.util.List;
import java.util.Map;
-import javax.annotation.Generated;
+import jakarta.annotation.Generated;
import org.apache.commons.lang3.builder.EqualsBuilder;
import org.apache.commons.lang3.builder.HashCodeBuilder;
import java.util.HashMap;
import java.util.Map;
-import javax.annotation.Generated;
+import jakarta.annotation.Generated;
import org.apache.commons.lang3.builder.EqualsBuilder;
import org.apache.commons.lang3.builder.HashCodeBuilder;
import com.fasterxml.jackson.databind.SerializationFeature;
import com.fasterxml.jackson.databind.json.JsonMapper;
import com.fasterxml.jackson.datatype.jsr310.JavaTimeModule;
-import com.fasterxml.jackson.module.jaxb.JaxbAnnotationModule;
+import com.fasterxml.jackson.module.jakarta.xmlbind.JakartaXmlBindAnnotationModule;
import com.google.common.base.CaseFormat;
import com.google.common.collect.Multimap;
import java.util.List;
import java.util.Random;
-import javax.xml.bind.JAXBContext;
-import javax.xml.bind.JAXBException;
-import javax.xml.bind.Marshaller;
+import jakarta.xml.bind.JAXBContext;
+import jakarta.xml.bind.JAXBException;
+import jakarta.xml.bind.Marshaller;
import org.apache.commons.io.output.ByteArrayOutputStream;
import org.eclipse.persistence.dynamic.DynamicEntity;
public <T> String getJsonFromObject(T clazz, boolean wrapRoot, boolean indent)
throws JsonGenerationException, JsonMappingException, IOException {
ObjectMapper mapper = JsonMapper.builder()
- .addModule(new JaxbAnnotationModule())
+ .addModule(new JakartaXmlBindAnnotationModule())
.addModule(new JavaTimeModule())
.serializationInclusion(JsonInclude.Include.NON_NULL)
.configure(SerializationFeature.WRITE_DATES_AS_TIMESTAMPS, false)
public AAIJunitRunner(Class<?> klass) throws Throwable {
super(klass);
setProps();
- modifyOxmHome();
+ // modifyOxmHome();
}
public void setProps() {
System.setProperty("BUNDLECONFIG_DIR", "src/test/resources/bundleconfig-local");
}
- public void modifyOxmHome() {
- try {
- Field aaiConstantsField = AAIConstants.class.getField("AAI_HOME_ETC_OXM");
- setFinalStatic(aaiConstantsField, "../aai-schema/src/main/resources/oxm/");
- } catch (Exception e) {
- e.printStackTrace();
- }
- }
-
- public void setFinalStatic(Field field, Object newValue) throws Exception {
- field.setAccessible(true);
- Field modifiersField = Field.class.getDeclaredField("modifiers");
- modifiersField.setAccessible(true);
- modifiersField.setInt(field, field.getModifiers() & ~Modifier.FINAL);
- field.set(null, newValue);
- }
+ // public void modifyOxmHome() {
+ // try {
+ // Field aaiConstantsField = AAIConstants.class.getField("AAI_HOME_ETC_OXM");
+ // setFinalStatic(aaiConstantsField, "../aai-schema/src/main/resources/oxm/");
+ // } catch (Exception e) {
+ // e.printStackTrace();
+ // }
+ // }
}
package org.onap.aai;
+import java.lang.reflect.Field;
import java.util.Map;
import org.junit.BeforeClass;
System.setProperty("AJSC_HOME", ".");
System.setProperty("BUNDLECONFIG_DIR", "src/test/resources/bundleconfig-local");
System.setProperty("aai.service.name", SERVICE_NAME);
- QueryFormatTestHelper.setFinalStatic(AAIConstants.class.getField("AAI_HOME_ETC_OXM"),
- "src/test/resources/bundleconfig-local/etc/oxm/");
+ // Field etcHomeField = AAIConstants.class.getField("AAI_HOME_ETC_OXM");
+ // QueryFormatTestHelper.setFinalStatic(etcHomeField,
+ // "src/test/resources/bundleconfig-local/etc/oxm/");
}
}
System.setProperty("AJSC_HOME", ".");
System.setProperty("BUNDLECONFIG_DIR", "src/test/resources/bundleconfig-local");
System.setProperty("aai.service.name", SERVICE_NAME);
- QueryFormatTestHelper.setFinalStatic(AAIConstants.class.getField("AAI_HOME_ETC_OXM"),
- "src/test/resources/bundleconfig-local/etc/oxm/");
}
}
System.setProperty("AJSC_HOME", ".");
System.setProperty("BUNDLECONFIG_DIR", "src/test/resources/bundleconfig-local");
System.setProperty("aai.service.name", SERVICE_NAME);
- QueryFormatTestHelper.setFinalStatic(AAIConstants.class.getField("AAI_HOME_ETC_OXM"),
- "src/test/resources/bundleconfig-local/etc/oxm/");
}
}
import java.util.Map;
import java.util.UUID;
-import javax.ws.rs.core.HttpHeaders;
-import javax.ws.rs.core.MediaType;
-import javax.ws.rs.core.MultivaluedHashMap;
-import javax.ws.rs.core.MultivaluedMap;
-import javax.ws.rs.core.Response;
-import javax.ws.rs.core.UriBuilder;
-import javax.ws.rs.core.UriInfo;
-
import org.javatuples.Pair;
import org.mockito.Mockito;
import org.onap.aai.config.SpringContextAware;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
+import jakarta.ws.rs.core.HttpHeaders;
+import jakarta.ws.rs.core.MediaType;
+import jakarta.ws.rs.core.MultivaluedHashMap;
+import jakarta.ws.rs.core.MultivaluedMap;
+import jakarta.ws.rs.core.Response;
+import jakarta.ws.rs.core.UriBuilder;
+import jakarta.ws.rs.core.UriInfo;
+
public class HttpTestUtil extends RESTAPI {
protected HttpEntry traversalHttpEntry;
import org.skyscreamer.jsonassert.JSONAssert;
import com.fasterxml.jackson.databind.ObjectMapper;
-import com.fasterxml.jackson.module.jaxb.JaxbAnnotationModule;
+import com.fasterxml.jackson.module.jakarta.xmlbind.JakartaXmlBindAnnotationModule;
public class IntrospectorSerializationTest extends AAISetup {
@Test
public void serializeNotificationEvent() throws IOException, AAIUnmarshallingException {
mapper = new ObjectMapper();
- mapper.registerModule(new JaxbAnnotationModule());
+ mapper.registerModule(new JakartaXmlBindAnnotationModule());
String pserver = new String(Files.readAllBytes(Path.of("src/test/resources/payloads/templates/pserver.json"))).replace("${hostname}", "pserver1");
Introspector introspector = loader.unmarshal("pserver", pserver);
import java.util.List;
import java.util.UUID;
-import javax.ws.rs.core.MultivaluedMap;
+import jakarta.ws.rs.core.MultivaluedMap;
import org.apache.tinkerpop.gremlin.process.traversal.dsl.graph.GraphTraversal;
import org.apache.tinkerpop.gremlin.process.traversal.dsl.graph.GraphTraversalSource;
import java.net.URI;
import java.nio.file.Files;
import java.nio.file.Path;
+import java.time.Duration;
import java.util.ArrayList;
import java.util.Collections;
import java.util.List;
-import javax.ws.rs.core.HttpHeaders;
-import javax.ws.rs.core.MediaType;
-import javax.ws.rs.core.MultivaluedMap;
-import javax.ws.rs.core.UriInfo;
-
import org.apache.kafka.clients.consumer.Consumer;
import org.apache.kafka.clients.consumer.ConsumerRecords;
import org.junit.Before;
import com.fasterxml.jackson.databind.ObjectMapper;
+import jakarta.ws.rs.core.HttpHeaders;
+import jakarta.ws.rs.core.MediaType;
+import jakarta.ws.rs.core.MultivaluedMap;
+import jakarta.ws.rs.core.UriInfo;
import lombok.SneakyThrows;
import lombok.extern.slf4j.Slf4j;
String expectedResponse = PayloadUtil.getExpectedPayload("aai-event.json");
messageProducer.sendNotification(event);
- ConsumerRecords<String, String> consumerRecords = KafkaTestUtils.getRecords(consumer, 10000);
+ ConsumerRecords<String, String> consumerRecords = KafkaTestUtils.getRecords(consumer, Duration.ofSeconds(10));
assertFalse(consumerRecords.isEmpty());
consumerRecords.forEach(consumerRecord -> {
JSONAssert.assertEquals(expectedResponse, consumerRecord.value(), JSONCompareMode.NON_EXTENSIBLE);
traversalUriHttpEntry.process(dbRequests, "test");
- ConsumerRecords<String, String> consumerRecords = KafkaTestUtils.getRecords(consumer, 100000);
+ ConsumerRecords<String, String> consumerRecords = KafkaTestUtils.getRecords(consumer, Duration.ofSeconds(10));
assertFalse(consumerRecords.isEmpty());
String expectedResponse = PayloadUtil.getExpectedPayload("pserver-event.json");
import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertNotNull;
-import javax.ws.rs.core.Response.Status;
+import jakarta.ws.rs.core.Response.Status;
import org.junit.Test;
import java.util.Collection;
import java.util.List;
-import javax.ws.rs.core.MultivaluedHashMap;
-import javax.ws.rs.core.MultivaluedMap;
-import javax.ws.rs.core.UriBuilder;
+import jakarta.ws.rs.core.MultivaluedHashMap;
+import jakarta.ws.rs.core.MultivaluedMap;
+import jakarta.ws.rs.core.UriBuilder;
import org.apache.tinkerpop.gremlin.process.traversal.P;
import org.apache.tinkerpop.gremlin.process.traversal.dsl.graph.GraphTraversal;
import java.io.UnsupportedEncodingException;
import java.net.URI;
-import javax.ws.rs.core.UriBuilder;
-import javax.xml.bind.JAXBException;
-
import org.junit.Ignore;
import org.junit.Test;
import org.onap.aai.AAISetup;
import org.onap.aai.serialization.engines.TransactionalGraphEngine;
import org.onap.aai.setup.SchemaVersion;
+import jakarta.ws.rs.core.UriBuilder;
+import jakarta.xml.bind.JAXBException;
+
@Ignore
public class LegacyQueryTest extends AAISetup {
import java.io.StringReader;
import java.io.UnsupportedEncodingException;
-import javax.xml.bind.JAXBException;
-import javax.xml.bind.Unmarshaller;
+import jakarta.xml.bind.JAXBException;
+import jakarta.xml.bind.Unmarshaller;
import javax.xml.transform.stream.StreamSource;
import org.eclipse.persistence.dynamic.DynamicEntity;
import org.onap.aai.exceptions.AAIException;
import org.onap.aai.introspection.Introspector;
import org.onap.aai.introspection.IntrospectorFactory;
-import org.onap.aai.introspection.LoaderFactory;
import org.onap.aai.introspection.ModelType;
import org.onap.aai.nodes.NodeIngestor;
import org.onap.aai.serialization.engines.JanusGraphDBEngine;
import java.io.StringReader;
import java.io.UnsupportedEncodingException;
-import javax.xml.bind.JAXBException;
-import javax.xml.bind.Unmarshaller;
+import jakarta.xml.bind.JAXBException;
+import jakarta.xml.bind.Unmarshaller;
import javax.xml.transform.stream.StreamSource;
import org.eclipse.persistence.dynamic.DynamicEntity;
import org.onap.aai.exceptions.AAIException;
import org.onap.aai.introspection.Introspector;
import org.onap.aai.introspection.IntrospectorFactory;
-import org.onap.aai.introspection.LoaderFactory;
import org.onap.aai.introspection.ModelType;
import org.onap.aai.serialization.engines.JanusGraphDBEngine;
import org.onap.aai.serialization.engines.QueryStyle;
import java.io.StringReader;
import java.io.UnsupportedEncodingException;
-import javax.xml.bind.JAXBException;
-import javax.xml.bind.Unmarshaller;
+import jakarta.xml.bind.JAXBException;
+import jakarta.xml.bind.Unmarshaller;
import javax.xml.transform.stream.StreamSource;
import org.apache.tinkerpop.gremlin.process.traversal.dsl.graph.GraphTraversal;
import org.onap.aai.exceptions.AAIException;
import org.onap.aai.introspection.Introspector;
import org.onap.aai.introspection.IntrospectorFactory;
-import org.onap.aai.introspection.LoaderFactory;
import org.onap.aai.introspection.ModelType;
import org.onap.aai.nodes.NodeIngestor;
import org.onap.aai.serialization.engines.JanusGraphDBEngine;
import java.io.UnsupportedEncodingException;
import java.net.URI;
-import javax.ws.rs.core.UriBuilder;
+import jakarta.ws.rs.core.UriBuilder;
import org.apache.tinkerpop.gremlin.process.traversal.dsl.graph.GraphTraversal;
import org.apache.tinkerpop.gremlin.process.traversal.dsl.graph.__;
import java.io.UnsupportedEncodingException;
import java.net.URI;
-import javax.annotation.PostConstruct;
-import javax.ws.rs.core.MultivaluedHashMap;
-import javax.ws.rs.core.UriBuilder;
-import javax.xml.bind.JAXBException;
-
import org.junit.Rule;
import org.junit.Test;
import org.junit.rules.ExpectedException;
import org.onap.aai.introspection.ModelType;
import org.onap.aai.setup.SchemaVersion;
+import jakarta.annotation.PostConstruct;
+import jakarta.ws.rs.core.MultivaluedHashMap;
+import jakarta.ws.rs.core.UriBuilder;
+import jakarta.xml.bind.JAXBException;
+
public class URIParserTest extends AAISetup {
import java.io.UnsupportedEncodingException;
import java.net.URI;
-import javax.annotation.PostConstruct;
-import javax.ws.rs.core.UriBuilder;
-import javax.xml.bind.JAXBException;
-
import org.junit.Rule;
import org.junit.Test;
import org.junit.rules.ExpectedException;
import org.onap.aai.AAISetup;
import org.onap.aai.exceptions.AAIException;
import org.onap.aai.introspection.Loader;
-import org.onap.aai.introspection.LoaderFactory;
import org.onap.aai.introspection.ModelType;
import org.onap.aai.parsers.exceptions.DoesNotStartWithValidNamespaceException;
+import jakarta.annotation.PostConstruct;
+import jakarta.ws.rs.core.UriBuilder;
+import jakarta.xml.bind.JAXBException;
+
public class URIToDBKeyTest extends AAISetup {
private Loader loader;
import java.io.UnsupportedEncodingException;
import java.net.URI;
-import javax.annotation.PostConstruct;
-import javax.ws.rs.core.UriBuilder;
-import javax.xml.bind.JAXBException;
-
import org.junit.Test;
import org.onap.aai.AAISetup;
import org.onap.aai.exceptions.AAIException;
import org.onap.aai.setup.SchemaVersion;
import org.springframework.test.annotation.DirtiesContext;
+import jakarta.annotation.PostConstruct;
+import jakarta.ws.rs.core.UriBuilder;
+import jakarta.xml.bind.JAXBException;
+
@DirtiesContext(classMode = DirtiesContext.ClassMode.BEFORE_CLASS)
public class URIToExtensionInformationTest extends AAISetup {
import java.net.URI;
import java.util.HashMap;
-import javax.annotation.PostConstruct;
-import javax.ws.rs.core.UriBuilder;
-import javax.xml.bind.JAXBException;
-
import org.junit.Ignore;
import org.junit.Rule;
import org.junit.Test;
import org.onap.aai.exceptions.AAIException;
import org.onap.aai.introspection.Introspector;
import org.onap.aai.introspection.Loader;
-import org.onap.aai.introspection.LoaderFactory;
import org.onap.aai.introspection.ModelType;
import org.onap.aai.introspection.exceptions.AAIUnknownObjectException;
import org.onap.aai.setup.SchemaVersion;
import org.springframework.test.annotation.DirtiesContext;
+import jakarta.annotation.PostConstruct;
+import jakarta.ws.rs.core.UriBuilder;
+import jakarta.xml.bind.JAXBException;
+
@DirtiesContext(classMode = DirtiesContext.ClassMode.BEFORE_CLASS)
public class URIToObjectTest extends AAISetup {
import java.net.URI;
import java.net.URISyntaxException;
-import javax.annotation.PostConstruct;
-import javax.ws.rs.core.UriBuilder;
-import javax.xml.bind.JAXBException;
-
import org.junit.Rule;
import org.junit.Test;
import org.junit.rules.ExpectedException;
import org.onap.aai.exceptions.AAIException;
import org.onap.aai.introspection.Introspector;
import org.onap.aai.introspection.Loader;
-import org.onap.aai.introspection.LoaderFactory;
import org.onap.aai.introspection.ModelType;
import org.onap.aai.setup.SchemaVersion;
import org.springframework.test.annotation.DirtiesContext;
+import jakarta.annotation.PostConstruct;
+import jakarta.ws.rs.core.UriBuilder;
+import jakarta.xml.bind.JAXBException;
+
@DirtiesContext(classMode = DirtiesContext.ClassMode.BEFORE_CLASS)
public class URIToRelationshipObjectTest extends AAISetup {
import static org.mockito.Mockito.verify;
import com.fasterxml.jackson.databind.ObjectMapper;
-import com.fasterxml.jackson.module.jaxb.JaxbAnnotationModule;
+import com.fasterxml.jackson.module.jakarta.xmlbind.JakartaXmlBindAnnotationModule;
import com.google.gson.Gson;
import java.io.IOException;
import java.net.SocketTimeoutException;
import java.util.List;
-import org.apache.http.conn.ConnectTimeoutException;
+import org.apache.hc.client5.http.ConnectTimeoutException;
import org.junit.Before;
import org.junit.Rule;
import org.junit.Test;
@Before
public void setUp() throws Exception {
mapper = new ObjectMapper();
- mapper.registerModule(new JaxbAnnotationModule());
+ mapper.registerModule(new JakartaXmlBindAnnotationModule());
gson = new Gson();
restClient = Mockito.mock(RestClient.class);
validationService = Mockito.spy(new ValidationService(restClient, "JUNIT", "generic-vnf", null, mapper));
public static void setup() throws Exception {
System.setProperty("AJSC_HOME", ".");
System.setProperty("BUNDLECONFIG_DIR", "src/test/resources/bundleconfig-local");
- QueryFormatTestHelper.setFinalStatic(AAIConstants.class.getField("AAI_HOME_ETC_OXM"),
- "src/test/resources/bundleconfig-local/etc/oxm/");
graph = JanusGraphFactory.build().set("storage.backend", "inmemory").open();
}
import java.lang.reflect.Method;
import java.net.URI;
-import javax.ws.rs.core.MultivaluedHashMap;
-import javax.ws.rs.core.MultivaluedMap;
+import jakarta.ws.rs.core.MultivaluedHashMap;
+import jakarta.ws.rs.core.MultivaluedMap;
import org.apache.tinkerpop.gremlin.structure.Vertex;
import org.junit.Before;
import static org.junit.Assert.assertEquals;
-import com.jayway.jsonpath.JsonPath;
-
import java.io.IOException;
import java.util.Arrays;
import java.util.Collection;
-import javax.ws.rs.core.Response;
-
import org.junit.Before;
import org.junit.Ignore;
import org.junit.Test;
import org.onap.aai.serialization.engines.QueryStyle;
import org.skyscreamer.jsonassert.JSONAssert;
+import com.jayway.jsonpath.JsonPath;
+
+import jakarta.ws.rs.core.Response;
+
/**
* <b>CloudRegionTest</b> is testing if you put a cloud region with all
* children nodes associated to it then you should be able to
import java.io.IOException;
import java.util.UUID;
-import javax.ws.rs.core.Response;
-
import org.apache.tinkerpop.gremlin.process.traversal.dsl.graph.GraphTraversalSource;
import org.apache.tinkerpop.gremlin.structure.Edge;
import org.apache.tinkerpop.gremlin.structure.Vertex;
import org.onap.aai.exceptions.AAIException;
import org.onap.aai.serialization.engines.QueryStyle;
+import jakarta.ws.rs.core.Response;
+
public class EdgeNotValidAnymoreTest extends AAISetup {
private HttpTestUtil testUtil;
import static org.junit.Assert.assertEquals;
-import com.jayway.jsonpath.JsonPath;
-
import java.io.IOException;
import java.io.UnsupportedEncodingException;
import java.util.Arrays;
import java.util.Collection;
-import javax.ws.rs.core.Response;
-
import org.junit.After;
import org.junit.Before;
import org.junit.Test;
import org.skyscreamer.jsonassert.JSONAssert;
import org.springframework.test.annotation.DirtiesContext;
+import com.jayway.jsonpath.JsonPath;
+
+import jakarta.ws.rs.core.Response;
+
@RunWith(value = Parameterized.class)
@DirtiesContext(classMode = DirtiesContext.ClassMode.BEFORE_CLASS)
public class EntitlementTest extends AAISetup {
import java.util.HashMap;
import java.util.Map;
-import javax.ws.rs.core.Response;
-
import org.json.JSONObject;
import org.junit.After;
import org.junit.Before;
import org.skyscreamer.jsonassert.JSONAssert;
import org.springframework.test.annotation.DirtiesContext;
+import jakarta.ws.rs.core.Response;
+
@RunWith(value = Parameterized.class)
@DirtiesContext(classMode = DirtiesContext.ClassMode.BEFORE_CLASS)
public class GenericVnfLInterfaceTest extends AAISetup {
import static org.junit.Assert.assertEquals;
-import com.jayway.jsonpath.JsonPath;
-
-import java.util.*;
-
-import javax.ws.rs.core.Response;
+import java.util.Arrays;
+import java.util.Collection;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+import java.util.UUID;
import org.junit.Before;
import org.junit.Ignore;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
+import com.jayway.jsonpath.JsonPath;
+
+import jakarta.ws.rs.core.Response;
+
@Ignore
@RunWith(AAIJunitRunner.class)
public class HPACapabilityTest {
import static org.hamcrest.CoreMatchers.containsString;
import static org.hamcrest.core.Is.is;
import static org.hamcrest.core.IsNot.not;
-import static org.junit.Assert.*;
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertThat;
+import static org.junit.Assert.fail;
import java.util.Arrays;
import java.util.Collection;
import java.util.List;
import java.util.stream.Collectors;
-import javax.ws.rs.core.Response;
-
import org.apache.tinkerpop.gremlin.process.traversal.dsl.graph.GraphTraversalSource;
import org.janusgraph.core.JanusGraphTransaction;
import org.json.JSONObject;
import org.slf4j.LoggerFactory;
import org.springframework.test.annotation.DirtiesContext;
+import jakarta.ws.rs.core.Response;
+
@RunWith(value = Parameterized.class)
@DirtiesContext(classMode = DirtiesContext.ClassMode.BEFORE_CLASS)
public class ImpliedDeleteIntegrationTest extends AAISetup {
import static org.junit.Assert.assertEquals;
-import com.jayway.jsonpath.JsonPath;
-
import java.io.IOException;
import java.io.UnsupportedEncodingException;
import java.util.Arrays;
import java.util.Collection;
-import javax.ws.rs.core.Response;
-
import org.junit.After;
import org.junit.Before;
import org.junit.Test;
import org.skyscreamer.jsonassert.JSONAssert;
import org.springframework.test.annotation.DirtiesContext;
+import com.jayway.jsonpath.JsonPath;
+
+import jakarta.ws.rs.core.Response;
+
@RunWith(value = Parameterized.class)
@DirtiesContext(classMode = DirtiesContext.ClassMode.BEFORE_CLASS)
public class ModelElementTest extends AAISetup {
import java.util.List;
import java.util.Map;
-import javax.ws.rs.core.Response;
+import jakarta.ws.rs.core.Response;
import org.apache.tinkerpop.gremlin.process.traversal.dsl.graph.GraphTraversalSource;
import org.apache.tinkerpop.gremlin.structure.Vertex;
import java.util.*;
-import javax.ws.rs.core.Response;
+import jakarta.ws.rs.core.Response;
import org.apache.tinkerpop.gremlin.structure.Edge;
import org.junit.Before;
import java.util.*;
-import javax.ws.rs.core.Response;
+import jakarta.ws.rs.core.Response;
import org.apache.tinkerpop.gremlin.process.traversal.dsl.graph.GraphTraversalSource;
import org.apache.tinkerpop.gremlin.structure.Edge;
import java.util.stream.Collectors;
import java.util.stream.IntStream;
-import javax.ws.rs.core.Response;
-
import org.apache.tinkerpop.gremlin.process.traversal.dsl.graph.GraphTraversalSource;
import org.apache.tinkerpop.gremlin.structure.Vertex;
import org.janusgraph.core.JanusGraph;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
+import jakarta.ws.rs.core.Response;
+
public class PserverDuplicateTest extends AAISetup {
private static final Logger LOGGER = LoggerFactory.getLogger(PserverDuplicateTest.class);
import java.util.HashMap;
import java.util.Map;
-import javax.ws.rs.core.Response;
+import jakarta.ws.rs.core.Response;
import org.apache.tinkerpop.gremlin.process.traversal.dsl.graph.GraphTraversalSource;
import org.janusgraph.core.JanusGraphTransaction;
import static org.junit.Assert.assertEquals;
-import com.jayway.jsonpath.JsonPath;
-
-import java.util.*;
-
-import javax.ws.rs.core.Response;
+import java.util.Arrays;
+import java.util.Collection;
+import java.util.HashMap;
+import java.util.Map;
+import java.util.UUID;
import org.junit.Before;
import org.junit.ClassRule;
import org.springframework.test.context.junit4.rules.SpringClassRule;
import org.springframework.test.context.junit4.rules.SpringMethodRule;
+import com.jayway.jsonpath.JsonPath;
+
+import jakarta.ws.rs.core.Response;
+
@RunWith(value = Parameterized.class)
public class TenantTest extends AAISetup {
import java.util.Arrays;
import java.util.Collection;
-import javax.ws.rs.core.Response;
+import jakarta.ws.rs.core.Response;
import org.junit.Before;
import org.junit.Test;
import java.util.Arrays;
import java.util.Collection;
-import javax.ws.rs.core.Response;
-
import org.apache.tinkerpop.gremlin.process.traversal.dsl.graph.GraphTraversalSource;
import org.janusgraph.core.JanusGraphTransaction;
-import org.junit.*;
+import org.junit.After;
+import org.junit.Before;
+import org.junit.ClassRule;
+import org.junit.Rule;
+import org.junit.Test;
import org.junit.runner.RunWith;
import org.junit.runners.Parameterized;
import org.onap.aai.AAISetup;
import org.springframework.test.context.junit4.rules.SpringClassRule;
import org.springframework.test.context.junit4.rules.SpringMethodRule;
+import jakarta.ws.rs.core.Response;
+
@RunWith(value = Parameterized.class)
public class VnfcRelationshipIssueTest extends AAISetup {
import java.util.List;
import java.util.UUID;
-import javax.ws.rs.core.HttpHeaders;
-import javax.ws.rs.core.MediaType;
-import javax.ws.rs.core.MultivaluedHashMap;
-import javax.ws.rs.core.MultivaluedMap;
-import javax.ws.rs.core.Response;
-import javax.ws.rs.core.UriBuilder;
-import javax.ws.rs.core.UriInfo;
+import jakarta.ws.rs.core.HttpHeaders;
+import jakarta.ws.rs.core.MediaType;
+import jakarta.ws.rs.core.MultivaluedHashMap;
+import jakarta.ws.rs.core.MultivaluedMap;
+import jakarta.ws.rs.core.Response;
+import jakarta.ws.rs.core.UriBuilder;
+import jakarta.ws.rs.core.UriInfo;
import org.apache.tinkerpop.gremlin.process.traversal.dsl.graph.GraphTraversalSource;
import org.javatuples.Pair;
import java.util.Set;
import java.util.UUID;
- import javax.ws.rs.core.HttpHeaders;
- import javax.ws.rs.core.MediaType;
- import javax.ws.rs.core.MultivaluedHashMap;
- import javax.ws.rs.core.MultivaluedMap;
- import javax.ws.rs.core.Response;
- import javax.ws.rs.core.UriBuilder;
- import javax.ws.rs.core.UriInfo;
+ import jakarta.ws.rs.core.HttpHeaders;
+ import jakarta.ws.rs.core.MediaType;
+ import jakarta.ws.rs.core.MultivaluedHashMap;
+ import jakarta.ws.rs.core.MultivaluedMap;
+ import jakarta.ws.rs.core.Response;
+ import jakarta.ws.rs.core.UriBuilder;
+ import jakarta.ws.rs.core.UriInfo;
import org.apache.tinkerpop.gremlin.process.traversal.dsl.graph.GraphTraversal;
import org.apache.tinkerpop.gremlin.process.traversal.dsl.graph.GraphTraversalSource;
import java.util.Arrays;
import java.util.List;
-import javax.ws.rs.core.HttpHeaders;
-import javax.ws.rs.core.MultivaluedMap;
-import javax.ws.rs.core.UriBuilder;
-import javax.ws.rs.core.UriInfo;
+import jakarta.ws.rs.core.HttpHeaders;
+import jakarta.ws.rs.core.MultivaluedMap;
+import jakarta.ws.rs.core.UriBuilder;
+import jakarta.ws.rs.core.UriInfo;
import org.apache.tinkerpop.gremlin.process.traversal.dsl.graph.GraphTraversalSource;
import org.janusgraph.core.JanusGraphException;
import java.util.Map;
import java.util.Set;
-import javax.ws.rs.core.Response.Status;
+import jakarta.ws.rs.core.Response.Status;
import org.apache.tinkerpop.gremlin.structure.Vertex;
import org.apache.tinkerpop.gremlin.structure.util.detached.DetachedVertex;
import java.util.HashMap;
import java.util.UUID;
-import javax.ws.rs.core.Response;
+import jakarta.ws.rs.core.Response;
import org.junit.Before;
import org.junit.Test;
import java.util.List;
import java.util.concurrent.Callable;
-import javax.ws.rs.core.HttpHeaders;
-import javax.ws.rs.core.MultivaluedHashMap;
-import javax.ws.rs.core.MultivaluedMap;
-import javax.ws.rs.core.Response;
-import javax.ws.rs.core.UriInfo;
+import jakarta.ws.rs.core.HttpHeaders;
+import jakarta.ws.rs.core.MultivaluedHashMap;
+import jakarta.ws.rs.core.MultivaluedMap;
+import jakarta.ws.rs.core.Response;
+import jakarta.ws.rs.core.UriInfo;
import org.junit.Assert;
import org.junit.BeforeClass;
graph = JanusGraphFactory.build().set("storage.backend", "inmemory").open();
System.setProperty("AJSC_HOME", ".");
System.setProperty("BUNDLECONFIG_DIR", "src/test/resources/bundleconfig-local");
- QueryFormatTestHelper.setFinalStatic(AAIConstants.class.getField("AAI_HOME_ETC_OXM"),
- "src/test/resources/bundleconfig-local/etc/oxm/");
}
import static org.mockito.Mockito.spy;
import static org.mockito.Mockito.when;
-import com.google.gson.JsonObject;
-import com.google.gson.JsonParser;
-
import java.io.UnsupportedEncodingException;
-import javax.ws.rs.core.MultivaluedHashMap;
-
import org.apache.tinkerpop.gremlin.process.traversal.Path;
import org.apache.tinkerpop.gremlin.process.traversal.dsl.graph.GraphTraversalSource;
import org.apache.tinkerpop.gremlin.process.traversal.step.util.Tree;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.test.annotation.DirtiesContext;
+import com.google.gson.JsonObject;
+import com.google.gson.JsonParser;
+
+import jakarta.ws.rs.core.MultivaluedHashMap;
+
@DirtiesContext(classMode = DirtiesContext.ClassMode.BEFORE_CLASS)
public class MultiFormatTest extends AAISetup {
return graph;
}
- public static void setFinalStatic(Field field, Object newValue) throws Exception {
- field.setAccessible(true);
- // remove final modifier from field
- Field modifiersField = Field.class.getDeclaredField("modifiers");
- modifiersField.setAccessible(true);
- modifiersField.setInt(field, field.getModifiers() & ~Modifier.FINAL);
- field.set(null, newValue);
- }
-
}
import static org.mockito.Mockito.spy;
import static org.mockito.Mockito.when;
-import com.google.gson.JsonObject;
-
import java.util.Arrays;
-import javax.ws.rs.core.MultivaluedHashMap;
-import javax.ws.rs.core.MultivaluedMap;
-
import org.apache.tinkerpop.gremlin.process.traversal.strategy.verification.ReadOnlyStrategy;
import org.apache.tinkerpop.gremlin.structure.Graph;
import org.apache.tinkerpop.gremlin.structure.T;
import org.onap.aai.serialization.queryformats.utils.UrlBuilder;
import org.springframework.test.annotation.DirtiesContext;
+import com.google.gson.JsonObject;
+
+import jakarta.ws.rs.core.MultivaluedHashMap;
+import jakarta.ws.rs.core.MultivaluedMap;
+
@DirtiesContext(classMode = DirtiesContext.ClassMode.BEFORE_CLASS)
public class ResourceFormatTest extends AAISetup {
import static org.mockito.Mockito.spy;
import static org.mockito.Mockito.when;
-import com.google.gson.JsonObject;
-
import java.io.UnsupportedEncodingException;
import java.util.Arrays;
-import javax.ws.rs.core.MultivaluedHashMap;
-import javax.ws.rs.core.MultivaluedMap;
-
import org.apache.tinkerpop.gremlin.process.traversal.strategy.verification.ReadOnlyStrategy;
import org.apache.tinkerpop.gremlin.structure.Graph;
import org.apache.tinkerpop.gremlin.structure.T;
import org.onap.aai.serialization.queryformats.utils.UrlBuilder;
import org.springframework.test.annotation.DirtiesContext;
+import com.google.gson.JsonObject;
+
+import jakarta.ws.rs.core.MultivaluedHashMap;
+import jakarta.ws.rs.core.MultivaluedMap;
+
@DirtiesContext(classMode = DirtiesContext.ClassMode.BEFORE_CLASS)
public class SimpleFormatTest extends AAISetup {
import static org.junit.Assert.assertEquals;
-import javax.ws.rs.core.MultivaluedHashMap;
-import javax.ws.rs.core.MultivaluedMap;
-
import org.junit.Test;
import org.junit.runner.RunWith;
import org.mockito.Mock;
import org.onap.aai.serialization.db.DBSerializer;
import org.onap.aai.serialization.queryformats.Resource.Builder;
+import jakarta.ws.rs.core.MultivaluedHashMap;
+import jakarta.ws.rs.core.MultivaluedMap;
+
@RunWith(MockitoJUnitRunner.class)
public class QueryParamInjectorTest {
import static org.junit.Assert.assertNotNull;
import static org.junit.Assert.assertTrue;
-import com.google.common.collect.ImmutableListMultimap;
-import com.google.common.collect.Lists;
-import com.google.common.collect.Multimap;
-
import java.io.IOException;
import java.time.LocalDateTime;
import java.time.Month;
import java.util.LinkedHashMap;
import java.util.List;
-import javax.xml.bind.JAXBException;
-
import org.eclipse.persistence.dynamic.DynamicEntity;
import org.eclipse.persistence.jaxb.JAXBContext;
import org.eclipse.persistence.jaxb.JAXBMarshaller;
import org.mockito.Mockito;
import org.onap.aai.domain.notificationEvent.NotificationEvent;
+import com.google.common.collect.ImmutableListMultimap;
+import com.google.common.collect.Lists;
+import com.google.common.collect.Multimap;
+
+import jakarta.xml.bind.JAXBException;
+
public class PojoUtilsTest {
private PojoUtils pojoUtils;
<parent>
<groupId>org.onap.aai.aai-common</groupId>
<artifactId>aai-parent</artifactId>
- <version>1.15.5-SNAPSHOT</version>
+ <version>1.16.0-SNAPSHOT</version>
<relativePath>../aai-parent/pom.xml</relativePath>
</parent>
<artifactId>aai-els-onap-logging</artifactId>
<scope>compile</scope>
</dependency>
<dependency>
- <groupId>jakarta.annotation</groupId>
- <artifactId>jakarta.annotation-api</artifactId>
- <scope>provided</scope>
+ <groupId>jakarta.servlet</groupId>
+ <artifactId>jakarta.servlet-api</artifactId>
+ <scope>compile</scope>
</dependency>
<dependency>
- <groupId>javax.servlet</groupId>
- <artifactId>javax.servlet-api</artifactId>
+ <groupId>jakarta.annotation</groupId>
+ <artifactId>jakarta.annotation-api</artifactId>
<scope>provided</scope>
</dependency>
<dependency>
- <groupId>javax.ws.rs</groupId>
- <artifactId>javax.ws.rs-api</artifactId>
+ <groupId>jakarta.ws.rs</groupId>
+ <artifactId>jakarta.ws.rs-api</artifactId>
<scope>provided</scope>
</dependency>
<dependency>
</dependency>
<dependency>
<groupId>com.fasterxml.jackson.module</groupId>
- <artifactId>jackson-module-jaxb-annotations</artifactId>
+ <artifactId>jackson-module-jakarta-xmlbind-annotations</artifactId>
</dependency>
<dependency>
<groupId>org.apache.commons</groupId>
<dependency>
<groupId>org.projectlombok</groupId>
<artifactId>lombok</artifactId>
- <version>1.18.34</version>
+ <version>1.18.36</version>
<scope>provided</scope>
</dependency>
<dependency>
<artifactId>hamcrest-core</artifactId>
</exclusion>
</exclusions>
- </dependency>
+ </dependency>
</dependencies>
</project>
package org.onap.aai.aailog.filter;
-import javax.annotation.Priority;
-import javax.servlet.http.HttpServletRequest;
-import javax.ws.rs.container.ContainerRequestContext;
-import javax.ws.rs.container.PreMatching;
-import javax.ws.rs.core.HttpHeaders;
-import javax.ws.rs.core.UriInfo;
+import jakarta.annotation.Priority;
+import jakarta.servlet.http.HttpServletRequest;
+import jakarta.ws.rs.container.ContainerRequestContext;
+import jakarta.ws.rs.container.PreMatching;
+import jakarta.ws.rs.core.HttpHeaders;
+import jakarta.ws.rs.core.UriInfo;
import org.onap.aai.aailog.logs.ServiceName;
import org.onap.logging.filter.base.AuditLogContainerFilter;
import java.time.format.DateTimeFormatter;
import java.util.UUID;
-import javax.ws.rs.core.MultivaluedMap;
-import javax.ws.rs.client.ClientRequestContext;
-import javax.ws.rs.client.ClientRequestFilter;
+import jakarta.ws.rs.core.MultivaluedMap;
+import jakarta.ws.rs.client.ClientRequestContext;
+import jakarta.ws.rs.client.ClientRequestFilter;
import org.glassfish.jersey.client.ClientResponse;
import org.onap.aai.aailog.logs.ServiceName;
import org.onap.logging.filter.base.Constants;
import java.io.IOException;
import java.util.UUID;
-import javax.ws.rs.client.ClientRequestContext;
-import javax.ws.rs.client.ClientResponseContext;
-import javax.ws.rs.client.ClientResponseFilter;
-import javax.ws.rs.core.MultivaluedMap;
+import jakarta.ws.rs.client.ClientRequestContext;
+import jakarta.ws.rs.client.ClientResponseContext;
+import jakarta.ws.rs.client.ClientResponseFilter;
+import jakarta.ws.rs.core.MultivaluedMap;
import org.onap.logging.filter.base.Constants;
import org.onap.logging.filter.base.MDCSetup;
package org.onap.aai.aailog.logs;
-import javax.ws.rs.core.MultivaluedMap;
-import javax.ws.rs.core.Response;
+import jakarta.ws.rs.core.MultivaluedMap;
+import jakarta.ws.rs.core.Response;
import org.onap.logging.filter.base.AbstractMetricLogFilter;
import org.onap.logging.filter.base.ONAPComponents;
import java.util.UUID;
-import javax.ws.rs.core.Response;
+import jakarta.ws.rs.core.Response;
import org.onap.logging.filter.base.MDCSetup;
import org.onap.logging.ref.slf4j.ONAPLogConstants;
import java.util.Map;
-import javax.xml.bind.annotation.XmlRootElement;
+import jakarta.xml.bind.annotation.XmlRootElement;
import lombok.AllArgsConstructor;
import lombok.Data;
package org.onap.aai.exceptions;
+import java.io.Serial;
import java.util.Collection;
import java.util.LinkedList;
public class AAIException extends Exception {
public static final String DEFAULT_EXCEPTION_CODE = "AAI_4000";
+ @Serial
private static final long serialVersionUID = 1L;
private final String code;
import java.security.cert.X509Certificate;
import javax.security.auth.x500.X500Principal;
-import javax.servlet.http.HttpServletRequest;
+import jakarta.servlet.http.HttpServletRequest;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
return "INACTIVE_HEADER_CONV";
}
- String cipherSuite = (String) accessEvent.getRequest().getAttribute("javax.servlet.request.cipher_suite");
+ String cipherSuite = (String) accessEvent.getRequest().getAttribute("jakarta.servlet.request.cipher_suite");
String authUser = null;
if (cipherSuite != null) {
try {
X509Certificate certChain[] = (X509Certificate[]) accessEvent.getRequest()
- .getAttribute("javax.servlet.request.X509Certificate");
+ .getAttribute("jakarta.servlet.request.X509Certificate");
if (certChain == null || certChain.length == 0) {
HttpServletRequest request = accessEvent.getRequest();
import java.util.Properties;
import java.util.Map.Entry;
-import javax.ws.rs.core.MediaType;
+import jakarta.ws.rs.core.MediaType;
import org.apache.commons.lang3.StringUtils;
import org.onap.aai.domain.errorResponse.ErrorMessage;
package org.onap.aai.logging;
-import javax.ws.rs.core.Response.Status;
+import jakarta.ws.rs.core.Response.Status;
/**
*
package org.onap.aai.logging;
+import java.io.Serial;
+
public class ErrorObjectFormatException extends Exception {
+ @Serial
private static final long serialVersionUID = 3732705544448553685L;
public ErrorObjectFormatException() {
package org.onap.aai.logging;
+import java.io.Serial;
+
public class ErrorObjectNotFoundException extends Exception {
+ @Serial
private static final long serialVersionUID = 4115316781400786740L;
public ErrorObjectNotFoundException() {
package org.onap.aai.logging;
+import java.io.Serial;
+
public class LoggingContextNotExistsException extends RuntimeException {
+ @Serial
private static final long serialVersionUID = -4965807709525739623L;
}
package org.onap.aai.logging;
+import java.io.Serial;
+
public class StopWatchNotStartedException extends RuntimeException {
+ @Serial
private static final long serialVersionUID = -4540164295822859408L;
public StopWatchNotStartedException() {
package org.onap.aai.util;
+import org.onap.aai.exceptions.AAIException;
+
import com.fasterxml.jackson.annotation.JsonInclude;
import com.fasterxml.jackson.databind.DeserializationFeature;
import com.fasterxml.jackson.databind.ObjectMapper;
import com.fasterxml.jackson.databind.SerializationFeature;
-import com.fasterxml.jackson.module.jaxb.JaxbAnnotationModule;
-
-import org.onap.aai.exceptions.AAIException;
+import com.fasterxml.jackson.module.jakarta.xmlbind.JakartaXmlBindAnnotationModule;
public class MapperUtil {
public static <T> T readWithDashesAsObjectOf(Class<T> clazz, String value) throws AAIException {
ObjectMapper mapper = new ObjectMapper();
try {
- mapper.registerModule(new JaxbAnnotationModule());
+ mapper.registerModule(new JakartaXmlBindAnnotationModule());
mapper.configure(DeserializationFeature.FAIL_ON_UNKNOWN_PROPERTIES, false);
mapper.configure(DeserializationFeature.UNWRAP_ROOT_VALUE, false);
mapper.configure(DeserializationFeature.FAIL_ON_UNKNOWN_PROPERTIES, false);
mapper.configure(DeserializationFeature.UNWRAP_ROOT_VALUE, false);
- mapper.registerModule(new JaxbAnnotationModule());
+ mapper.registerModule(new JakartaXmlBindAnnotationModule());
return mapper.writeValueAsString(obj);
} catch (Exception e) {
throw new AAIException("AAI_4008", e);
package org.onap.logging.filter.base;
-import javax.servlet.http.HttpServletRequest;
+import jakarta.servlet.http.HttpServletRequest;
import org.onap.logging.ref.slf4j.ONAPLogConstants;
import org.slf4j.Logger;
import java.util.Enumeration;
-import javax.servlet.http.HttpServletRequest;
-import javax.servlet.http.HttpServletResponse;
-import javax.ws.rs.core.HttpHeaders;
+import jakarta.servlet.http.HttpServletRequest;
+import jakarta.servlet.http.HttpServletResponse;
+import jakarta.ws.rs.core.HttpHeaders;
public abstract class AbstractServletFilter {
import java.io.IOException;
-import javax.annotation.Priority;
-import javax.servlet.http.HttpServletRequest;
-import javax.ws.rs.container.ContainerRequestContext;
-import javax.ws.rs.container.ContainerRequestFilter;
-import javax.ws.rs.container.ContainerResponseContext;
-import javax.ws.rs.container.ContainerResponseFilter;
-import javax.ws.rs.core.Context;
-import javax.ws.rs.ext.Providers;
+import jakarta.annotation.Priority;
+import jakarta.servlet.http.HttpServletRequest;
+import jakarta.ws.rs.container.ContainerRequestContext;
+import jakarta.ws.rs.container.ContainerRequestFilter;
+import jakarta.ws.rs.container.ContainerResponseContext;
+import jakarta.ws.rs.container.ContainerResponseFilter;
+import jakarta.ws.rs.core.Context;
+import jakarta.ws.rs.ext.Providers;
import org.onap.logging.ref.slf4j.ONAPLogConstants;
import org.slf4j.MDC;
import java.io.IOException;
-import javax.servlet.Filter;
-import javax.servlet.FilterChain;
-import javax.servlet.FilterConfig;
-import javax.servlet.ServletException;
-import javax.servlet.ServletRequest;
-import javax.servlet.ServletResponse;
-import javax.servlet.http.HttpServletRequest;
-import javax.servlet.http.HttpServletResponse;
+import jakarta.servlet.Filter;
+import jakarta.servlet.FilterChain;
+import jakarta.servlet.FilterConfig;
+import jakarta.servlet.ServletException;
+import jakarta.servlet.ServletRequest;
+import jakarta.servlet.ServletResponse;
+import jakarta.servlet.http.HttpServletRequest;
+import jakarta.servlet.http.HttpServletResponse;
import org.onap.logging.ref.slf4j.ONAPLogConstants;
import org.slf4j.MDC;
public void doFilter(final ServletRequest request, final ServletResponse response, final FilterChain filterChain)
throws IOException, ServletException {
try {
- if (request != null && request instanceof HttpServletRequest) {
- pre((HttpServletRequest) request);
+ if (request != null && request instanceof HttpServletRequest servletRequest) {
+ pre(servletRequest);
}
filterChain.doFilter(request, response);
} finally {
- if (request != null && request instanceof HttpServletRequest) {
- post((HttpServletRequest) request, (HttpServletResponse) response);
+ if (request != null && request instanceof HttpServletRequest servletRequest) {
+ post(servletRequest, (HttpServletResponse) response);
}
MDC.clear();
}
import java.time.temporal.ChronoUnit;
import java.util.UUID;
-import javax.servlet.http.HttpServletRequest;
-import javax.ws.rs.core.HttpHeaders;
-import javax.ws.rs.core.Response;
+import jakarta.servlet.http.HttpServletRequest;
+import jakarta.ws.rs.core.HttpHeaders;
+import jakarta.ws.rs.core.Response;
import org.onap.logging.ref.slf4j.ONAPLogConstants;
import org.slf4j.Logger;
package org.onap.logging.filter.base;
-import javax.annotation.Priority;
-import javax.ws.rs.client.ClientRequestContext;
-import javax.ws.rs.client.ClientRequestFilter;
-import javax.ws.rs.client.ClientResponseContext;
-import javax.ws.rs.client.ClientResponseFilter;
-import javax.ws.rs.core.Context;
-import javax.ws.rs.core.MultivaluedMap;
-import javax.ws.rs.ext.Providers;
+import jakarta.annotation.Priority;
+import jakarta.ws.rs.client.ClientRequestContext;
+import jakarta.ws.rs.client.ClientRequestFilter;
+import jakarta.ws.rs.client.ClientResponseContext;
+import jakarta.ws.rs.client.ClientResponseFilter;
+import jakarta.ws.rs.core.Context;
+import jakarta.ws.rs.core.MultivaluedMap;
+import jakarta.ws.rs.ext.Providers;
@Priority(0)
public class MetricLogClientFilter
import java.nio.charset.Charset;
import java.nio.charset.StandardCharsets;
-import javax.ws.rs.WebApplicationException;
-import javax.ws.rs.client.ClientRequestContext;
-import javax.ws.rs.client.ClientRequestFilter;
-import javax.ws.rs.client.ClientResponseContext;
-import javax.ws.rs.client.ClientResponseFilter;
-import javax.ws.rs.core.HttpHeaders;
-import javax.ws.rs.core.MultivaluedHashMap;
-import javax.ws.rs.core.MultivaluedMap;
-import javax.ws.rs.ext.WriterInterceptor;
-import javax.ws.rs.ext.WriterInterceptorContext;
+import jakarta.ws.rs.WebApplicationException;
+import jakarta.ws.rs.client.ClientRequestContext;
+import jakarta.ws.rs.client.ClientRequestFilter;
+import jakarta.ws.rs.client.ClientResponseContext;
+import jakarta.ws.rs.client.ClientResponseFilter;
+import jakarta.ws.rs.core.HttpHeaders;
+import jakarta.ws.rs.core.MultivaluedHashMap;
+import jakarta.ws.rs.core.MultivaluedMap;
+import jakarta.ws.rs.ext.WriterInterceptor;
+import jakarta.ws.rs.ext.WriterInterceptorContext;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import java.io.PrintWriter;
import java.util.zip.GZIPInputStream;
-import javax.servlet.Filter;
-import javax.servlet.FilterChain;
-import javax.servlet.FilterConfig;
-import javax.servlet.ReadListener;
-import javax.servlet.ServletException;
-import javax.servlet.ServletInputStream;
-import javax.servlet.ServletOutputStream;
-import javax.servlet.ServletRequest;
-import javax.servlet.ServletResponse;
-import javax.servlet.WriteListener;
-import javax.servlet.http.HttpServletRequest;
-import javax.servlet.http.HttpServletRequestWrapper;
-import javax.servlet.http.HttpServletResponse;
-import javax.servlet.http.HttpServletResponseWrapper;
+import jakarta.servlet.Filter;
+import jakarta.servlet.FilterChain;
+import jakarta.servlet.FilterConfig;
+import jakarta.servlet.ReadListener;
+import jakarta.servlet.ServletException;
+import jakarta.servlet.ServletInputStream;
+import jakarta.servlet.ServletOutputStream;
+import jakarta.servlet.ServletRequest;
+import jakarta.servlet.ServletResponse;
+import jakarta.servlet.WriteListener;
+import jakarta.servlet.http.HttpServletRequest;
+import jakarta.servlet.http.HttpServletRequestWrapper;
+import jakarta.servlet.http.HttpServletResponse;
+import jakarta.servlet.http.HttpServletResponseWrapper;
public class PayloadLoggingServletFilter extends AbstractServletFilter implements Filter {
package org.onap.logging.filter.base;
-import javax.ws.rs.core.MultivaluedMap;
+import jakarta.ws.rs.core.MultivaluedMap;
public class SimpleJaxrsHeadersMap implements SimpleMap {
MultivaluedMap<String, String> map;
package org.onap.logging.filter.base;
-import javax.servlet.http.HttpServletRequest;
+import jakarta.servlet.http.HttpServletRequest;
public class SimpleServletHeadersMap implements SimpleMap {
private HttpServletRequest request;
import java.time.format.DateTimeFormatter;
import java.util.UUID;
-import javax.servlet.http.HttpServletRequest;
+import jakarta.servlet.http.HttpServletRequest;
import org.slf4j.Logger;
import org.slf4j.MDC;
import java.net.URI;
-import javax.ws.rs.container.ContainerRequestContext;
-import javax.ws.rs.container.ContainerResponseContext;
-import javax.ws.rs.core.MultivaluedHashMap;
-import javax.ws.rs.core.MultivaluedMap;
-import javax.ws.rs.core.UriInfo;
-
import org.junit.jupiter.api.AfterEach;
import org.junit.jupiter.api.Test;
import org.junit.jupiter.api.extension.ExtendWith;
import org.onap.logging.ref.slf4j.ONAPLogConstants;
import org.slf4j.MDC;
+import jakarta.ws.rs.container.ContainerRequestContext;
+import jakarta.ws.rs.container.ContainerResponseContext;
+import jakarta.ws.rs.core.MultivaluedHashMap;
+import jakarta.ws.rs.core.MultivaluedMap;
+import jakarta.ws.rs.core.UriInfo;
+
@ExtendWith(MockitoExtension.class)
public class AaiAuditLogContainerFilterTest {
@Mock
import java.net.URISyntaxException;
import java.net.UnknownHostException;
-import javax.ws.rs.client.ClientRequestContext;
-import javax.ws.rs.core.MultivaluedHashMap;
-import javax.ws.rs.core.MultivaluedMap;
-
import org.junit.After;
import org.junit.Before;
import org.junit.Test;
import org.onap.logging.ref.slf4j.ONAPLogConstants;
import org.slf4j.MDC;
+import jakarta.ws.rs.client.ClientRequestContext;
+import jakarta.ws.rs.core.MultivaluedHashMap;
+import jakarta.ws.rs.core.MultivaluedMap;
+
@RunWith(MockitoJUnitRunner.class)
public class RestControllerClientLoggingInterceptorTest {
@Before
public void init() throws URISyntaxException {
- System.setProperty("javax.ws.rs.ext.RuntimeDelegate", "com.sun.ws.rs.ext.RuntimeDelegateImpl");
+ System.setProperty("jakarta.ws.rs.ext.RuntimeDelegate", "com.sun.ws.rs.ext.RuntimeDelegateImpl");
when(clientRequest.getHeaders()).thenReturn(new MultivaluedHashMap<String, Object>());
when(clientRequest.getUri())
.thenReturn(new URI("https://localhost:9999/aai/v1/cloud-infrastructure/complexes/complex/complex-1"));
import java.io.IOException;
-import javax.ws.rs.core.Response;
-
import org.junit.jupiter.api.Test;
import org.onap.aai.logging.AaiElsErrorCode;
import org.onap.aai.logging.ErrorObject;
+import jakarta.ws.rs.core.Response;
+
public class AAIExceptionTest {
private AAIException aaiException;
MockHttpServletRequest https = new MockHttpServletRequest();
https.addHeader("Authorization", "Basic dXNlcjpwYXNzd29yZA==");
- https.setAttribute("javax.servlet.request.cipher_suite", "");
- https.setAttribute("javax.servlet.request.X509Certificate", null);
+ https.setAttribute("jakarta.servlet.request.cipher_suite", "");
+ https.setAttribute("jakarta.servlet.request.X509Certificate", null);
when(accessEvent.getRequest()).thenReturn(https);
assertEquals("user", cnName.convert(accessEvent));
MockHttpServletRequest https = new MockHttpServletRequest();
https.addHeader("Authorization", "dXNlcjpwYXNzd29yZA==");
- https.setAttribute("javax.servlet.request.cipher_suite", "");
- https.setAttribute("javax.servlet.request.X509Certificate", null);
+ https.setAttribute("jakarta.servlet.request.cipher_suite", "");
+ https.setAttribute("jakarta.servlet.request.X509Certificate", null);
when(accessEvent.getRequest()).thenReturn(https);
assertEquals("-", cnName.convert(accessEvent));
MockHttpServletRequest https = new MockHttpServletRequest();
https.addHeader("Authorization", "Basic dXNlcjpwYXNzd29yZA==");
- https.setAttribute("javax.servlet.request.cipher_suite", null);
- https.setAttribute("javax.servlet.request.X509Certificate", null);
+ https.setAttribute("jakarta.servlet.request.cipher_suite", null);
+ https.setAttribute("jakarta.servlet.request.X509Certificate", null);
when(accessEvent.getRequest()).thenReturn(https);
assertEquals("-", cnName.convert(accessEvent));
X509Certificate[] certChain = {cert};
MockHttpServletRequest https = new MockHttpServletRequest();
- https.setAttribute("javax.servlet.request.cipher_suite", "");
- https.setAttribute("javax.servlet.request.X509Certificate", certChain);
+ https.setAttribute("jakarta.servlet.request.cipher_suite", "");
+ https.setAttribute("jakarta.servlet.request.X509Certificate", certChain);
when(accessEvent.getRequest()).thenReturn(https);
when(cert.getSubjectX500Principal()).thenReturn(new X500Principal(testSubject));
import java.util.List;
import java.util.Map;
-import javax.ws.rs.core.MediaType;
+import jakarta.ws.rs.core.MediaType;
import org.junit.jupiter.api.AfterEach;
import org.junit.jupiter.api.BeforeEach;
org.onap.aai.domain.errorResponse.Fault restResponse =
objectMapper.readValue(errorResponse, org.onap.aai.domain.errorResponse.Fault.class);
-
+
Map<ExceptionType, ErrorMessage> requestError = restResponse.getRequestError();
assertNotNull(requestError);
ErrorMessage errorMessage = requestError.get(ExceptionType.SERVICE);
@Test
public void thatInvalidMediaTypeWillReturnInvalidAcceptHeaderException() throws ErrorObjectNotFoundException, JsonMappingException, JsonProcessingException {
String errorResponse = ErrorLogHelper.getRESTAPIErrorResponse(Collections.singletonList(MediaType.TEXT_PLAIN_TYPE), new AAIException(), new ArrayList<>());
-
+
Fault restResponse = objectMapper.readValue(errorResponse, Fault.class);
assertNotNull(restResponse);
import static org.junit.jupiter.api.Assertions.assertEquals;
-import javax.ws.rs.core.Response;
-
import org.junit.jupiter.api.Test;
+import jakarta.ws.rs.core.Response;
+
public class ErrorObjectTest {
private ErrorObject errorObject;
private static final String ERROR_DISPOSITION = "5";
* 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.
import static org.junit.jupiter.api.Assertions.assertEquals;
import static org.mockito.Mockito.when;
-import javax.ws.rs.container.ContainerRequestContext;
-import javax.ws.rs.container.ContainerResponseContext;
-import javax.ws.rs.core.MultivaluedHashMap;
-import javax.ws.rs.core.MultivaluedMap;
-import javax.ws.rs.core.UriInfo;
-
import org.junit.jupiter.api.AfterEach;
import org.junit.jupiter.api.Test;
import org.junit.jupiter.api.extension.ExtendWith;
import org.slf4j.LoggerFactory;
import org.slf4j.MDC;
+import jakarta.ws.rs.container.ContainerResponseContext;
+import jakarta.ws.rs.core.MultivaluedHashMap;
+import jakarta.ws.rs.core.MultivaluedMap;
+import jakarta.ws.rs.core.UriInfo;
+
@ExtendWith(MockitoExtension.class)
public class AuditLogContainerFilterTest {
protected static final Logger logger = LoggerFactory.getLogger(AbstractMetricLogFilter.class);
@Mock
- private ContainerRequestContext containerRequest;
+ private jakarta.ws.rs.container.ContainerRequestContext containerRequest;
@Mock
private ContainerResponseContext containerResponse;
* 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.
import static org.junit.jupiter.api.Assertions.assertEquals;
import static org.mockito.Mockito.when;
-import javax.servlet.ServletRequest;
-import javax.servlet.ServletResponse;
-import javax.servlet.http.HttpServletRequest;
-import javax.servlet.http.HttpServletResponse;
+import jakarta.servlet.ServletRequest;
+import jakarta.servlet.ServletResponse;
+import jakarta.servlet.http.HttpServletRequest;
+import jakarta.servlet.http.HttpServletResponse;
import org.junit.jupiter.api.AfterEach;
import org.junit.jupiter.api.Test;
* 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.
import static org.junit.jupiter.api.Assertions.assertEquals;
-import javax.ws.rs.core.MultivaluedHashMap;
-import javax.ws.rs.core.MultivaluedMap;
+import jakarta.ws.rs.core.MultivaluedHashMap;
+import jakarta.ws.rs.core.MultivaluedMap;
import org.junit.jupiter.api.Test;
import org.onap.logging.ref.slf4j.ONAPLogConstants;
* 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.
import java.util.HashMap;
-import javax.servlet.http.HttpServletRequest;
-import javax.ws.rs.core.HttpHeaders;
-import javax.ws.rs.core.MultivaluedHashMap;
-import javax.ws.rs.core.MultivaluedMap;
+import jakarta.servlet.http.HttpServletRequest;
+import jakarta.ws.rs.core.HttpHeaders;
+import jakarta.ws.rs.core.MultivaluedHashMap;
+import jakarta.ws.rs.core.MultivaluedMap;
import org.junit.jupiter.api.AfterEach;
import org.junit.jupiter.api.Test;
* 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.
import java.time.ZonedDateTime;
import java.time.format.DateTimeFormatter;
-import javax.ws.rs.client.ClientRequestContext;
-import javax.ws.rs.core.MultivaluedHashMap;
-import javax.ws.rs.core.MultivaluedMap;
+import jakarta.ws.rs.client.ClientRequestContext;
+import jakarta.ws.rs.core.MultivaluedHashMap;
+import jakarta.ws.rs.core.MultivaluedMap;
import org.junit.jupiter.api.AfterEach;
import org.junit.jupiter.api.Test;
* 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.
import java.io.IOException;
import java.net.URISyntaxException;
-import javax.ws.rs.client.ClientRequestContext;
-import javax.ws.rs.core.MultivaluedHashMap;
-import javax.ws.rs.core.MultivaluedMap;
+import jakarta.ws.rs.client.ClientRequestContext;
+import jakarta.ws.rs.core.MultivaluedHashMap;
+import jakarta.ws.rs.core.MultivaluedMap;
import org.junit.jupiter.api.Test;
import org.junit.jupiter.api.extension.ExtendWith;
* 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.
import static org.junit.jupiter.api.Assertions.assertEquals;
-import javax.ws.rs.core.MultivaluedHashMap;
-import javax.ws.rs.core.MultivaluedMap;
+import jakarta.ws.rs.core.MultivaluedHashMap;
+import jakarta.ws.rs.core.MultivaluedMap;
import org.junit.jupiter.api.Test;
import org.onap.logging.ref.slf4j.ONAPLogConstants;
* 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.
import static org.junit.jupiter.api.Assertions.assertEquals;
import static org.mockito.Mockito.when;
-import javax.servlet.http.HttpServletRequest;
+import jakarta.servlet.http.HttpServletRequest;
import org.junit.jupiter.api.Test;
import org.junit.jupiter.api.extension.ExtendWith;
import java.util.Map;
import java.util.UUID;
-import javax.xml.bind.DatatypeConverter;
-
import org.junit.jupiter.api.AfterEach;
import org.junit.jupiter.api.Test;
import org.slf4j.Logger;
import org.slf4j.event.Level;
import org.springframework.mock.web.MockHttpServletRequest;
+import jakarta.xml.bind.DatatypeConverter;
+
/**
* Tests for {@link ONAPLogAdapter}.
*/
<parent>
<groupId>org.onap.aai.aai-common</groupId>
<artifactId>aai-parent</artifactId>
- <version>1.15.5-SNAPSHOT</version>
+ <version>1.16.0-SNAPSHOT</version>
<relativePath>../aai-parent/pom.xml</relativePath>
</parent>
<modelVersion>4.0.0</modelVersion>
<parent>
<groupId>org.onap.aai.aai-common</groupId>
<artifactId>aai-common</artifactId>
- <version>1.15.5-SNAPSHOT</version>
+ <version>1.16.0-SNAPSHOT</version>
</parent>
<artifactId>aai-parent</artifactId>
<name>aai-parent</name>
<commons.net.version>3.8.0</commons.net.version>
<commons.text.version>1.10.0</commons.text.version>
<docker.fabric.version>0.40.2</docker.fabric.version>
- <eclipse.persistence.version>2.7.15</eclipse.persistence.version>
+ <eclipse.persistence.version>3.0.1</eclipse.persistence.version>
<google.guava.version>33.4.0-jre</google.guava.version>
<gremlin.version>3.7.3</gremlin.version>
<janusgraph.version>1.1.0</janusgraph.version>
Please don't upgrade to 2.3.0 or above for nexus iq or security scans
as it could potentially break our code
-->
- <spring.boot.version>2.7.18</spring.boot.version>
+ <spring.boot.version>3.0.13</spring.boot.version>
<json.path.version>2.2.0</json.path.version>
<json.version>20240303</json.version>
<junit.version>4.12</junit.version>
- <httpclient.version>4.5.13</httpclient.version>
- <io.swagger.version>1.5.24</io.swagger.version>
- <logback.version>1.2.13</logback.version>
- <slf4j.version>1.7.36</slf4j.version>
+ <logback.version>1.4.10</logback.version>
+ <slf4j.version>2.0.7</slf4j.version>
<mockito.all.version>3.4.0</mockito.all.version>
<mockito.core.version>3.4.0</mockito.core.version>
<opencsv.version>3.1</opencsv.version>
<plexus.utils.version>3.1.1</plexus.utils.version>
<reflections.version>0.9.10</reflections.version>
<snakeyaml.version>1.29</snakeyaml.version>
- <lombok.version>1.18.34</lombok.version>
+ <lombok.version>1.18.36</lombok.version>
<testcontainers.version>1.20.4</testcontainers.version>
- <javax.servlet.version>3.1.0</javax.servlet.version>
+ <jakarta.servlet.version>3.1.0</jakarta.servlet.version>
<javax.annotation.version>1.2</javax.annotation.version>
<sonar.jacoco.reportPath />
<artifactId>hamcrest-junit</artifactId>
<version>${hamcrest.junit.version}</version>
</dependency>
-
- <dependency>
- <groupId>javax.servlet</groupId>
- <artifactId>javax.servlet-api</artifactId>
- <version>${javax.servlet.version}</version>
- <scope>provided</scope>
- </dependency>
<dependency>
<groupId>jakarta.annotation</groupId>
<artifactId>jakarta.annotation-api</artifactId>
- <version>1.3.5</version>
+ <version>2.1.1</version>
</dependency>
<dependency>
<dependency>
<groupId>jakarta.xml.bind</groupId>
<artifactId>jakarta.xml.bind-api</artifactId>
- <version>2.3.3</version>
+ <version>3.0.1</version>
</dependency>
<dependency>
<groupId>org.glassfish.jaxb</groupId>
<artifactId>jaxb-runtime</artifactId>
- <version>2.3.9</version>
+ <version>3.0.1</version>
</dependency>
<dependency>
<version>${commons.text.version}</version>
</dependency>
- <dependency>
- <groupId>javax.ws.rs</groupId>
- <artifactId>javax.ws.rs-api</artifactId>
- <version>${jaxrs.version}</version>
- </dependency>
-
<dependency>
<groupId>commons-cli</groupId>
<artifactId>commons-cli</artifactId>
<version>${aai.schema.service.version}</version>
</dependency>
- <dependency>
- <groupId>org.apache.httpcomponents</groupId>
- <artifactId>httpclient</artifactId>
- <version>${httpclient.version}</version>
- </dependency>
-
<dependency>
<groupId>org.skyscreamer</groupId>
<artifactId>jsonassert</artifactId>
</execution>
</executions>
</plugin>
- <plugin>
- <groupId>org.sonarsource.scanner.maven</groupId>
- <artifactId>sonar-maven-plugin</artifactId>
- <version>${sonar.scanner.version}</version>
- </plugin>
<plugin>
<groupId>org.apache.maven.plugins</groupId>
<artifactId>maven-checkstyle-plugin</artifactId>
- <version>3.0.0</version>
+ <version>3.3.1</version>
<configuration>
<skip>True</skip>
</configuration>
<parent>
<groupId>org.onap.aai.aai-common</groupId>
<artifactId>aai-parent</artifactId>
- <version>1.15.5-SNAPSHOT</version>
+ <version>1.16.0-SNAPSHOT</version>
<relativePath>../aai-parent/pom.xml</relativePath>
</parent>
<artifactId>aai-rest</artifactId>
<artifactId>spring-boot-autoconfigure</artifactId>
</dependency>
<dependency>
- <groupId>javax.ws.rs</groupId>
- <artifactId>javax.ws.rs-api</artifactId>
+ <groupId>jakarta.ws.rs</groupId>
+ <artifactId>jakarta.ws.rs-api</artifactId>
</dependency>
<dependency>
- <groupId>org.apache.httpcomponents</groupId>
- <artifactId>httpclient</artifactId>
+ <groupId>org.apache.httpcomponents.client5</groupId>
+ <artifactId>httpclient5</artifactId>
</dependency>
<dependency>
<groupId>org.springframework.boot</groupId>
<scope>compile</scope>
<exclusions>
<exclusion>
- <groupId>javax.ws.rs</groupId>
- <artifactId>javax.ws.rs-api</artifactId>
+ <groupId>jakarta.ws.rs</groupId>
+ <artifactId>jakarta.ws.rs-api</artifactId>
</exclusion>
</exclusions>
</dependency>
package org.onap.aai.restclient;
-import javax.annotation.PostConstruct;
-
-import org.apache.http.client.HttpClient;
-import org.apache.http.impl.client.HttpClients;
+import jakarta.annotation.PostConstruct;
+import org.apache.hc.client5.http.classic.HttpClient;
+import org.apache.hc.client5.http.impl.classic.HttpClients;
import org.onap.aai.aailog.filter.RestClientLoggingInterceptor;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
package org.onap.aai.restclient;
-import javax.annotation.PostConstruct;
+import jakarta.annotation.PostConstruct;
+import org.apache.hc.client5.http.classic.HttpClient;
+
import javax.net.ssl.SSLContext;
-import org.apache.http.client.HttpClient;
-import org.apache.http.impl.client.HttpClients;
-import org.apache.http.ssl.SSLContextBuilder;
+import org.apache.hc.client5.http.impl.classic.HttpClients;
+import org.apache.hc.client5.http.impl.io.PoolingHttpClientConnectionManager;
+import org.apache.hc.client5.http.impl.io.PoolingHttpClientConnectionManagerBuilder;
+import org.apache.hc.client5.http.ssl.SSLConnectionSocketFactoryBuilder;
import org.onap.aai.aailog.filter.RestClientLoggingInterceptor;
-import org.slf4j.Logger;
-import org.slf4j.LoggerFactory;
import org.springframework.http.client.HttpComponentsClientHttpRequestFactory;
-import org.springframework.util.ResourceUtils;
import org.springframework.web.client.RestTemplate;
public abstract class OneWaySSLRestClient extends RestClient {
}
protected HttpClient getClient() throws Exception {
-
- SSLContext sslContext = SSLContextBuilder.create().build();
-
- HttpClient client =
- HttpClients.custom()
- .setSSLContext(sslContext)
- .setSSLHostnameVerifier((s, sslSession) -> true)
- .build();
-
- return client;
+ SSLContext sslContext = SSLContext.getDefault();
+ PoolingHttpClientConnectionManager connectionManager = PoolingHttpClientConnectionManagerBuilder.create()
+ .setSSLSocketFactory(
+ SSLConnectionSocketFactoryBuilder.create()
+ .setSslContext(sslContext)
+ .build()
+ )
+ .build();
+ return HttpClients
+ .custom()
+ .setConnectionManager(connectionManager)
+ .build();
}
@Override
package org.onap.aai.restclient;
-import javax.annotation.PostConstruct;
+import jakarta.annotation.PostConstruct;
+import org.apache.hc.client5.http.classic.HttpClient;
+
import javax.net.ssl.SSLContext;
-import org.apache.http.client.HttpClient;
-import org.apache.http.impl.client.HttpClients;
-import org.apache.http.ssl.SSLContextBuilder;
+import org.apache.hc.client5.http.impl.classic.HttpClients;
+import org.apache.hc.client5.http.impl.io.PoolingHttpClientConnectionManager;
+import org.apache.hc.client5.http.impl.io.PoolingHttpClientConnectionManagerBuilder;
+import org.apache.hc.client5.http.ssl.DefaultClientTlsStrategy;
+import org.apache.hc.client5.http.ssl.SSLConnectionSocketFactoryBuilder;
+import org.apache.hc.core5.ssl.SSLContextBuilder;
import org.onap.aai.aailog.filter.RestClientLoggingInterceptor;
import org.springframework.http.client.HttpComponentsClientHttpRequestFactory;
import org.springframework.web.client.RestTemplate;
protected HttpClient getClient() throws Exception {
- SSLContext sslContext =
- SSLContextBuilder.create().build();
-
- HttpClient client =
- HttpClients.custom()
- .setSSLContext(sslContext)
- .setSSLHostnameVerifier((s, sslSession) -> true)
- .build();
+ SSLContext sslContext = SSLContext.getDefault();
+ PoolingHttpClientConnectionManager connectionManager = PoolingHttpClientConnectionManagerBuilder.create()
+ .setSSLSocketFactory(
+ SSLConnectionSocketFactoryBuilder.create()
+ .setSslContext(sslContext)
+ .build()
+ )
+ .build();
+ HttpClient client = HttpClients
+ .custom()
+ .setConnectionManager(connectionManager)
+ .build();
return client;
}
<parent>
<groupId>org.onap.aai.aai-common</groupId>
<artifactId>aai-parent</artifactId>
- <version>1.15.5-SNAPSHOT</version>
+ <version>1.16.0-SNAPSHOT</version>
<relativePath>../aai-parent/pom.xml</relativePath>
</parent>
<groupId>com.fasterxml.jackson.core</groupId>
<artifactId>jackson-databind</artifactId>
</dependency>
- <dependency>
- <groupId>org.hamcrest</groupId>
- <artifactId>hamcrest-junit</artifactId>
- <scope>test</scope>
- <exclusions>
- <exclusion>
- <groupId>junit</groupId>
- <artifactId>junit</artifactId>
- </exclusion>
- </exclusions>
- </dependency>
<dependency>
<groupId>org.junit.jupiter</groupId>
<artifactId>junit-jupiter</artifactId>
package org.onap.aai.schemaif;
+import java.io.Serial;
+
public class SchemaProviderException extends Exception {
+ @Serial
private static final long serialVersionUID = 8162385108397238865L;
public SchemaProviderException() {
<parent>
<groupId>org.onap.aai.aai-common</groupId>
<artifactId>aai-parent</artifactId>
- <version>1.15.5-SNAPSHOT</version>
+ <version>1.16.0-SNAPSHOT</version>
<relativePath>../aai-parent/pom.xml</relativePath>
</parent>
<artifactId>aai-schema-ingest</artifactId>
<artifactId>json-path</artifactId>
</dependency>
<dependency>
- <groupId>javax.ws.rs</groupId>
- <artifactId>javax.ws.rs-api</artifactId>
+ <groupId>jakarta.ws.rs</groupId>
+ <artifactId>jakarta.ws.rs-api</artifactId>
</dependency>
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-webmvc</artifactId>
</dependency>
<dependency>
- <groupId>org.apache.httpcomponents</groupId>
- <artifactId>httpclient</artifactId>
+ <groupId>org.springframework.boot</groupId>
+ <artifactId>spring-boot-starter-web</artifactId>
+ </dependency>
+ <dependency>
+ <groupId>org.apache.httpcomponents.client5</groupId>
+ <artifactId>httpclient5</artifactId>
</dependency>
<dependency>
<groupId>ch.qos.logback</groupId>
import org.onap.aai.setup.SchemaConfigVersions;
import org.onap.aai.setup.SchemaLocationsBean;
import org.onap.aai.setup.SchemaVersions;
+import org.springframework.boot.autoconfigure.condition.ConditionalOnMissingBean;
import org.springframework.boot.autoconfigure.condition.ConditionalOnProperty;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
public class ConfigConfiguration {
@Bean(name = "schemaConfigVersions")
+ @ConditionalOnMissingBean
public SchemaConfigVersions schemaConfigVersions() {
return new SchemaConfigVersions();
}
import java.util.concurrent.ExecutionException;
import java.util.stream.Collectors;
-import javax.annotation.PostConstruct;
+import jakarta.annotation.PostConstruct;
import org.apache.tinkerpop.gremlin.structure.Direction;
import org.onap.aai.edges.enums.DirectionNotation;
package org.onap.aai.nodes;
-import com.google.common.base.CaseFormat;
-
import java.io.ByteArrayInputStream;
import java.io.IOException;
import java.io.InputStream;
import java.util.regex.Matcher;
import java.util.regex.Pattern;
-import javax.annotation.PostConstruct;
import javax.xml.XMLConstants;
-import javax.xml.bind.JAXBException;
import javax.xml.parsers.DocumentBuilder;
import javax.xml.parsers.DocumentBuilderFactory;
import javax.xml.parsers.ParserConfigurationException;
import org.w3c.dom.NodeList;
import org.xml.sax.SAXException;
+import com.google.common.base.CaseFormat;
+
+import jakarta.annotation.PostConstruct;
+import jakarta.xml.bind.JAXBException;
+
@Component
/*
* NodeIngestor - ingests A&AI OXM files per given config, serves DynamicJAXBContext per version
import java.util.List;
import java.util.stream.Collectors;
-import javax.annotation.PostConstruct;
+import jakarta.annotation.PostConstruct;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.boot.autoconfigure.condition.ConditionalOnExpression;
import org.springframework.core.io.Resource;
import org.springframework.http.HttpHeaders;
import org.springframework.http.HttpStatus;
+import org.springframework.http.HttpStatusCode;
import org.springframework.http.MediaType;
import org.springframework.http.ResponseEntity;
import org.springframework.stereotype.Component;
verifySchemaServiceResponse(schemaResponse.getStatusCode());
LOGGER.debug("SchemaResponse Status code" + schemaResponse.getStatusCode());
-
+
Resource resultBody = schemaResponse.getBody();
return resultBody != null
? Collections.singletonList(resultBody.getInputStream())
}
- private void verifySchemaServiceResponse(HttpStatus statusCode) throws IOException {
- if (statusCode != HttpStatus.OK) {
+ private void verifySchemaServiceResponse(HttpStatusCode statusCode) throws IOException {
+ if (!statusCode.equals(HttpStatusCode.valueOf(HttpStatus.OK.value()))) {
LOGGER.error("Please check the Schema Service. It returned with the status code {}", statusCode);
throw new IOException("SchemaService is not available");
}
import java.util.List;
import java.util.stream.Collectors;
-import javax.annotation.PostConstruct;
+import jakarta.annotation.PostConstruct;
import org.springframework.boot.autoconfigure.condition.ConditionalOnExpression;
import org.springframework.context.annotation.PropertySource;
import java.util.List;
import java.util.Map;
-import javax.annotation.PostConstruct;
+import jakarta.annotation.PostConstruct;
import org.onap.aai.restclient.RestClient;
import org.springframework.beans.factory.annotation.Autowired;
package org.onap.aai.validation.nodes;
-import com.google.common.collect.ArrayListMultimap;
-import com.google.common.collect.Multimap;
-
import java.io.FileInputStream;
import java.io.IOException;
import java.io.InputStream;
import org.w3c.dom.NodeList;
import org.xml.sax.SAXException;
+import com.google.common.collect.ArrayListMultimap;
+import com.google.common.collect.Multimap;
+
/**
* Default duplicate rules for A&AI -
* node types may never have a duplicate definition
import static java.nio.charset.StandardCharsets.UTF_8;
import static org.hamcrest.CoreMatchers.is;
import static org.hamcrest.MatcherAssert.assertThat;
-import static org.junit.jupiter.api.Assertions.*;
+import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertFalse;
+import static org.junit.jupiter.api.Assertions.assertThrows;
+import static org.junit.jupiter.api.Assertions.assertTrue;
import java.io.ByteArrayOutputStream;
import java.io.File;
import java.nio.file.Files;
import java.nio.file.Path;
-import javax.xml.bind.SchemaOutputResolver;
import javax.xml.transform.OutputKeys;
import javax.xml.transform.Result;
import javax.xml.transform.Transformer;
import org.springframework.test.context.TestPropertySource;
import org.w3c.dom.Document;
+import jakarta.xml.bind.SchemaOutputResolver;
+
@TestPropertySource(
properties = {
"schema.ingest.file = src/test/resources/forWiringTests/schema-ingest-wiring-test-local-node.properties"})
import java.nio.file.Files;
import java.nio.file.Path;
-import javax.xml.bind.SchemaOutputResolver;
+import jakarta.xml.bind.SchemaOutputResolver;
import javax.xml.transform.OutputKeys;
import javax.xml.transform.Result;
import javax.xml.transform.Transformer;
.removeIf(converter -> MappingJackson2XmlHttpMessageConverter.class.isAssignableFrom(converter.getClass()));
}
});
- restTemplate = restTemplateBuilder.build();
+ restTemplate = restTemplateBuilder.detectRequestFactory(false).build();
mockRestServiceServer = MockRestServiceServer.createServer(restTemplate);
JsonObject payload = null;
e.printStackTrace();
}
JsonArray mockUris = payload.getAsJsonArray("mock-uri");
-
+
String url = "https://localhost:8447/aai/v14";
for (int i = 0; i < mockUris.size(); i++) {
-/**
+/**
* ============LICENSE_START=======================================================
* org.onap.aai
* ================================================================================
<parent>
<groupId>org.onap.aai.aai-common</groupId>
<artifactId>aai-parent</artifactId>
- <version>1.15.5-SNAPSHOT</version>
+ <version>1.16.0-SNAPSHOT</version>
<relativePath>../aai-parent/pom.xml</relativePath>
</parent>
<artifactId>aai-utils</artifactId>
<dependencies>
<dependency>
- <groupId>org.apache.httpcomponents</groupId>
- <artifactId>httpclient</artifactId>
+ <groupId>org.apache.httpcomponents.client5</groupId>
+ <artifactId>httpclient5</artifactId>
</dependency>
<dependency>
<groupId>org.eclipse.persistence</groupId>
<artifactId>lombok</artifactId>
<scope>provided</scope>
</dependency>
- <dependency>
- <groupId>org.hamcrest</groupId>
- <artifactId>hamcrest-junit</artifactId>
- <scope>test</scope>
- <exclusions>
- <exclusion>
- <groupId>junit</groupId>
- <artifactId>junit</artifactId>
- </exclusion>
- </exclusions>
- </dependency>
<dependency>
<groupId>org.junit.jupiter</groupId>
<artifactId>junit-jupiter</artifactId>
import java.util.regex.Matcher;
import java.util.regex.Pattern;
-import javax.xml.bind.JAXBException;
+import jakarta.xml.bind.JAXBException;
import org.eclipse.persistence.jaxb.JAXBContextProperties;
import org.eclipse.persistence.jaxb.dynamic.DynamicJAXBContext;
<groupId>org.onap.aai.aai-common</groupId>
<artifactId>aai-common</artifactId>
- <version>1.15.5-SNAPSHOT</version>
+ <version>1.16.0-SNAPSHOT</version>
<packaging>pom</packaging>
<name>aai-aai-common</name>
<description>Contains all of the common code for resources and traversal repos</description>
<properties>
<aai.common.version>${project.version}</aai.common.version>
<aai.generate.schema>true</aai.generate.schema>
+ <maven.compiler.release>17</maven.compiler.release>
<sitePath>/content/sites/site/org/onap/aai/aai-common/${project.artifactId}/${project.version}</sitePath>
<onap.nexus.url>https://nexus.onap.org</onap.nexus.url>
<onap.nexus.snapshot.path>/content/repositories/snapshots/</onap.nexus.snapshot.path>
<groupId>org.apache.maven.plugins</groupId>
<artifactId>maven-compiler-plugin</artifactId>
<configuration>
- <release>11</release>
+ <release>17</release>
</configuration>
</plugin>
<plugin>
Code Review / aai / aai-common.git / commitdiff