<project xmlns="http://maven.apache.org/POM/4.0.0"
- xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
- xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
+ xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
+ xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
<modelVersion>4.0.0</modelVersion>
<artifactId>catalog-be</artifactId>
<maven-dependency-plugin.version>3.2.0</maven-dependency-plugin.version>
<replacer.plugin.version>1.5.3</replacer.plugin.version>
<ui.version>${project.version}</ui.version>
- <io.github.hakky54.version>7.4.11</io.github.hakky54.version>
</properties>
<dependencies>
</exclusions>
</dependency>
- <dependency>
- <groupId>io.micrometer</groupId>
-
<artifactId>micrometer-registry-prometheus</artifactId>
- <version>${micrometer.version}</version>
- </dependency>
+ <dependency>
+ <groupId>io.micrometer</groupId>
+ <artifactId>micrometer-registry-prometheus</artifactId>
+ <version>${micrometer.version}</version>
+ </dependency>
<dependency>
<groupId>ch.qos.logback</groupId>
<scope>compile</scope>
</dependency>
+
<!-- CAMBRIA CLIENT for U-EB -->
<dependency>
<groupId>com.att.nsa</groupId>
</exclusions>
</dependency>
+ <!-- CADI -->
+ <dependency>
+ <groupId>org.onap.aaf.authz</groupId>
+ <artifactId>aaf-cadi-aaf</artifactId>
+ <version>${cadi.version}</version>
+ <exclusions>
+ <exclusion>
+ <groupId>com.datastax.cassandra</groupId>
+ <artifactId>cassandra-driver-core</artifactId>
+ </exclusion>
+ <exclusion>
+ <groupId>org.slf4j</groupId>
+ <artifactId>slf4j-log4j12</artifactId>
+ </exclusion>
+ <exclusion>
+ <artifactId>log4j</artifactId>
+ <groupId>log4j</groupId>
+ </exclusion>
+ <exclusion>
+ <groupId>javax.servlet</groupId>
+ <artifactId>javax.servlet-api</artifactId>
+ </exclusion>
+ </exclusions>
+ </dependency>
+
<!-- TEST -->
<dependency>
<groupId>org.assertj</groupId>
<artifactId>kafka-clients</artifactId>
</dependency>
- <dependency>
- <groupId>io.github.hakky54</groupId>
- <artifactId>sslcontext-kickstart-for-jetty</artifactId>
- <version>${io.github.hakky54.version}</version>
- </dependency>
- <dependency>
- <groupId>io.github.hakky54</groupId>
- <artifactId>sslcontext-kickstart</artifactId>
- <version>${io.github.hakky54.version}</version>
- </dependency>
-
</dependencies>
<build>
-FROM onap/integration-java11:10.0.0
+FROM onap/integration-java11:9.0.0
USER root
ARG JETTY_FOLDER=/app/jetty
#| Jetty |
#| |
#+----------------------------------+
+
default['jetty']['dmaap_truststore_pwd'] = "dmaap_truststore_pwd"
-default['jetty']['keystore_path'] = "etc/org.onap.sdc.p12"
default['jetty']['keystore_pwd'] = "?(kP!Yur![*!Y5!E^f(ZKc31"
default['jetty']['keymanager_pwd'] = "?(kP!Yur![*!Y5!E^f(ZKc31"
-default['jetty']['truststore_path'] = "etc/org.onap.sdc.trust.jks"
+default['jetty']['truststore_path'] = "#{ENV['JETTY_BASE']}/etc/truststore"
# TO CHANGE THE TRUSTSTORE CERT THE JVM CONFIGURATION
# MUST BE ALSO CHANGE IN THE startup.sh FILE
default['jetty'][:truststore_pwd] = "z+KEj;t+,KN^iimSiS89e#p0"
mode "0755"
variables ({
:https_port => "#{node['BE'][:https_port]}" ,
- :jetty_keystore_path => "#{node['jetty'][:keystore_path]}" ,
:jetty_keystore_pwd => "#{node['jetty'][:keystore_pwd]}" ,
:jetty_keymanager_pwd => "#{node['jetty'][:keymanager_pwd]}" ,
- :jetty_truststore_path => "#{node['jetty'][:truststore_path]}",
:jetty_truststore_pwd => "#{node['jetty'][:truststore_pwd]}"
})
end
## See http://www.eclipse.org/jetty/documentation/current/configuring-security-secure-passwords.html
## Keystore file path (relative to $jetty.base)
-jetty.sslContext.keyStorePath=<%= @jetty_keystore_path %>
+jetty.sslContext.keyStorePath=etc/org.onap.sdc.p12
## Truststore file path (relative to $jetty.base)
-jetty.sslContext.trustStorePath=<%= @jetty_truststore_path %>
+jetty.sslContext.trustStorePath=etc/org.onap.sdc.trust.jks
## Keystore password
# jetty.sslContext.keyStorePassword=OBF:1vny1zlo1x8e1vnw1vn61x8g1zlu1vn4
jetty.sslContext.keyStorePassword=<%= @jetty_keystore_pwd %>
## Keystore type and provider
-jetty.sslContext.keyStoreType=JKS
+# jetty.sslContext.keyStoreType=JKS
# jetty.sslContext.keyStoreProvider=
## KeyManager password
jetty.sslContext.trustStorePassword=<%= @jetty_truststore_pwd %>
## Truststore type and provider
-jetty.sslContext.trustStoreType=JKS
+# jetty.sslContext.trustStoreType=JKS
# jetty.sslContext.trustStoreProvider=
## whether client certificate authentication is required
--- /dev/null
+/*-
+ * ============LICENSE_START=======================================================
+ * SDC
+ * ================================================================================
+ * Copyright (C) 2020 AT&T Intellectual Property. All rights reserved.
+ * ================================================================================
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ * ============LICENSE_END=========================================================
+ */
+package org.openecomp.sdc.be.filters;
+
+import java.io.IOException;
+import java.util.function.Supplier;
+import javax.annotation.Priority;
+import javax.servlet.FilterChain;
+import javax.servlet.FilterConfig;
+import javax.servlet.ServletContext;
+import javax.servlet.ServletException;
+import javax.servlet.ServletRequest;
+import javax.servlet.ServletResponse;
+import javax.servlet.http.HttpServletRequest;
+import org.onap.aaf.cadi.Access;
+import org.onap.aaf.cadi.PropAccess;
+import org.onap.aaf.cadi.config.Config;
+import org.onap.aaf.cadi.filter.CadiFilter;
+import org.openecomp.sdc.be.components.impl.CADIHealthCheck;
+import org.openecomp.sdc.be.config.CadiFilterParams;
+import org.openecomp.sdc.be.config.ConfigurationManager;
+import org.openecomp.sdc.be.impl.WebAppContextWrapper;
+import org.openecomp.sdc.common.api.Constants;
+import org.openecomp.sdc.common.api.HealthCheckInfo;
+import org.openecomp.sdc.common.log.wrappers.Logger;
+import org.openecomp.sdc.common.util.ThreadLocalsHolder;
+import org.springframework.web.context.WebApplicationContext;
+
+@Priority(2)
+public class BeCadiServletFilter extends CadiFilter {
+
+ private static final Logger log = Logger.getLogger(BeCadiServletFilter.class);
+ private static final String BE_CADI_SERVICE_FILTER = "BeCadiServletFilter: ";
+ private ConfigurationManager configurationManager = ConfigurationManager.getConfigurationManager();
+
+ public BeCadiServletFilter() {
+ super();
+ log.debug(BE_CADI_SERVICE_FILTER);
+ }
+
+ /**
+ * This constructor to be used when directly constructing and placing in HTTP Engine
+ *
+ * @param access
+ * @param moreTafLurs
+ * @throws ServletException
+ */
+ public BeCadiServletFilter(Access access, Object... moreTafLurs) throws ServletException {
+ super(access, moreTafLurs);
+ log.debug(BE_CADI_SERVICE_FILTER);
+ }
+
+ /**
+ * Use this to pass in a PreContructed CADI Filter, but with initializing... let Servlet do it
+ *
+ * @param init
+ * @param access
+ * @param moreTafLurs
+ * @throws ServletException
+ */
+ public BeCadiServletFilter(boolean init, PropAccess access, Object... moreTafLurs) throws ServletException {
+ super(init, access, moreTafLurs);
+ log.debug(BE_CADI_SERVICE_FILTER);
+ }
+
+ private void checkIfNullProperty(String key, String value) {
+ /* When value is null, so not defined in application.properties
+ set nothing in System properties */
+ if (value != null) {
+ /* Ensure that any properties already defined in System.prop by JVM params
+ won't be overwritten by Spring application.properties values */
+ System.setProperty(key, System.getProperty(key, value));
+ }
+ }
+
+ @Override
+ public void init(FilterConfig filterConfig) throws ServletException {
+ // set some properties in System so that Cadi filter will find its config
+
+ // The JVM values set will always overwrite the Spring ones.
+ CadiFilterParams cadiFilterParams = configurationManager.getConfiguration().getCadiFilterParams();
+ checkIfNullProperty(Config.HOSTNAME, cadiFilterParams.getHostname());
+ log.debug("BeCadiServletFilter: HOSTNAME", cadiFilterParams.getHostname());
+ checkIfNullProperty(Config.CADI_KEYFILE, cadiFilterParams.getCadi_keyfile());
+ checkIfNullProperty(Config.CADI_LOGLEVEL, cadiFilterParams.getCadi_loglevel());
+ checkIfNullProperty(Config.CADI_LATITUDE, cadiFilterParams.getAFT_LATITUDE());
+ checkIfNullProperty(Config.CADI_LONGITUDE, cadiFilterParams.getAFT_LONGITUDE());
+ checkIfNullProperty(Config.AAF_URL, cadiFilterParams.getAaf_url());
+ //checkIfNullProperty(Config.AAF_LOCATE_URL, cadiFilterParams.getAafLocateUrl());
+ checkIfNullProperty(Config.AAF_APPID, cadiFilterParams.getAaf_id());
+ checkIfNullProperty(Config.AAF_APPPASS, cadiFilterParams.getAaf_password());
+ checkIfNullProperty(Config.AAF_ENV, cadiFilterParams.getAFT_ENVIRONMENT());
+ checkIfNullProperty(Config.CADI_X509_ISSUERS, cadiFilterParams.getCadiX509Issuers());
+ checkIfNullProperty(Config.CADI_TRUSTSTORE, cadiFilterParams.getCadi_truststore());
+ checkIfNullProperty(Config.CADI_TRUSTSTORE_PASSWORD, cadiFilterParams.getCadi_truststore_password());
+ super.init(filterConfig);
+ log.debug("BeCadiServletFilter finishing init(), Current status of CADI would be UP");
+ if (!isNeedAuth()) {
+ CADIHealthCheck.getCADIHealthCheckInstance().setIsCADIUp(HealthCheckInfo.HealthCheckStatus.DOWN);
+ } else {
+ CADIHealthCheck.getCADIHealthCheckInstance().setIsCADIUp(HealthCheckInfo.HealthCheckStatus.UP);
+ }
+ }
+
+ @Override
+ public void doFilter(ServletRequest request, ServletResponse response, FilterChain chain) throws IOException, ServletException {
+ if (ThreadLocalsHolder.isExternalRequest() && isNeedAuth()) {
+ log.debug("doFilter: {}", request.getContentType());
+ HttpServletRequest hreq = (HttpServletRequest) request;
+ log.debug("Need aaf authentication : {}", hreq);
+ ThreadLocalUtils threadLocalUtils = getThreadLocalUtils(((HttpServletRequest) request).getSession().getServletContext());
+ threadLocalUtils.setUserContext((HttpServletRequest) request);
+ super.doFilter(request, response, chain);
+ } else {
+ log.debug("No need aaf authentication");
+ chain.doFilter(request, response);
+ }
+ }
+
+ private boolean isNeedAuth() {
+ return configurationManager.getConfiguration().getAafAuthNeeded();
+ }
+
+ ThreadLocalUtils getThreadLocalUtils(ServletContext context) {
+ return getClassFromWebAppContext(context, () -> ThreadLocalUtils.class);
+ }
+
+ <T> T getClassFromWebAppContext(ServletContext context, Supplier<Class<T>> businessLogicClassGen) {
+ WebAppContextWrapper webApplicationContextWrapper = (WebAppContextWrapper) context
+ .getAttribute(Constants.WEB_APPLICATION_CONTEXT_WRAPPER_ATTR);
+ WebApplicationContext webApplicationContext = webApplicationContextWrapper.getWebAppContext(context);
+ return webApplicationContext.getBean(businessLogicClassGen.get());
+ }
+}
private static final String MANIFEST_FILE_NAME = "/META-INF/MANIFEST.MF";
private static final Logger log = Logger.getLogger(BEAppContextListener.class);
- @Override
public void contextInitialized(ServletContextEvent context) {
super.contextInitialized(context);
ConfigurationManager configurationManager = new ConfigurationManager(ExternalConfiguration.getConfigurationSource());
*/
package org.openecomp.sdc.config;
-import nl.altindag.ssl.SSLFactory;
-import nl.altindag.ssl.util.JettySslUtils;
import org.apache.http.impl.client.CloseableHttpClient;
-import org.eclipse.jetty.util.ssl.SslContextFactory;
-import org.onap.config.api.JettySSLUtils;
import org.onap.portalsdk.core.onboarding.exception.CipherUtilException;
import org.onap.sdc.security.PortalClient;
import org.openecomp.sdc.be.auditing.impl.ConfigurationProvider;
import org.openecomp.sdc.be.components.impl.aaf.RoleAuthorizationHandler;
import org.openecomp.sdc.be.components.impl.lock.ComponentLockAspect;
import org.openecomp.sdc.be.components.lifecycle.LifecycleBusinessLogic;
-import org.openecomp.sdc.be.config.Configuration;
import org.openecomp.sdc.be.config.ConfigurationManager;
import org.openecomp.sdc.be.ecomp.converters.AssetMetadataConverter;
import org.openecomp.sdc.be.filters.FilterConfiguration;
import org.openecomp.sdc.be.filters.PortalConfiguration;
import org.openecomp.sdc.be.filters.ThreadLocalUtils;
+import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.ComponentScan;
+import org.springframework.context.annotation.Configuration;
import org.springframework.core.annotation.Order;
-import javax.net.ssl.SSLSessionContext;
-import javax.net.ssl.X509ExtendedKeyManager;
-import javax.net.ssl.X509ExtendedTrustManager;
-import java.io.IOException;
-import java.nio.file.Files;
-import java.nio.file.Path;
-import java.nio.file.StandardOpenOption;
-
-
// @formatter:off
-@org.springframework.context.annotation.Configuration
+@Configuration
@ComponentScan({
"org.openecomp.sdc.be.user",
"org.openecomp.sdc.be.facade.operations",
private static final int BEFORE_TRANSACTION_MANAGER = 0;
private final ComponentLocker componentLocker;
- private final JettySSLUtils.JettySslConfig sslConfig;
+ @Autowired
public CatalogBESpringConfig(ComponentLocker componentLocker) {
this.componentLocker = componentLocker;
- sslConfig = JettySSLUtils.getSSLConfig();
}
@Bean(name = "lifecycleBusinessLogic")
}
@Bean
- public Configuration configuration() {
+ public org.openecomp.sdc.be.config.Configuration configuration() {
return ConfigurationManager.getConfigurationManager().getConfiguration();
}
-
- @Bean
- public SSLFactory sslFactory() throws IOException {
- return SSLFactory.builder().withSwappableIdentityMaterial()
- .withIdentityMaterial(Files.newInputStream(Path.of(sslConfig.getKeystorePath()), StandardOpenOption.READ), sslConfig.getKeystorePass().toCharArray(), sslConfig.getKeystoreType()).withSwappableTrustMaterial()
- .withTrustMaterial(Files.newInputStream(Path.of(sslConfig.getTruststorePath()), StandardOpenOption.READ), sslConfig.getTruststorePass().toCharArray(), sslConfig.getTruststoreType()).withNeedClientAuthentication()
- .build();
- }
-
- @Bean
- public SslContextFactory.Server sslContextFactory(SSLFactory sslFactory) {
- return JettySslUtils.forServer(sslFactory);
- }
-
- @Bean
- public X509ExtendedKeyManager keyManager(SSLFactory sslFactory) throws Exception {
- return sslFactory.getKeyManager().orElseThrow(Exception::new);
- }
-
- @Bean
- public X509ExtendedTrustManager trustManager(SSLFactory sslFactory) throws Exception {
- return sslFactory.getTrustManager().orElseThrow(Exception::new);
- }
-
- @Bean
- public SSLSessionContext serverSessionContext(SSLFactory sslFactory) {
- return sslFactory.getSslContext().getServerSessionContext();
- }
-
}
-FROM onap/integration-java11:10.0.0
+FROM onap/integration-java11:9.0.0
USER root
ARG JETTY_FOLDER=/app/jetty
default['FE'][:http_port] = 8181
default['FE'][:https_port] = 9443
default['disableHttp'] = true
-default['jetty']['keystore_path'] = "etc/org.onap.sdc.p12"
default['jetty'][:keystore_pwd] = "?(kP!Yur![*!Y5!E^f(ZKc31"
default['jetty'][:keymanager_pwd] = "?(kP!Yur![*!Y5!E^f(ZKc31"
-default['jetty']['truststore_path'] = "etc/org.onap.sdc.trust.jks"
# TO CHANGE THE TRUSTSTORE CERT THE JVM CONFIGURATION
# MUST BE ALSO CHANGE IN THE startup.sh FILE
default['jetty'][:truststore_pwd] = "z+KEj;t+,KN^iimSiS89e#p0"
#BasicAuth
default['basic_auth']['enabled'] = true
default['basic_auth'][:user_name] = "testName"
-default['basic_auth'][:user_pass] = "testPass"
+default['basic_auth'][:user_pass] = "testPass"
\ No newline at end of file
mode "0755"
variables({
:https_port => "#{node['FE'][:https_port]}" ,
- :jetty_keystore_path => "#{node['jetty'][:keystore_path]}" ,
:jetty_keystore_pwd => "#{node['jetty'][:keystore_pwd]}" ,
:jetty_keymanager_pwd => "#{node['jetty'][:keymanager_pwd]}" ,
- :jetty_truststore_path => "#{node['jetty'][:truststore_path]}",
:jetty_truststore_pwd => "#{node['jetty'][:truststore_pwd]}"
})
end
## See http://www.eclipse.org/jetty/documentation/current/configuring-security-secure-passwords.html
## Keystore file path (relative to $jetty.base)
-jetty.sslContext.keyStorePath=<%= @jetty_keystore_path %>
+jetty.sslContext.keyStorePath=etc/org.onap.sdc.p12
## Truststore file path (relative to $jetty.base)
-jetty.sslContext.trustStorePath=<%= @jetty_truststore_path %>
+jetty.sslContext.trustStorePath=etc/org.onap.sdc.trust.jks
## Keystore password
# jetty.sslContext.keyStorePassword=OBF:1vny1zlo1x8e1vnw1vn61x8g1zlu1vn4
jetty.sslContext.keyStorePassword=<%= @jetty_keystore_pwd %>
## Keystore type and provider
-jetty.sslContext.keyStoreType=JKS
+# jetty.sslContext.keyStoreType=JKS
# jetty.sslContext.keyStoreProvider=
## KeyManager password
jetty.sslContext.trustStorePassword=<%= @jetty_truststore_pwd %>
## Truststore type and provider
-jetty.sslContext.trustStoreType=JKS
+# jetty.sslContext.trustStoreType=JKS
# jetty.sslContext.trustStoreProvider=
## whether client certificate authentication is required
import com.google.gson.Gson;
import com.google.gson.GsonBuilder;
+import java.io.IOException;
+import java.security.GeneralSecurityException;
import org.apache.http.HttpStatus;
import org.apache.http.client.config.RequestConfig;
import org.apache.http.client.methods.CloseableHttpResponse;
import org.openecomp.sdc.fe.config.PluginsConfiguration;
import org.openecomp.sdc.fe.config.PluginsConfiguration.Plugin;
-import java.io.IOException;
-
public class PluginStatusBL {
private static final Logger log = Logger.getLogger(PluginStatusBL.class.getName());
private boolean hasSecuredPlugins() {
if (this.getPluginsList() != null) {
return pluginsConfiguration.getPluginsList().stream()
- .anyMatch(plugin -> plugin.getPluginDiscoveryUrl().toLowerCase().startsWith("https"));
+ .anyMatch(plugin -> plugin.getPluginDiscoveryUrl().toLowerCase().startsWith("https"));
}
return false;
}
- private CloseableHttpClient getPooledClient(final boolean isSecured) throws Exception {
+ private CloseableHttpClient getPooledClient(boolean isSecured) throws GeneralSecurityException, IOException {
final PoolingHttpClientConnectionManager poolingConnManager;
- if (isSecured) {
- final SSLConnectionSocketFactory s = new SSLConnectionSocketFactory(JettySSLUtils.getSslContext(), new NoopHostnameVerifier());
- final Registry<ConnectionSocketFactory> registry = RegistryBuilder.<ConnectionSocketFactory>create()
- .register("http", new PlainConnectionSocketFactory())
- .register("https", s).build();
- poolingConnManager = new PoolingHttpClientConnectionManager(registry);
- } else {
+ if (!isSecured) {
poolingConnManager = new PoolingHttpClientConnectionManager();
+ } else {
+ SSLConnectionSocketFactory s = new SSLConnectionSocketFactory(JettySSLUtils.getSslContext(), new NoopHostnameVerifier());
+ Registry<ConnectionSocketFactory> registry = RegistryBuilder.<ConnectionSocketFactory>create()
+ .register("http", new PlainConnectionSocketFactory()).register("https", s).build();
+ poolingConnManager = new PoolingHttpClientConnectionManager(registry);
}
- final int maxTotal = System.getProperties().containsKey(MAX_CONNECTION_POOL) ? Integer.parseInt(System.getProperty(MAX_CONNECTION_POOL)) : 5;
- final int routeMax = System.getProperties().containsKey(MAX_ROUTE_POOL) ? Integer.parseInt(System.getProperty(MAX_ROUTE_POOL)) : 20;
+ int maxTotal = System.getProperties().containsKey(MAX_CONNECTION_POOL) ? Integer.parseInt(System.getProperty(MAX_CONNECTION_POOL)) : 5;
+ int routeMax = System.getProperties().containsKey(MAX_ROUTE_POOL) ? Integer.parseInt(System.getProperty(MAX_ROUTE_POOL)) : 20;
poolingConnManager.setMaxTotal(maxTotal);
poolingConnManager.setDefaultMaxPerRoute(routeMax);
return HttpClients.custom().setConnectionManager(poolingConnManager).setSSLHostnameVerifier(new NoopHostnameVerifier()).build();
log.debug("The value returned from getConfig is {}", pluginsConfiguration);
Integer connectionTimeout = pluginsConfiguration.getConnectionTimeout();
this.requestConfig = RequestConfig.custom().setSocketTimeout(connectionTimeout).setConnectTimeout(connectionTimeout)
- .setConnectionRequestTimeout(connectionTimeout).build();
+ .setConnectionRequestTimeout(connectionTimeout).build();
Plugin wantedPlugin = pluginsConfiguration.getPluginsList().stream().filter(plugin -> plugin.getPluginId().equals(pluginId)).findAny()
- .orElse(null);
+ .orElse(null);
if (wantedPlugin != null) {
result = gson.toJson(checkPluginAvailability(wantedPlugin));
}
private static final int PROBE_INTERVALE = 15;
private static Logger log = Logger.getLogger(FEAppContextListener.class.getName());
- @Override
public void contextInitialized(ServletContextEvent context) {
super.contextInitialized(context);
ConfigurationManager configurationManager = new ConfigurationManager(ExternalConfiguration.getConfigurationSource());
log.debug("After executing {}", this.getClass());
}
- @Override
public void contextDestroyed(ServletContextEvent context) {
ExecutorService executorPool = (ExecutorService) context.getServletContext().getAttribute(Constants.THREAD_EXECUTOR_ATTR);
if (executorPool != null) {
*/
package org.openecomp.sdc.fe.servlets;
+import static org.apache.commons.lang3.StringUtils.isEmpty;
+
import com.google.common.annotations.VisibleForTesting;
+import java.net.MalformedURLException;
+import java.net.URL;
+import java.util.Base64;
+import javax.servlet.http.HttpServletRequest;
import org.apache.commons.lang3.NotImplementedException;
import org.apache.commons.lang3.StringUtils;
import org.eclipse.jetty.client.api.Request;
import org.openecomp.sdc.fe.impl.LogHandler;
import org.openecomp.sdc.fe.utils.BeProtocol;
-import javax.servlet.http.HttpServletRequest;
-import java.net.MalformedURLException;
-import java.net.URL;
-import java.util.Base64;
-
-import static org.apache.commons.lang3.StringUtils.isEmpty;
-
public class FeProxyServlet extends SSLProxyServlet {
public static final String UUID = "uuid";
BasicAuthConfig basicAuth = config.getBasicAuth();
if (basicAuth.isEnabled()) {
proxyRequest.header(HttpHeader.AUTHORIZATION,
- "Basic " + Base64.getEncoder().encodeToString((basicAuth.getUserName() + ":" + basicAuth.getUserPass()).getBytes()));
+ "Basic " + Base64.getEncoder().encodeToString((basicAuth.getUserName() + ":" + basicAuth.getUserPass()).getBytes()));
}
super.addProxyHeaders(clientRequest, proxyRequest);
}
}
private String getModifiedUrl(Configuration config, PluginsConfiguration pluginConf, String uri, String queryString)
- throws MalformedURLException {
+ throws MalformedURLException {
if (config == null) {
log.error(EcompLoggerErrorCode.UNKNOWN_ERROR, "FeProxyServlet getModifiedUrl", "sdc-FE", "failed to retrieve configuration.");
throw new RuntimeException("failed to read FE configuration");
} else if (uri.contains(WORKFLOW_CONTEXT)) {
uri = uri.replace(SDC1_FE_PROXY + WORKFLOW_CONTEXT, WORKFLOW_CONTEXT);
String workflowPluginURL = pluginConf.getPluginsList().stream()
- .filter(plugin -> plugin.getPluginId().equalsIgnoreCase(PLUGIN_ID_WORKFLOW)).map(Plugin::getPluginDiscoveryUrl).findFirst()
- .orElse(null);
+ .filter(plugin -> plugin.getPluginId().equalsIgnoreCase(PLUGIN_ID_WORKFLOW)).map(Plugin::getPluginDiscoveryUrl).findFirst()
+ .orElse(null);
java.net.URL workflowURL = new URL(workflowPluginURL);
protocol = workflowURL.getProtocol();
host = workflowURL.getHost();
private PluginsConfiguration getPluginConfiguration(HttpServletRequest request) {
return ((ConfigurationManager) request.getSession().getServletContext().getAttribute(Constants.CONFIGURATION_MANAGER_ATTR))
- .getPluginsConfiguration();
+ .getPluginsConfiguration();
}
private boolean isMsToggleOn(Configuration config) {
String facadeSuffix = String.format("%s%s", FACADE_PATH_IDENTIFIER, CATALOG_REQUEST_IDENTIFIER);
String nonFacadeUrl = currentURI.replace(facadeSuffix, "rest/v1/screen");
redirectValue = getModifiedUrl(config, getPluginConfiguration(request), nonFacadeUrl,
- "excludeTypes=VFCMT&excludeTypes=Configuration");
+ "excludeTypes=VFCMT&excludeTypes=Configuration");
}
// Home
else if (currentURI.endsWith(HOME_REQUEST_IDENTIFIER)) {
String facadeSuffix = String.format("%s%s", FACADE_PATH_IDENTIFIER, CATALOG_REQUEST_IDENTIFIER);
String nonFacadeUrl = currentURI.replace(facadeSuffix, "rest/v1/screen");
redirectValue = getModifiedUrl(config, getPluginConfiguration(request), nonFacadeUrl,
- "excludeTypes=VFCMT&excludeTypes=Configuration");
+ "excludeTypes=VFCMT&excludeTypes=Configuration");
} else {
String message = String
- .format("facade is toggled off, Could not rediret url %s with query params %s", currentURI, getQueryString(request));
+ .format("facade is toggled off, Could not rediret url %s with query params %s", currentURI, getQueryString(request));
log.error(message);
throw new NotImplementedException(message);
}
if (StringUtils.isEmpty(msUrl)) {
// do that only once
msUrl = String.format(MS_URL, config.getCatalogFacadeMs().getProtocol(), config.getCatalogFacadeMs().getHost(),
- config.getCatalogFacadeMs().getPort());
+ config.getCatalogFacadeMs().getPort());
}
StringBuilder url;
String queryString;
private Configuration getConfiguration(HttpServletRequest request) {
return ((ConfigurationManager) request.getSession().getServletContext().getAttribute(Constants.CONFIGURATION_MANAGER_ATTR))
- .getConfiguration();
+ .getConfiguration();
}
private String getAuthority(String host, String port) {
*/
package org.openecomp.sdc.fe.servlets;
+import javax.servlet.ServletException;
import org.eclipse.jetty.client.HttpClient;
-import org.eclipse.jetty.client.dynamic.HttpClientTransportDynamic;
-import org.eclipse.jetty.io.ClientConnector;
import org.eclipse.jetty.proxy.ProxyServlet;
import org.eclipse.jetty.util.ssl.SslContextFactory;
-import org.onap.config.api.JettySSLUtils;
import org.openecomp.sdc.common.api.Constants;
import org.openecomp.sdc.fe.config.Configuration;
import org.openecomp.sdc.fe.config.ConfigurationManager;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
-import javax.servlet.ServletException;
-
public abstract class SSLProxyServlet extends ProxyServlet {
private static final long serialVersionUID = 1L;
- private static final Logger LOGGER = LoggerFactory.getLogger(SSLProxyServlet.class);
+ private static final Logger log = LoggerFactory.getLogger(SSLProxyServlet.class);
@Override
protected HttpClient createHttpClient() throws ServletException {
Configuration config = ((ConfigurationManager) getServletConfig().getServletContext().getAttribute(Constants.CONFIGURATION_MANAGER_ATTR))
- .getConfiguration();
+ .getConfiguration();
boolean isSecureClient = !config.getBeProtocol().equals(BeProtocol.HTTP.getProtocolName());
HttpClient client = (isSecureClient) ? getSecureHttpClient() : super.createHttpClient();
int requestTimeout = config.getRequestTimeout() * 1000;
}
setTimeout(requestTimeout);
client.setIdleTimeout(requestTimeout);
+ client.setStopTimeout(requestTimeout);
return client;
}
private HttpClient getSecureHttpClient() throws ServletException {
- final SslContextFactory.Client sslContextFactory = new SslContextFactory.Client(true);
- try {
- sslContextFactory.setSslContext(JettySSLUtils.getSslContext());
- } catch (Exception e) {
- LOGGER.error("Exception thrown while getting SslContext", e);
- throw new ServletException(e);
- }
- final ClientConnector clientConnector = new ClientConnector();
- clientConnector.setSslContextFactory(sslContextFactory);
- final HttpClient httpClient = new HttpClient(new HttpClientTransportDynamic(clientConnector));
+ // Instantiate HttpClient with the SslContextFactory
+ final var httpClient = new HttpClient(new SslContextFactory.Client(true));
// Configure HttpClient, for example:
httpClient.setFollowRedirects(false);
// Start HttpClient
try {
httpClient.start();
} catch (Exception x) {
- LOGGER.error("Exception thrown while starting httpClient", x);
+ log.error("Exception thrown while starting httpClient", x);
throw new ServletException(x);
}
return httpClient;
}
-
}
* 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 org.eclipse.jetty.client.api.Request;
import org.eclipse.jetty.http.HttpFields;
-import org.junit.jupiter.api.BeforeAll;
-import org.junit.jupiter.api.BeforeEach;
-import org.junit.jupiter.api.Test;
+import org.junit.Before;
+import org.junit.BeforeClass;
+import org.junit.Test;
import org.mockito.Mockito;
import org.openecomp.sdc.common.api.Constants;
import org.openecomp.sdc.fe.config.Configuration;
import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertFalse;
-import static org.junit.Assert.assertThrows;
import static org.junit.Assert.assertTrue;
import static org.mockito.Mockito.when;
public class FeProxyServletTest {
- /*
- * Example Url Mappings:
- * http://localhost:8080/sdc1/feProxy/rest/services/MichaelTest2/0.0.1/csar
- * --> http://localhost:8090/sdc2/rest/services/MichaelTest2/0.0.1/csar
- * http://localhost:8080/sdc1/feProxy/dummy/not/working -->
- * http://localhost:8090/sdc2/dummy/not/working
- */
- private final FeProxyServletForTest feProxy = new FeProxyServletForTest();
- private static final HttpServletRequest servletRequest = Mockito.mock(HttpServletRequest.class);
- private static final HttpSession httpSession = Mockito.mock(HttpSession.class);
- private static final ServletContext servletContext = Mockito.mock(ServletContext.class);
- private static final ConfigurationManager configurationManager = Mockito.mock(ConfigurationManager.class);
- private static final Configuration configuration = Mockito.mock(Configuration.class);
- private static final Configuration.OnboardingConfig onboardingConfiguration = Mockito.mock(Configuration.OnboardingConfig.class);
- private static final Configuration.CatalogFacadeMsConfig catalogFacadeMsConfig = Mockito.mock(Configuration.CatalogFacadeMsConfig.class);
- private static final Request proxyRequest = Mockito.spy(Request.class);
- private static final HttpFields httpFields = Mockito.mock(HttpFields.class);
- private static final PluginsConfiguration pluginsConfiguration = Mockito.mock(PluginsConfiguration.class);
- private static final PluginsConfiguration.Plugin plugin = Mockito.mock(PluginsConfiguration.Plugin.class);
-
- private static final boolean sslEnabled = false;
- private static final String BE_PROTOCOL = "http";
- private static final String BE_PROTOCOL_SSL = "https";
- private static final String BE_HOST = "172.20.43.124";
- private static final int BE_PORT = 8090;
- private static final int BE_PORT_SSL = 9443;
- private static final String ONBOARDING_BE_PROTOCOL = "http";
- private static final String ONBOARDING_BE_HOST = "172.20.43.125";
- private static final int ONBOARDING_BE_PORT = 8091;
- private static final String WF_PROTOCOL = "http";
- private static final String WF_HOST = "172.20.43.126";
- private static final int WF_PORT = 8092;
- private static final String HEADER_1 = "Header1";
- private static final String HEADER_2 = "Header2";
- private static final String HEADER_3 = "Header3";
- private static final String HEADER_1_VAL = "Header1_Val";
- private static final String HEADER_2_VAL = "Header2_Val";
- private static final String HEADER_3_VAL = "Header3_Val";
- private static final String REQUEST_ID_VAL = "4867495a-5ed7-49e4-8be2-cc8d66fdd52b";
- private static final String msProtocol = "http";
- private static final String msHealth = "/healthCheck";
- private static final String msHost = "localhost";
- private static final Integer msPort = 8080;
- private static final String msPath = "/uicache";
- private static final String msUrl = String.format("%s://%s:%s", msProtocol, msHost, msPort);
-
- @BeforeAll
- public static void beforeClass() {
- when(servletRequest.getSession()).thenReturn(httpSession);
- when(httpSession.getServletContext()).thenReturn(servletContext);
- when(servletContext.getAttribute(Constants.CONFIGURATION_MANAGER_ATTR)).thenReturn(configurationManager);
- when(configurationManager.getConfiguration()).thenReturn(configuration);
- when(configuration.getBeProtocol()).thenReturn(sslEnabled ? BE_PROTOCOL_SSL : BE_PROTOCOL);
- when(configuration.getBeHost()).thenReturn(BE_HOST);
- when(configuration.getBeHttpPort()).thenReturn(BE_PORT);
- when(configuration.getBeSslPort()).thenReturn(BE_PORT_SSL);
- when(configuration.getOnboarding()).thenReturn(onboardingConfiguration);
- when(configuration.getOnboarding().getProtocolBe()).thenReturn(ONBOARDING_BE_PROTOCOL);
- when(configuration.getOnboarding().getHostBe()).thenReturn(ONBOARDING_BE_HOST);
- when(configuration.getOnboarding().getPortBe()).thenReturn(ONBOARDING_BE_PORT);
-
- List<String> strList = new ArrayList<>();
- strList.add(HEADER_1);
- strList.add(HEADER_2);
- strList.add(HEADER_3);
-
- when(servletRequest.getHeaderNames()).thenReturn(Collections.enumeration(strList));
- when(servletRequest.getHeader(HEADER_1)).thenReturn(HEADER_1_VAL);
- when(servletRequest.getHeader(HEADER_2)).thenReturn(HEADER_2_VAL);
- when(servletRequest.getHeader(HEADER_3)).thenReturn(HEADER_3_VAL);
- when(servletRequest.getHeader(Constants.X_ECOMP_REQUEST_ID_HEADER)).thenReturn(REQUEST_ID_VAL);
-
- when(proxyRequest.getHeaders()).thenReturn(httpFields);
- when(httpFields.contains(HEADER_1)).thenReturn(true);
- when(httpFields.contains(HEADER_2)).thenReturn(true);
- when(httpFields.contains(HEADER_3)).thenReturn(false);
-
- List<PluginsConfiguration.Plugin> pluginList = new ArrayList<PluginsConfiguration.Plugin>();
- when(plugin.getPluginId()).thenReturn("WORKFLOW");
- when(plugin.getPluginSourceUrl()).thenReturn(WF_PROTOCOL + "://" + WF_HOST + ":" + WF_PORT);
- when(plugin.getPluginDiscoveryUrl()).thenReturn(WF_PROTOCOL + "://" + WF_HOST + ":" + WF_PORT);
- pluginList.add(plugin);
- when(configurationManager.getPluginsConfiguration()).thenReturn(pluginsConfiguration);
- when(pluginsConfiguration.getPluginsList()).thenReturn(pluginList);
-
- }
-
- @BeforeEach
- public void setUp() {
- when(configuration.getCatalogFacadeMs()).thenReturn(catalogFacadeMsConfig);
- when(servletRequest.getQueryString()).thenReturn(null);
- when(catalogFacadeMsConfig.getPath()).thenReturn(null);
- }
-
- @Test
- void testRewriteURI_APIRequest() {
- when(servletRequest.getRequestURI()).thenReturn("/sdc1/feProxy/rest/dummyBeAPI");
- String requestResourceUrl = "http://localhost:8080/sdc1/feProxy/rest/dummyBeAPI";
- String expectedChangedUrl = (sslEnabled ? BE_PROTOCOL_SSL : BE_PROTOCOL) + "://" + BE_HOST + ":" + (sslEnabled ? BE_PORT_SSL : BE_PORT) + "/sdc2/rest/dummyBeAPI";
- when(servletRequest.getRequestURL()).thenReturn(new StringBuffer(requestResourceUrl));
-
- when(servletRequest.getContextPath()).thenReturn("/sdc1");
- when(servletRequest.getServletPath()).thenReturn("/feProxy/rest/dummyBeAPI");
-
- String rewriteURI = feProxy.rewriteTarget(servletRequest);
-
- assertEquals(expectedChangedUrl, rewriteURI);
- }
-
- @Test
- void testRewriteURIWithOnboardingAPIRequest() {
- when(servletRequest.getRequestURI()).thenReturn("/sdc1/feProxy/onboarding-api/gg%20g?subtype=VF");
- String requestResourceUrl = "http://localhost:8080/sdc1/feProxy/onboarding-api/gg%20g?subtype=VF";
- String expectedChangedUrl = ONBOARDING_BE_PROTOCOL + "://" + ONBOARDING_BE_HOST + ":" + ONBOARDING_BE_PORT + "/onboarding-api/gg%20g?subtype=VF";
- when(servletRequest.getRequestURL()).thenReturn(new StringBuffer(requestResourceUrl));
-
- when(servletRequest.getContextPath()).thenReturn("/sdc1");
- when(servletRequest.getServletPath()).thenReturn("/feProxy/onboarding-api/gg%20g?subtype=VF");
-
- String rewriteURI = feProxy.rewriteTarget(servletRequest);
-
- assertEquals(expectedChangedUrl, rewriteURI);
- }
-
- @Test
- void testRewriteURIWithQureyParam_APIRequest() {
- when(servletRequest.getRequestURI()).thenReturn("/sdc1/feProxy/dcae-api/gg%20g?subtype=VF");
- String requestResourceUrl = "http://localhost:8080/sdc1/feProxy/dcae-api/gg%20g?subtype=VF";
- String expectedChangedUrl = (sslEnabled ? BE_PROTOCOL_SSL : BE_PROTOCOL) + "://" + BE_HOST + ":" + (sslEnabled ? BE_PORT_SSL : BE_PORT) + "/dcae-api/gg%20g?subtype=VF";
- when(servletRequest.getRequestURL()).thenReturn(new StringBuffer(requestResourceUrl));
-
- when(servletRequest.getContextPath()).thenReturn("/sdc1");
- when(servletRequest.getServletPath()).thenReturn("/feProxy/dcae-api/gg%20g?subtype=VF");
-
- String rewriteURI = feProxy.rewriteTarget(servletRequest);
-
- assertEquals(expectedChangedUrl, rewriteURI);
- }
-
- @Test
- void testRewriteTargetWithRedeirectAPIRequest() {
- when(servletRequest.getRequestURI()).thenReturn("/sdc1/feProxy/rest/gg%20g?subtype=VF");
- String requestResourceUrl = "http://localhost:8080/sdc1/feProxy/rest/gg%20g?subtype=VF";
- String expectedChangedUrl = (sslEnabled ? BE_PROTOCOL_SSL : BE_PROTOCOL) + "://" + BE_HOST + ":" + (sslEnabled ? BE_PORT_SSL : BE_PORT) + "/sdc2/rest/gg%20g?subtype=VF";
- when(servletRequest.getRequestURL()).thenReturn(new StringBuffer(requestResourceUrl));
-
- when(servletRequest.getContextPath()).thenReturn("/sdc1");
- when(servletRequest.getServletPath()).thenReturn("/feProxy/rest/gg%20g?subtype=VF");
-
- String rewriteURI = feProxy.rewriteTarget(servletRequest);
-
- assertEquals(expectedChangedUrl, rewriteURI);
- }
-
- @Test
- void testRewriteURIWithWFAPIRequest() {
- when(servletRequest.getRequestURI()).thenReturn("/sdc1/feProxy/wf/workflows");
- String requestResourceUrl = "http://localhost:8080/sdc1/feProxy/wf/workflows";
- String expectedChangedUrl = WF_PROTOCOL + "://" + WF_HOST + ":" + WF_PORT + "/wf/workflows";
- when(servletRequest.getRequestURL()).thenReturn(new StringBuffer(requestResourceUrl));
-
- when(servletRequest.getContextPath()).thenReturn("/sdc1");
- when(servletRequest.getServletPath()).thenReturn("/feProxy/wf/workflows");
-
- String rewriteURI = feProxy.rewriteTarget(servletRequest);
-
- assertEquals(expectedChangedUrl, rewriteURI);
- }
-
- @Test
- void testRedirectToMSWhenMsUrlExists() throws MalformedURLException {
- final String urlParams = "x=1&y=2&z=3";
- final String url = "http//test.com:8080/uicache/v1/catalog";
- setUpConfigMocks();
- when(servletRequest.getRequestURL()).thenReturn(new StringBuffer(url));
- when(servletRequest.getQueryString()).thenReturn(urlParams);
- assertTrue(feProxy.isMsRequest(url + urlParams));
- assertEquals(msUrl + "/uicache/v1/catalog?" + urlParams,
- feProxy.redirectMsRequestToMservice(servletRequest, configuration));
- }
-
- @Test
- void testRedirectToMSWhenMsUrlExistsWithoutParams() throws MalformedURLException {
- final String uri = "/uicache/v1/home";
- final String url = String.format("http//test.com:8080%s", uri);
- setUpConfigMocks();
- when(servletRequest.getRequestURL()).thenReturn(new StringBuffer(url));
- when(servletRequest.getRequestURI()).thenReturn(uri);
- assertTrue(feProxy.isMsRequest(url));
- assertEquals(msUrl + "/uicache/v1/home", feProxy.redirectMsRequestToMservice(servletRequest, configuration));
- }
-
- @Test
- void testRedirectToBeOnToggleOff() throws MalformedURLException {
- final String uri = "/uicache/v1/catalog";
- final String url = String.format("http//test.com:8080%s", uri);
- when(catalogFacadeMsConfig.getPath()).thenReturn(null);
-
- when(servletRequest.getRequestURL()).thenReturn(new StringBuffer(url));
- when(servletRequest.getRequestURI()).thenReturn(uri);
- assertTrue(feProxy.isMsRequest(url));
- String expectedUrl = String.format("%s://%s:%s/rest/v1/screen?excludeTypes=VFCMT&excludeTypes=Configuration",
- (sslEnabled ? BE_PROTOCOL_SSL : BE_PROTOCOL), BE_HOST, (sslEnabled ? BE_PORT_SSL : BE_PORT));
- assertEquals(expectedUrl, feProxy.redirectMsRequestToMservice(servletRequest, configuration));
- }
-
- @Test
- void testRedirectToMSWhenMsUrlExistsButItIsNotCatalogRequest() throws MalformedURLException {
- final String url = "http//test.com:8080/rest/v1/sc";
- final String urlParams = "x=1&y=2&z=3";
- setUpConfigMocks();
- when(servletRequest.getRequestURL()).thenReturn(new StringBuffer(url));
- when(servletRequest.getQueryString()).thenReturn(urlParams);
- assertFalse(feProxy.isMsRequest(url));
- assertThrows(StringIndexOutOfBoundsException.class, () -> feProxy.redirectMsRequestToMservice(servletRequest, configuration));
- }
-
- private void setUpConfigMocks() {
- when(catalogFacadeMsConfig.getPath()).thenReturn(msPath);
- when(catalogFacadeMsConfig.getProtocol()).thenReturn(msProtocol);
- when(catalogFacadeMsConfig.getHost()).thenReturn(msHost);
- when(catalogFacadeMsConfig.getPort()).thenReturn(msPort);
- when(catalogFacadeMsConfig.getHealthCheckUri()).thenReturn(msHealth);
- }
-
- /* class for testing only exposes the protected method.*/
- public static class FeProxyServletForTest extends FeProxyServlet {
- private static final long serialVersionUID = 1L;
-
- @Override
- public String rewriteTarget(HttpServletRequest request) {
- return super.rewriteTarget(request);
- }
-
- @Override
- boolean isMsRequest(String currentUrl) {
- return super.isMsRequest(currentUrl);
- }
- }
+ /*
+ * Example Url Mappings:
+ * http://localhost:8080/sdc1/feProxy/rest/services/MichaelTest2/0.0.1/csar
+ * --> http://localhost:8090/sdc2/rest/services/MichaelTest2/0.0.1/csar
+ * http://localhost:8080/sdc1/feProxy/dummy/not/working -->
+ * http://localhost:8090/sdc2/dummy/not/working
+ */
+ FeProxyServletForTest feProxy = new FeProxyServletForTest();
+ final static HttpServletRequest servletRequest = Mockito.mock(HttpServletRequest.class);
+ final static HttpSession httpSession = Mockito.mock(HttpSession.class);
+ final static ServletContext servletContext = Mockito.mock(ServletContext.class);
+ final static ConfigurationManager configurationManager = Mockito.mock(ConfigurationManager.class);
+ final static Configuration configuration = Mockito.mock(Configuration.class);
+ final static Configuration.OnboardingConfig onboardingConfiguration = Mockito.mock(Configuration.OnboardingConfig.class);
+ private final static Configuration.CatalogFacadeMsConfig catalogFacadeMsConfig = Mockito.mock(Configuration.CatalogFacadeMsConfig.class);
+ final static Request proxyRequest = Mockito.spy(Request.class);
+ final static HttpFields httpFields = Mockito.mock(HttpFields.class);
+ private static final PluginsConfiguration pluginsConfiguration = Mockito.mock(PluginsConfiguration.class);
+ private static final PluginsConfiguration.Plugin plugin = Mockito.mock(PluginsConfiguration.Plugin.class);
+
+ final static String BE_PROTOCOL = "http";
+ final static String BE_HOST = "172.20.43.124";
+ final static int BE_PORT = 8090;
+ final static String ONBOARDING_BE_PROTOCOL = "http";
+ final static String ONBOARDING_BE_HOST = "172.20.43.125";
+ final static int ONBOARDING_BE_PORT = 8091;
+ final static String WF_PROTOCOL = "http";
+ final static String WF_HOST = "172.20.43.126";
+ final static int WF_PORT = 8092;
+ final static String HEADER_1 = "Header1";
+ final static String HEADER_2 = "Header2";
+ final static String HEADER_3 = "Header3";
+ final static String HEADER_1_VAL = "Header1_Val";
+ final static String HEADER_2_VAL = "Header2_Val";
+ final static String HEADER_3_VAL = "Header3_Val";
+ final static String REQUEST_ID_VAL = "4867495a-5ed7-49e4-8be2-cc8d66fdd52b";
+ private final static String msProtocol = "http";
+ private final static String msHealth = "/healthCheck";
+ private final static String msHost = "localhost";
+ private final static Integer msPort = 8080;
+ private final static String msPath = "/uicache";
+ private final static String msUrl = String.format("%s://%s:%s", msProtocol, msHost, msPort);
+
+ @BeforeClass
+ public static void beforeClass() {
+ when(servletRequest.getSession()).thenReturn(httpSession);
+ when(httpSession.getServletContext()).thenReturn(servletContext);
+ when(servletContext.getAttribute(Constants.CONFIGURATION_MANAGER_ATTR)).thenReturn(configurationManager);
+ when(configurationManager.getConfiguration()).thenReturn(configuration);
+ when(configuration.getBeProtocol()).thenReturn(BE_PROTOCOL);
+ when(configuration.getBeHost()).thenReturn(BE_HOST);
+ when(configuration.getBeHttpPort()).thenReturn(BE_PORT);
+ when(configuration.getOnboarding()).thenReturn(onboardingConfiguration);
+ when(configuration.getOnboarding().getProtocolBe()).thenReturn(ONBOARDING_BE_PROTOCOL);
+ when(configuration.getOnboarding().getHostBe()).thenReturn(ONBOARDING_BE_HOST);
+ when(configuration.getOnboarding().getPortBe()).thenReturn(ONBOARDING_BE_PORT);
+
+ List<String> strList = new ArrayList<>();
+ strList.add(HEADER_1);
+ strList.add(HEADER_2);
+ strList.add(HEADER_3);
+
+ when(servletRequest.getHeaderNames()).thenReturn(Collections.enumeration(strList));
+ when(servletRequest.getHeader(HEADER_1)).thenReturn(HEADER_1_VAL);
+ when(servletRequest.getHeader(HEADER_2)).thenReturn(HEADER_2_VAL);
+ when(servletRequest.getHeader(HEADER_3)).thenReturn(HEADER_3_VAL);
+ when(servletRequest.getHeader(Constants.X_ECOMP_REQUEST_ID_HEADER)).thenReturn(REQUEST_ID_VAL);
+
+ when(proxyRequest.getHeaders()).thenReturn(httpFields);
+ when(httpFields.containsKey(HEADER_1)).thenReturn(true);
+ when(httpFields.containsKey(HEADER_2)).thenReturn(true);
+ when(httpFields.containsKey(HEADER_3)).thenReturn(false);
+
+ List<PluginsConfiguration.Plugin> pluginList = new ArrayList<PluginsConfiguration.Plugin>();
+ when(plugin.getPluginId()).thenReturn("WORKFLOW");
+ when(plugin.getPluginSourceUrl()).thenReturn(WF_PROTOCOL + "://" + WF_HOST + ":" + WF_PORT);
+ when(plugin.getPluginDiscoveryUrl()).thenReturn(WF_PROTOCOL + "://" + WF_HOST + ":" + WF_PORT);
+ pluginList.add(plugin);
+ when(configurationManager.getPluginsConfiguration()).thenReturn(pluginsConfiguration);
+ when(pluginsConfiguration.getPluginsList()).thenReturn(pluginList);
+
+ }
+
+ @Before
+ public void setUp() {
+ when(configuration.getCatalogFacadeMs()).thenReturn(catalogFacadeMsConfig);
+ when(servletRequest.getQueryString()).thenReturn(null);
+ when(catalogFacadeMsConfig.getPath()).thenReturn(null);
+ }
+ @Test
+ public void testRewriteURI_APIRequest() {
+ when(servletRequest.getRequestURI()).thenReturn("/sdc1/feProxy/rest/dummyBeAPI");
+ String requestResourceUrl = "http://localhost:8080/sdc1/feProxy/rest/dummyBeAPI";
+ String expectedChangedUrl = BE_PROTOCOL + "://" + BE_HOST + ":" + BE_PORT + "/sdc2/rest/dummyBeAPI";
+ when(servletRequest.getRequestURL()).thenReturn(new StringBuffer(requestResourceUrl));
+
+ when(servletRequest.getContextPath()).thenReturn("/sdc1");
+ when(servletRequest.getServletPath()).thenReturn("/feProxy/rest/dummyBeAPI");
+
+ String rewriteURI = feProxy.rewriteTarget(servletRequest);
+
+ assertTrue(rewriteURI.equals(expectedChangedUrl));
+ }
+
+ @Test
+ public void testRewriteURIWithOnboardingAPIRequest() {
+ when(servletRequest.getRequestURI()).thenReturn("/sdc1/feProxy/onboarding-api/gg%20g?subtype=VF");
+ String requestResourceUrl = "http://localhost:8080/sdc1/feProxy/onboarding-api/gg%20g?subtype=VF";
+ String expectedChangedUrl = ONBOARDING_BE_PROTOCOL + "://" + ONBOARDING_BE_HOST + ":" + ONBOARDING_BE_PORT + "/onboarding-api/gg%20g?subtype=VF";
+ when(servletRequest.getRequestURL()).thenReturn(new StringBuffer(requestResourceUrl));
+
+ when(servletRequest.getContextPath()).thenReturn("/sdc1");
+ when(servletRequest.getServletPath()).thenReturn("/feProxy/onboarding-api/gg%20g?subtype=VF");
+
+ String rewriteURI = feProxy.rewriteTarget(servletRequest);
+
+ assertTrue(rewriteURI.equals(expectedChangedUrl));
+ }
+
+
+ @Test
+ public void testRewriteURIWithQureyParam_APIRequest() {
+ when(servletRequest.getRequestURI()).thenReturn("/sdc1/feProxy/dcae-api/gg%20g?subtype=VF");
+ String requestResourceUrl = "http://localhost:8080/sdc1/feProxy/dcae-api/gg%20g?subtype=VF";
+ String expectedChangedUrl = BE_PROTOCOL + "://" + BE_HOST + ":" + BE_PORT + "/dcae-api/gg%20g?subtype=VF";
+ when(servletRequest.getRequestURL()).thenReturn(new StringBuffer(requestResourceUrl));
+
+ when(servletRequest.getContextPath()).thenReturn("/sdc1");
+ when(servletRequest.getServletPath()).thenReturn("/feProxy/dcae-api/gg%20g?subtype=VF");
+
+ String rewriteURI = feProxy.rewriteTarget(servletRequest);
+
+ assertTrue(rewriteURI.equals(expectedChangedUrl));
+ }
+
+ @Test
+ public void testRewriteTargetWithRedeirectAPIRequest() {
+ when(servletRequest.getRequestURI()).thenReturn("/sdc1/feProxy/rest/gg%20g?subtype=VF");
+ String requestResourceUrl = "http://localhost:8080/sdc1/feProxy/rest/gg%20g?subtype=VF";
+ String expectedChangedUrl = BE_PROTOCOL + "://" + BE_HOST + ":" + BE_PORT + "/sdc2/rest/gg%20g?subtype=VF";
+ when(servletRequest.getRequestURL()).thenReturn(new StringBuffer(requestResourceUrl));
+
+ when(servletRequest.getContextPath()).thenReturn("/sdc1");
+ when(servletRequest.getServletPath()).thenReturn("/feProxy/rest/gg%20g?subtype=VF");
+
+ String rewriteURI = feProxy.rewriteTarget(servletRequest);
+
+ assertTrue(rewriteURI.equals(expectedChangedUrl));
+ }
+
+
+
+ @Test
+ public void testRewriteURIWithWFAPIRequest() {
+ when(servletRequest.getRequestURI()).thenReturn("/sdc1/feProxy/wf/workflows");
+ String requestResourceUrl = "http://localhost:8080/sdc1/feProxy/wf/workflows";
+ String expectedChangedUrl = WF_PROTOCOL + "://" + WF_HOST + ":" + WF_PORT + "/wf/workflows";
+ when(servletRequest.getRequestURL()).thenReturn(new StringBuffer(requestResourceUrl));
+
+ when(servletRequest.getContextPath()).thenReturn("/sdc1");
+ when(servletRequest.getServletPath()).thenReturn("/feProxy/wf/workflows");
+
+ String rewriteURI = feProxy.rewriteTarget(servletRequest);
+
+ assertEquals(expectedChangedUrl, rewriteURI);
+ }
+
+ @Test
+ public void testRedirectToMSWhenMsUrlExists() throws MalformedURLException {
+ final String urlParams = "x=1&y=2&z=3";
+ final String url = "http//test.com:8080/uicache/v1/catalog";
+ setUpConfigMocks();
+ when(servletRequest.getRequestURL()).thenReturn(new StringBuffer(url));
+ when(servletRequest.getQueryString()).thenReturn(urlParams);
+ assertTrue(feProxy.isMsRequest(url + urlParams));
+ assertEquals(msUrl + "/uicache/v1/catalog?" + urlParams,
+ feProxy.redirectMsRequestToMservice(servletRequest, configuration));
+ }
+
+ @Test
+ public void testRedirectToMSWhenMsUrlExistsWithoutParams() throws MalformedURLException {
+ final String uri = "/uicache/v1/home";
+ final String url = String.format("http//test.com:8080%s", uri);
+ setUpConfigMocks();
+ when(servletRequest.getRequestURL()).thenReturn(new StringBuffer(url));
+ when(servletRequest.getRequestURI()).thenReturn(uri);
+ assertTrue(feProxy.isMsRequest(url));
+ assertEquals(msUrl + "/uicache/v1/home", feProxy.redirectMsRequestToMservice(servletRequest, configuration));
+ }
+ @Test
+ public void testRedirectToBeOnToggleOff() throws MalformedURLException {
+ final String uri = "/uicache/v1/catalog";
+ final String url = String.format("http//test.com:8080%s", uri);
+ when(catalogFacadeMsConfig.getPath()).thenReturn(null);
+
+ when(servletRequest.getRequestURL()).thenReturn(new StringBuffer(url));
+ when(servletRequest.getRequestURI()).thenReturn(uri);
+ assertTrue(feProxy.isMsRequest(url));
+ String expectedUrl = String.format("%s://%s:%s/rest/v1/screen?excludeTypes=VFCMT&excludeTypes=Configuration",
+ BE_PROTOCOL, BE_HOST, BE_PORT);
+ assertEquals(expectedUrl, feProxy.redirectMsRequestToMservice(servletRequest, configuration));
+ }
+ @Test(expected = StringIndexOutOfBoundsException.class)
+ public void testRedirectToMSWhenMsUrlExistsButItIsNotCatalogRequest() throws MalformedURLException {
+ final String url = "http//test.com:8080/rest/v1/sc";
+ final String urlParams = "x=1&y=2&z=3";
+ setUpConfigMocks();
+ when(servletRequest.getRequestURL()).thenReturn(new StringBuffer(url));
+ when(servletRequest.getQueryString()).thenReturn(urlParams);
+ assertFalse(feProxy.isMsRequest(url));
+ feProxy.redirectMsRequestToMservice(servletRequest, configuration);
+ }
+
+ private void setUpConfigMocks() {
+ when(catalogFacadeMsConfig.getPath()).thenReturn(msPath);
+ when(catalogFacadeMsConfig.getProtocol()).thenReturn(msProtocol);
+ when(catalogFacadeMsConfig.getHost()).thenReturn(msHost);
+ when(catalogFacadeMsConfig.getPort()).thenReturn(msPort);
+ when(catalogFacadeMsConfig.getHealthCheckUri()).thenReturn(msHealth);
+ }
+
+ /* class for testing only exposes the protected method.*/
+ public static class FeProxyServletForTest extends FeProxyServlet{
+ private static final long serialVersionUID = 1L;
+ @Override
+ public String rewriteTarget(HttpServletRequest request) {
+ return super.rewriteTarget(request);
+ }
+ @Override
+ boolean isMsRequest(String currentUrl) {
+ return super.isMsRequest(currentUrl);
+ }
+ }
}
</exclusion>
</exclusions>
</dependency>
- <dependency>
- <groupId>org.onap.sdc.common</groupId>
- <artifactId>onap-configuration-management-api</artifactId>
- <version>${project.version}</version>
- <scope>compile</scope>
- </dependency>
</dependencies>
<build>
package org.openecomp.sdc.be.config;
import com.google.common.annotations.VisibleForTesting;
+import java.util.HashMap;
+import java.util.Map;
import org.openecomp.sdc.be.config.validation.ArtifactConfigValidator;
import org.openecomp.sdc.common.api.ArtifactTypeEnum;
import org.openecomp.sdc.common.api.BasicConfiguration;
import org.openecomp.sdc.common.config.EcompErrorConfiguration;
import org.openecomp.sdc.common.config.IEcompConfigurationManager;
-import java.util.HashMap;
-import java.util.Map;
-
public class ConfigurationManager implements FileChangeCallback, IEcompConfigurationManager {
private static ConfigurationManager instance;
final Map<String, Object> configurations = new HashMap<>();
- private ConfigurationSource configurationSource;
+ ConfigurationSource configurationSource = null;
@VisibleForTesting
public ConfigurationManager() {
final Object configurationObj = configurations.get(getKey(Configuration.class));
if (configurationObj instanceof Configuration) {
final ArtifactConfigValidator artifactConfigValidator = new ArtifactConfigValidator((Configuration) configurationObj,
- ArtifactTypeEnum.getBaseArtifacts());
+ ArtifactTypeEnum.getBaseArtifacts());
artifactConfigValidator.validate();
}
}
import org.apache.http.client.UserTokenHandler;
import org.apache.http.client.config.RequestConfig;
import org.apache.http.conn.HttpClientConnectionManager;
-import org.apache.http.impl.client.HttpClientBuilder;
+import org.apache.http.impl.client.CloseableHttpClient;
import org.apache.http.impl.client.HttpClients;
-import org.onap.config.api.JettySSLUtils;
import org.openecomp.sdc.common.api.Constants;
import org.openecomp.sdc.common.http.config.ClientCertificate;
-import org.slf4j.Logger;
-import org.slf4j.LoggerFactory;
+import org.openecomp.sdc.common.log.wrappers.Logger;
public class HttpClientFactory {
- private static final Logger LOGGER = LoggerFactory.getLogger(HttpClientFactory.class);
+ private static final Logger logger = Logger.getLogger(HttpClientFactory.class.getName());
private static final UserTokenHandler userTokenHandler = context -> null;
private final HttpConnectionMngFactory connectionMngFactory;
}
HttpClient createClient(String protocol, HttpClientConfigImmutable config) {
- LOGGER.debug("Create {} client based on {}", protocol, config);
- final ClientCertificate clientCertificate = Constants.HTTPS.equals(protocol) ? config.getClientCertificate() : null;
- final HttpClientConnectionManager connectionManager = connectionMngFactory.getOrCreate(clientCertificate);
- final RequestConfig requestConfig = createClientTimeoutConfiguration(config);
-
- try {
- final HttpClientBuilder httpClientBuilder = HttpClients.custom()
- .setDefaultRequestConfig(requestConfig)
- .setConnectionManager(connectionManager)
- .setUserTokenHandler(userTokenHandler)
- .setRetryHandler(resolveRetryHandler(config));
- if (clientCertificate != null) {
- httpClientBuilder.setSSLContext(JettySSLUtils.getSslContext());
- }
- return new HttpClient(httpClientBuilder.build(), config);
- } catch (Exception e) {
- LOGGER.error("Failed to createClient", e);
- throw new RuntimeException(e);
- }
+ logger.debug("Create {} client based on {}", protocol, config);
+ ClientCertificate clientCertificate = Constants.HTTPS.equals(protocol) ? config.getClientCertificate() : null;
+ HttpClientConnectionManager connectionManager = connectionMngFactory.getOrCreate(clientCertificate);
+ RequestConfig requestConfig = createClientTimeoutConfiguration(config);
+ CloseableHttpClient client = HttpClients.custom().setDefaultRequestConfig(requestConfig).setConnectionManager(connectionManager)
+ .setUserTokenHandler(userTokenHandler).setRetryHandler(resolveRetryHandler(config)).build();
+ return new HttpClient(client, config);
}
private HttpRequestRetryHandler resolveRetryHandler(HttpClientConfigImmutable config) {
*/
package org.openecomp.sdc.common.http.client.api;
-import lombok.AllArgsConstructor;
-import lombok.Getter;
import org.apache.commons.lang3.StringUtils;
-@Getter
-@AllArgsConstructor
public class HttpResponse<T> {
private final T response;
private final String description;
public HttpResponse(T response, int statusCode) {
- this(response, statusCode, StringUtils.EMPTY);
+ this.response = response;
+ this.statusCode = statusCode;
+ this.description = StringUtils.EMPTY;
+ }
+
+ public HttpResponse(T response, int statusCode, String description) {
+ this.response = response;
+ this.statusCode = statusCode;
+ this.description = description;
+ }
+
+ public T getResponse() {
+ return response;
+ }
+
+ public int getStatusCode() {
+ return statusCode;
+ }
+
+ public String getDescription() {
+ return description;
}
@Override
public String toString() {
- return "HttpResponse [response=" + response + ", statusCode=" + statusCode + ", description=" + description + "]";
+ StringBuilder builder = new StringBuilder();
+ builder.append("HttpResponse [response=");
+ builder.append(response);
+ builder.append(", statusCode=");
+ builder.append(statusCode);
+ builder.append(", description=");
+ builder.append(description);
+ builder.append("]");
+ return builder.toString();
}
}
private static Logger log = Logger.getLogger(AppContextListener.class.getName());
- @Override
public void contextInitialized(ServletContextEvent context) {
log.debug("ServletContextListener initialized ");
log.debug("After read values from Manifest {}", getManifestInfo(context.getServletContext()));
ExternalConfiguration.listenForChanges();
}
- @Override
public void contextDestroyed(ServletContextEvent context) {
log.debug("ServletContextListener destroyed");
ExternalConfiguration.stopListenForFileChanges();
--- /dev/null
+package org.openecomp.sdc.common.log.interceptors;
+
+import java.io.IOException;
+import java.net.URI;
+import org.apache.http.HttpException;
+import org.apache.http.HttpMessage;
+import org.apache.http.HttpRequest;
+import org.apache.http.HttpRequestInterceptor;
+import org.apache.http.HttpResponse;
+import org.apache.http.protocol.HttpContext;
+import org.onap.logging.filter.base.AbstractMetricLogFilter;
+import org.onap.logging.ref.slf4j.ONAPLogConstants;
+import org.openecomp.sdc.common.log.elements.LogFieldsMdcHandler;
+
+public class ApacheClientLogRequestInterceptor extends AbstractMetricLogFilter<HttpRequest, HttpResponse, HttpMessage> implements
+ HttpRequestInterceptor {
+
+ private String previousInvocationId;
+
+ @Override
+ protected void addHeader(HttpMessage httpMessage, String s, String s1) {
+ httpMessage.addHeader(s, s1);
+ }
+
+ @Override
+ protected String getTargetServiceName(HttpRequest httpRequest) {
+ return httpRequest.getRequestLine().getUri();
+ }
+
+ @Override
+ protected String getServiceName(HttpRequest httpRequest) {
+ return URI.create(httpRequest.getRequestLine().getUri()).getPath();
+ }
+
+ @Override
+ protected int getHttpStatusCode(HttpResponse httpResponse) {
+ return httpResponse.getStatusLine().getStatusCode();
+ }
+
+ @Override
+ protected String getResponseCode(HttpResponse httpResponse) {
+ return String.valueOf(httpResponse.getStatusLine().getStatusCode());
+ }
+
+ @Override
+ protected String getTargetEntity(HttpRequest httpRequest) {
+ //fallback to default value that provided by AbstractMetricLogFilter
+ return null;
+ }
+
+ @Override
+ protected void additionalPre(HttpRequest httpRequest, HttpMessage httpMessage) {
+ String outgoingInvocationId = httpMessage.getFirstHeader(ONAPLogConstants.Headers.INVOCATION_ID).getValue();
+ LogFieldsMdcHandler.getInstance().setOutgoingInvocationId(outgoingInvocationId);
+ LogFieldsMdcHandler.getInstance().setKeyInvocationId(previousInvocationId);
+ }
+
+ @Override
+ public void process(HttpRequest httpRequest, HttpContext httpContext) throws HttpException, IOException {
+ previousInvocationId = LogFieldsMdcHandler.getInstance().getKeyInvocationId();
+ super.pre(httpRequest, httpRequest);
+ }
+}
--- /dev/null
+package org.openecomp.sdc.common.log.interceptors;
+
+import java.io.IOException;
+import java.net.URI;
+import org.apache.http.HttpException;
+import org.apache.http.HttpMessage;
+import org.apache.http.HttpRequest;
+import org.apache.http.HttpResponse;
+import org.apache.http.HttpResponseInterceptor;
+import org.apache.http.protocol.HttpContext;
+import org.onap.logging.filter.base.AbstractMetricLogFilter;
+
+public class ApacheClientLogResponseInterceptor extends AbstractMetricLogFilter<HttpRequest, HttpResponse, HttpMessage> implements
+ HttpResponseInterceptor {
+
+ @Override
+ protected void addHeader(HttpMessage httpMessage, String s, String s1) {
+ httpMessage.addHeader(s, s1);
+ }
+
+ @Override
+ protected String getTargetServiceName(HttpRequest httpRequest) {
+ return httpRequest.getRequestLine().getUri();
+ }
+
+ @Override
+ protected String getServiceName(HttpRequest httpRequest) {
+ return URI.create(httpRequest.getRequestLine().getUri()).getPath();
+ }
+
+ @Override
+ protected int getHttpStatusCode(HttpResponse httpResponse) {
+ return httpResponse.getStatusLine().getStatusCode();
+ }
+
+ @Override
+ protected String getResponseCode(HttpResponse httpResponse) {
+ return String.valueOf(httpResponse.getStatusLine().getStatusCode());
+ }
+
+ @Override
+ protected String getTargetEntity(HttpRequest httpRequest) {
+ //fallback to default value that provided by AbstractMetricLogFilter
+ return null;
+ }
+
+ @Override
+ public void process(HttpResponse httpResponse, HttpContext httpContext) throws HttpException, IOException {
+ super.post(null, httpResponse);
+ }
+}
--- /dev/null
+/*-
+ * ============LICENSE_START=======================================================
+ * SDC
+ * ================================================================================
+ * Copyright (C) 2017 AT&T Intellectual Property. All rights reserved.
+ * ================================================================================
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ * ============LICENSE_END=========================================================
+ */
+package org.openecomp.sdc.common.util;
+
+import java.util.ArrayList;
+import java.util.List;
+import java.util.Spliterator;
+import java.util.Spliterators.AbstractSpliterator;
+import java.util.function.Consumer;
+import java.util.function.Predicate;
+import java.util.stream.Stream;
+import java.util.stream.StreamSupport;
+
+/**
+ * Utility Class For Actions On Streams
+ *
+ * @author mshitrit
+ */
+public final class StreamUtils {
+
+ private StreamUtils() {
+ throw new UnsupportedOperationException();
+ }
+
+ /**
+ * Breaks the stream when the predicate is not met.<br> Does not evaluate elements after the stream breaks.<br> This method evaluates the
+ * stream.<br>
+ *
+ * @param stream
+ * @param predicate
+ * @return
+ */
+ public static <T> Stream<T> takeWhilePlusOneNoEval(Stream<T> stream, Predicate<T> predicate) {
+ List<T> results = new ArrayList<>();
+ Consumer<T> listAdder = results::add;
+ stream.map(e -> {
+ listAdder.accept(e);
+ return e;
+ }).filter(e -> !predicate.test(e)).findFirst();
+ return results.stream();
+ }
+
+ public static <T> Stream<T> takeWhile(Stream<T> stream, Predicate<T> predicate) {
+ return StreamSupport.stream(takeWhile(stream.spliterator(), predicate), false);
+ }
+
+ public static <T> Stream<T> takeWhilePlusOne(Stream<T> stream, Predicate<T> predicate) {
+ return StreamSupport.stream(takeWhile(stream.spliterator(), new StopAfterFailPredicate<>(predicate)), false);
+ }
+
+ private static <T> Spliterator<T> takeWhile(Spliterator<T> splitr, Predicate<T> predicate) {
+ return new MySplitIterator<>(splitr, predicate);
+ }
+
+ public static class MySplitIterator<T> extends AbstractSpliterator<T> implements Spliterator<T> {
+
+ boolean stillGoing = true;
+ private Spliterator<T> innerItr;
+ private Predicate<T> innerPred;
+
+ private MySplitIterator(Spliterator<T> splitItr, Predicate<T> pred) {
+ super(splitItr.estimateSize(), 0);
+ innerItr = splitItr;
+ innerPred = pred;
+ }
+
+ @Override
+ public boolean tryAdvance(Consumer<? super T> action) {
+ boolean canAdvance = true;
+ if (stillGoing) {
+ stillGoing = innerItr.tryAdvance(createConsumerWrapper(action));
+ } else {
+ canAdvance = false;
+ }
+ return canAdvance;
+ }
+
+ private Consumer<? super T> createConsumerWrapper(Consumer<? super T> action) {
+ return new Consumer<T>() {
+ @Override
+ public void accept(T t) {
+ stillGoing = innerPred.test(t);
+ if (stillGoing) {
+ action.accept(t);
+ }
+ }
+ };
+ }
+ }
+
+ public static class StopAfterFailPredicate<T> implements Predicate<T> {
+
+ boolean hasNotFailed;
+ Predicate<T> innerPredicate;
+
+ private StopAfterFailPredicate(Predicate<T> pred) {
+ hasNotFailed = true;
+ innerPredicate = pred;
+ }
+
+ ;
+
+ @Override
+ public boolean test(T t) {
+ boolean isPassed;
+ if (hasNotFailed) {
+ isPassed = true;
+ hasNotFailed = innerPredicate.test(t);
+ } else {
+ isPassed = false;
+ }
+ return isPassed;
+ }
+ }
+}
private static final Logger log = Logger.getLogger(ConfigurationManager.class.getName());
private static ConfigurationManager instance;
- private final ConfigurationSource configurationSource;
- private final Map<String, Object> configurations = new HashMap<>();
+ ConfigurationSource configurationSource = null;
+ Map<String, Object> configurations = new HashMap<>();
public ConfigurationManager(ConfigurationSource configurationSource) {
super();
return (Configuration) configurations.get(getKey(Configuration.class));
}
- @Override
public void reconfigure(BasicConfiguration obj) {
//
package org.openecomp.sdc.common.http.client.api;
-import org.junit.jupiter.api.Test;
-import org.junit.jupiter.api.extension.ExtendWith;
+import org.junit.Test;
+import org.junit.runner.RunWith;
import org.mockito.Mock;
import org.mockito.Mockito;
-import org.mockito.junit.jupiter.MockitoExtension;
+import org.mockito.junit.MockitoJUnitRunner;
import org.onap.sdc.security.SecurityUtil;
import org.openecomp.sdc.common.http.config.BasicAuthorization;
import org.openecomp.sdc.common.http.config.ClientCertificate;
import static junit.framework.TestCase.assertNotNull;
-@ExtendWith(MockitoExtension.class)
-class HttpClientFactoryTest {
+@RunWith(MockitoJUnitRunner.class)
+public class HttpClientFactoryTest {
@Mock
- private HttpConnectionMngFactory httpConnectionMngFactory;
+ HttpConnectionMngFactory httpConnectionMngFactory;
@Test
- void validateNewClientCreationReturnsValidClient() {
- final HttpClient httpClient = new HttpClientFactory(httpConnectionMngFactory).createClient("Http", prepareTestClientConfigImmutable());
+ public void validateNewClientCreationReturnsValidClient() throws HttpExecuteException {
+ HttpClient httpClient = new HttpClientFactory(httpConnectionMngFactory).createClient("Http",prepareTestClientConfigImmutable());
assertNotNull(httpClient);
httpClient.close();
}
package org.openecomp.sdc.common.http.client.api;
import org.apache.http.HttpStatus;
-import org.junit.jupiter.api.Test;
+import org.junit.Test;
-import static org.junit.jupiter.api.Assertions.assertEquals;
-import static org.junit.jupiter.api.Assertions.assertTrue;
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertTrue;
-class HttpResponseTest {
+public class HttpResponseTest {
@Test
- void validateNoDescriptionConstructor() {
+ public void validateNoDescriptionConstructor() {
final String testResponse = "test response";
HttpResponse<String> httpResponseTest = new HttpResponse<>(testResponse, HttpStatus.SC_OK);
- assertEquals(httpResponseTest.getStatusCode(), HttpStatus.SC_OK);
- assertEquals(httpResponseTest.getResponse(), testResponse);
- assertEquals(httpResponseTest.getDescription(), "");
+ assertEquals(httpResponseTest.getStatusCode(),HttpStatus.SC_OK);
+ assertEquals(httpResponseTest.getResponse(),testResponse);
+ assertEquals(httpResponseTest.getDescription(),"");
}
@Test
- void validateAllArgsConstructor() {
+ public void validateAllArgsConstructor() {
final String testResponse = "test response";
final String testDescription = "test description";
HttpResponse<String> httpResponseTest = new HttpResponse<>(testResponse, HttpStatus.SC_OK, testDescription);
- assertEquals(httpResponseTest.getStatusCode(), HttpStatus.SC_OK);
- assertEquals(httpResponseTest.getResponse(), testResponse);
- assertEquals(httpResponseTest.getDescription(), testDescription);
+ assertEquals(httpResponseTest.getStatusCode(),HttpStatus.SC_OK);
+ assertEquals(httpResponseTest.getResponse(),testResponse);
+ assertEquals(httpResponseTest.getDescription(),testDescription);
}
@Test
- void validateToStringConstructor() {
+ public void validateToStringConstructor() {
final String testResponse = "test response";
final String testDescription = "test description";
--- /dev/null
+/*-
+ * ============LICENSE_START=======================================================
+ * SDC
+ * ================================================================================
+ * Copyright (C) 2017 AT&T Intellectual Property. All rights reserved.
+ * ================================================================================
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ * ============LICENSE_END=========================================================
+ */
+
+package org.openecomp.sdc.common.util;
+
+import fj.data.Either;
+import static org.junit.Assert.assertEquals;
+import org.junit.Test;
+
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.List;
+import java.util.function.Function;
+import java.util.stream.Collectors;
+import java.util.stream.Stream;
+
+import static org.junit.Assert.assertTrue;
+
+public class StreamUtilsTests {
+ @Test
+ public void testTakeWhilePredicateNotMet() {
+ List<Either<Integer, Boolean>> list = buildListWith10Integers();
+
+ assertEquals(10, StreamUtils.takeWhile(list.stream(), Either::isLeft).count());
+ }
+
+ @Test
+ public void testTakeWhilePredicateIsMet() {
+ List<Either<Integer, Boolean>> list = buildListWith10Integers();
+ addToBooleansToList(list);
+
+ final Stream<Either<Integer, Boolean>> takeWhileStream = StreamUtils.takeWhile(list.stream(), Either::isLeft);
+ assertEquals(0, takeWhileStream.filter(Either::isRight).count());
+ }
+
+ @Test
+ public <T> void testTakeErrorEvalOnlyOnce() {
+ List<Integer> bucket = new ArrayList<>();
+ // API
+ Function<Integer, Either<Integer, Boolean>> cons = num -> {
+ Either<Integer, Boolean> ret;
+ bucket.add(num);
+ if (num > 5) {
+ ret = Either.right(false);
+ } else {
+ ret = Either.left(num);
+ }
+ ;
+ return ret;
+ };
+
+ List<Integer> num1to10 = Arrays.asList(1, 2, 3, 4, 5, 6, 7, 8, 9, 10);
+ Stream<Either<Integer, Boolean>> streamEithers = num1to10.stream().map(cons::apply);
+ List<Either<Integer, Boolean>> collect = StreamUtils.takeWhilePlusOneNoEval(streamEithers, Either::isLeft)
+ .collect(Collectors.toList());
+ assertTrue(bucket.size() <= 6);
+ assertTrue(collect.size() <= 6);
+ assertEquals(1, collect.stream().filter(Either::isRight).count());
+
+ }
+
+ @Test
+ public void testTakeWhilePlusOnePredicateNotMet() {
+ List<Either<Integer, Boolean>> list = buildListWith10Integers();
+
+ assertEquals(10, StreamUtils.takeWhilePlusOne(list.stream(), Either::isLeft).count());
+ }
+
+ @Test
+ public void testTakeWhilePlusOnePredicateIsMet() {
+ List<Either<Integer, Boolean>> list = buildListWith10Integers();
+ addToBooleansToList(list);
+
+ final Stream<Either<Integer, Boolean>> takeWhilePlusOneStream = StreamUtils.takeWhilePlusOne(list.stream(),
+ Either::isLeft);
+ assertEquals(1, takeWhilePlusOneStream.filter(Either::isRight).count());
+ }
+
+ private void addToBooleansToList(List<Either<Integer, Boolean>> list) {
+ list.add(Either.right(false));
+ list.add(Either.right(false));
+ }
+
+ private List<Either<Integer, Boolean>> buildListWith10Integers() {
+ List<Either<Integer, Boolean>> list = new ArrayList<>();
+ for (int i = 0; i < 10; i++) {
+ list.add(Either.left(i));
+ }
+ return list;
+ }
+
+ @Test
+ public void myTest() {
+ List<Integer> list = new ArrayList<>();
+ for (int i = 0; i < 10; i++) {
+ list.add(i);
+ }
+
+ List<Either<Integer, Boolean>> container = new ArrayList<>();
+ list.stream().map(e -> myBusinessLogic(e, container)).filter(Either::isRight).findAny();
+ // Actual Results are in container
+ assertEquals(6, container.size());
+
+ }
+
+ private Either<Integer, Boolean> myBusinessLogic(int e, List<Either<Integer, Boolean>> cobtainerList) {
+ Either<Integer, Boolean> eitherElement = similuteDBAccess(e);
+ // Keep The results in external List
+ cobtainerList.add(eitherElement);
+
+ return eitherElement;
+ }
+
+ private Either<Integer, Boolean> similuteDBAccess(int e) {
+ Either<Integer, Boolean> eitherElement;
+ if (e < 5) {
+ // DB Success
+ eitherElement = Either.left(e);
+ } else {
+ // DB Fail
+ eitherElement = Either.right(true);
+ }
+ return eitherElement;
+ }
+}
</exclusion>
</exclusions>
</dependency>
- <dependency>
- <groupId>org.projectlombok</groupId>
- <artifactId>lombok</artifactId>
- <version>${lombok.version}</version>
- </dependency>
<dependency>
<groupId>org.apache.httpcomponents</groupId>
*/
package org.onap.config.api;
-import lombok.AccessLevel;
-import lombok.AllArgsConstructor;
-import lombok.NoArgsConstructor;
-import org.apache.http.conn.ssl.TrustSelfSignedStrategy;
-import org.apache.http.ssl.SSLContexts;
-import org.slf4j.Logger;
-import org.slf4j.LoggerFactory;
-
-import javax.net.ssl.SSLContext;
+import java.io.File;
import java.io.FileInputStream;
-import java.io.InputStream;
+import java.io.IOException;
+import java.security.GeneralSecurityException;
import java.security.KeyStore;
import java.util.Properties;
+import javax.net.ssl.SSLContext;
+import org.apache.http.conn.ssl.TrustSelfSignedStrategy;
+import org.apache.http.ssl.SSLContexts;
-@NoArgsConstructor(access = AccessLevel.PRIVATE)
public class JettySSLUtils {
- private static final Logger LOGGER = LoggerFactory.getLogger(JettySSLUtils.class);
- private static final String JETTY_BASE = System.getenv("JETTY_BASE");
- public static JettySslConfig getSSLConfig() {
- final Properties sslProperties = new Properties();
- final String sslPropsPath = JETTY_BASE + "/start.d/ssl.ini";
- try (final InputStream fis = new FileInputStream(sslPropsPath)) {
+ private JettySSLUtils() {
+ }
+
+ public static JettySslConfig getSSLConfig() throws IOException {
+ Properties sslProperties = new Properties();
+ String sslPropsPath = System.getenv("JETTY_BASE") + File.separator + "/start.d/ssl.ini";
+ File sslPropsFile = new File(sslPropsPath);
+ try (FileInputStream fis = new FileInputStream(sslPropsFile)) {
sslProperties.load(fis);
- } catch (Exception e) {
- LOGGER.error("Failed to read '{}'", sslPropsPath, e);
}
return new JettySslConfig(sslProperties);
}
- public static SSLContext getSslContext() throws Exception {
- final JettySslConfig sslProperties = getSSLConfig();
- final KeyStore trustStore = KeyStore.getInstance(sslProperties.getTruststoreType());
- try (final InputStream fis = new FileInputStream(sslProperties.getTruststorePath())) {
- trustStore.load(fis, (sslProperties.getTruststorePass()).toCharArray());
+ public static SSLContext getSslContext() throws GeneralSecurityException, IOException {
+ JettySslConfig sslProperties = JettySSLUtils.getSSLConfig();
+ KeyStore trustStore = KeyStore.getInstance(sslProperties.getTruststoreType());
+ try (FileInputStream instream = new FileInputStream(new File(sslProperties.getTruststorePath()));) {
+ trustStore.load(instream, (sslProperties.getTruststorePass()).toCharArray());
}
-
- final KeyStore keystore = KeyStore.getInstance(sslProperties.getKeystoreType());
- try (final InputStream fis = new FileInputStream(sslProperties.getKeystorePath())) {
- keystore.load(fis, sslProperties.getKeystorePass().toCharArray());
+ KeyStore keystore = KeyStore.getInstance(sslProperties.getKeystoreType());
+ try (FileInputStream instream = new FileInputStream(new File(sslProperties.getKeystorePath()));) {
+ keystore.load(instream, sslProperties.getKeystorePass().toCharArray());
}
// Trust own CA and all self-signed certs
- return SSLContexts.custom()
- .loadKeyMaterial(keystore, sslProperties.getKeystorePass().toCharArray())
- .loadTrustMaterial(trustStore, new TrustSelfSignedStrategy())
- .build();
+ return SSLContexts.custom().loadKeyMaterial(keystore, sslProperties.getKeystorePass().toCharArray())
+ .loadTrustMaterial(trustStore, new TrustSelfSignedStrategy()).build();
}
- @AllArgsConstructor
public static class JettySslConfig {
- private final Properties sslProperties;
+ static final String JETTY_BASE = System.getenv("JETTY_BASE");
+ static final String KEY_STORE_TYPE_PROPERTY_NAME = "jetty.sslContext.keyStoreType";
+ static final String TRUST_STORE_TYPE_PROPERTY_NAME = "jetty.sslContext.trustStoreType";
+ Properties sslProperties;
- public String getJettyBase(){
- return JETTY_BASE;
+ JettySslConfig(Properties sslProperties) {
+ this.sslProperties = sslProperties;
+ }
+
+ public String getJettyBase() {
+ return JettySslConfig.JETTY_BASE;
}
public String getKeystorePath() {
}
public String getKeystoreType() {
- return sslProperties.getProperty("jetty.sslContext.keyStoreType", KeyStore.getDefaultType());
+ return sslProperties.getProperty(KEY_STORE_TYPE_PROPERTY_NAME, KeyStore.getDefaultType());
}
public String getTruststorePath() {
}
public String getTruststoreType() {
- return sslProperties.getProperty("jetty.sslContext.trustStoreType", KeyStore.getDefaultType());
+ return sslProperties.getProperty(TRUST_STORE_TYPE_PROPERTY_NAME, KeyStore.getDefaultType());
}
- public String getKeyManagerPassword() {
+ public String getKeyStoreManager() {
return sslProperties.getProperty("jetty.sslContext.keyManagerPassword");
}
}
}
+ public String getProperty(String key) {
+ return sslProperties.getProperty(key);
+ }
}
}
</exclusion>
</exclusions>
</dependency>
- <dependency>
- <groupId>org.apache.httpcomponents</groupId>
- <artifactId>httpcore</artifactId>
- <version>${httpcore.version}</version>
- </dependency>
</dependencies>
</project>
*/
package org.openecomp.sdcrests.vsp.rest.services;
+import static javax.ws.rs.core.HttpHeaders.CONTENT_DISPOSITION;
+import static org.openecomp.core.utilities.file.FileUtils.getFileExtension;
+import static org.openecomp.core.utilities.file.FileUtils.getNetworkPackageName;
+
+import java.io.IOException;
+import java.nio.ByteBuffer;
+import java.nio.charset.StandardCharsets;
+import java.security.GeneralSecurityException;
+import java.security.KeyManagementException;
+import java.security.NoSuchAlgorithmException;
+import java.util.List;
+import java.util.Objects;
+import java.util.Optional;
+import javax.inject.Named;
+import javax.net.ssl.SSLContext;
+import javax.ws.rs.client.Client;
+import javax.ws.rs.client.ClientBuilder;
+import javax.ws.rs.core.Response;
import org.onap.config.api.ConfigurationManager;
import org.onap.config.api.JettySSLUtils;
import org.openecomp.core.utilities.orchestration.OnboardingTypesEnum;
import org.springframework.context.annotation.Scope;
import org.springframework.stereotype.Service;
-import javax.inject.Named;
-import javax.ws.rs.client.Client;
-import javax.ws.rs.client.ClientBuilder;
-import javax.ws.rs.core.Response;
-import java.nio.ByteBuffer;
-import java.nio.charset.StandardCharsets;
-import java.util.List;
-import java.util.Objects;
-import java.util.Optional;
-
-import static javax.ws.rs.core.HttpHeaders.CONTENT_DISPOSITION;
-import static org.openecomp.core.utilities.file.FileUtils.getFileExtension;
-import static org.openecomp.core.utilities.file.FileUtils.getNetworkPackageName;
-
/**
* Enables integration API interface with VNF Repository (VNFSDK).
* <ol>
private static Client trustSSLClient() {
try {
- return ClientBuilder.newBuilder()
- .sslContext(JettySSLUtils.getSslContext())
- .hostnameVerifier((requestedHost, remoteServerSession) -> requestedHost.equalsIgnoreCase(remoteServerSession.getPeerHost())).build();
- } catch (final Exception e) {
+ SSLContext sslcontext = JettySSLUtils.getSslContext();
+ return ClientBuilder.newBuilder().sslContext(sslcontext).hostnameVerifier((requestedHost, remoteServerSession)
+ -> requestedHost.equalsIgnoreCase(remoteServerSession.getPeerHost())).build();
+
+ } catch (IOException | GeneralSecurityException e) {
LOGGER.error("Failed to initialize SSL context", e);
}
return ClientBuilder.newClient();
}
+
private final Configuration config;
public VnfPackageRepositoryImpl(Configuration config) {
private Response uploadVnfPackage(final String vspId, final String versionId, final String csarId, final byte[] payload) {
try {
final OrchestrationTemplateCandidateManager candidateManager = OrchestrationTemplateCandidateManagerFactory.getInstance()
- .createInterface();
+ .createInterface();
final String filename = formatFilename(csarId);
final String fileExtension = getFileExtension(filename);
final OnboardPackageInfo onboardPackageInfo = new OnboardPackageInfo(getNetworkPackageName(filename), fileExtension,
- ByteBuffer.wrap(payload), OnboardingTypesEnum.getOnboardingTypesEnum(fileExtension));
+ ByteBuffer.wrap(payload), OnboardingTypesEnum.getOnboardingTypesEnum(fileExtension));
final VspDetails vspDetails = new VspDetails(vspId, getVersion(vspId, versionId));
final UploadFileResponse response = candidateManager.upload(vspDetails, onboardPackageInfo);
final UploadFileResponseDto uploadFileResponse = new MapUploadFileResponseToUploadFileResponseDto()
- .applyMapping(response, UploadFileResponseDto.class);
+ .applyMapping(response, UploadFileResponseDto.class);
return Response.ok(uploadFileResponse).build();
} catch (final Exception e) {
ErrorCode error = new GeneralErrorBuilder().build();
if (LOGGER.isErrorEnabled()) {
String body = response.hasEntity() ? response.readEntity(String.class) : "";
LOGGER.error("Unexpected response status while {}: URI={}, status={}, body={}", action, uri, response.getStatus(), body,
- new CoreException(error));
+ new CoreException(error));
}
return generateInternalServerError(error);
}
<dependencies>
+ <dependency>
+ <groupId>org.slf4j</groupId>
+ <artifactId>slf4j-api</artifactId>
+ <version>1.7.25</version>
+ </dependency>
+
<dependency>
<groupId>org.apache.commons</groupId>
<artifactId>commons-crypto</artifactId>
-FROM onap/integration-java11:10.0.0
+FROM onap/integration-java11:9.0.0
USER root
ARG JETTY_FOLDER=/app/jetty
default['FE'][:https_port] = 9443
default['disableHttp'] = true
default['cassandra'][:truststore_password] = "Aa123456"
-
-default['jetty']['keystore_path'] = "etc/org.onap.sdc.p12"
default['jetty'][:keystore_pwd] = "?(kP!Yur![*!Y5!E^f(ZKc31"
default['jetty'][:keymanager_pwd] = "?(kP!Yur![*!Y5!E^f(ZKc31"
-default['jetty']['truststore_path'] = "etc/org.onap.sdc.trust.jks"
-# TO CHANGE THE TRUSTSTORE CERT THE JVM CONFIGURATION
-# MUST BE ALSO CHANGE IN THE startup.sh FILE
default['jetty'][:truststore_pwd] = "z+KEj;t+,KN^iimSiS89e#p0"
+default['jetty']['truststore_path'] = "#{ENV['JETTY_BASE']}/etc/truststore"
default['VnfRepo']['vnfRepoPort'] = 8702
default['VnfRepo']['vnfRepoHost'] = "refrepo"
-# Cassandra
+#Cassandra
default['cassandra']['cassandra_port'] = 9042
default['cassandra']['datacenter_name'] = "DC-"
default['cassandra']['cluster_name'] = "SDC-CS-"
default['cassandra']['socket_connect_timeout'] = 20000
default['cassandra']['janusgraph_connection_timeout'] = 10000
-# Basicauth
+#Basicauth
default['basic_auth']['enabled'] = true
default['basic_auth'][:user_name] = "testName"
default['basic_auth'][:user_pass] = "testPass"
default['basic_auth']['excludedUrls'] = "/v1.0/healthcheck"
-# ExternalTesting
+#ExternalTesting
default['EXTTEST']['ep1_config'] = "vtp,VTP,true,http://refrepo:8702/onapapi/vnfsdk-marketplace,onap.*"
default['EXTTEST']['ep2_config'] = "repository,Repository,false,,.*"
-# Set the http module option
+#Set the http module option
if node['disableHttp']
http_option = "#--module=http"
else
group "#{ENV['JETTY_GROUP']}"
mode "0755"
variables ({
- :http_option => http_option,
+ :http_option => http_option ,
:http_port => "#{node['ONBOARDING_BE'][:http_port]}"
})
-
+
end
+
template "https-ini" do
path "#{ENV['JETTY_BASE']}/start.d/https.ini"
source "https-ini.erb"
variables :https_port => "#{node['ONBOARDING_BE'][:https_port]}"
end
+
template "ssl-ini" do
path "#{ENV['JETTY_BASE']}/start.d/ssl.ini"
source "ssl-ini.erb"
group "#{ENV['JETTY_GROUP']}"
mode "0755"
variables ({
- :https_port => "#{node['ONBOARDING_BE'][:https_port]}",
- :jetty_keystore_path => "#{node['jetty'][:keystore_path]}",
- :jetty_keystore_pwd => "#{node['jetty'][:keystore_pwd]}",
- :jetty_keymanager_pwd => "#{node['jetty'][:keymanager_pwd]}",
- :jetty_truststore_path => "#{node['jetty'][:truststore_path]}",
+ :https_port => "#{node['ONBOARDING_BE'][:https_port]}" ,
+ :jetty_keystore_pwd => "#{node['jetty'][:keystore_pwd]}" ,
+ :jetty_keymanager_pwd => "#{node['jetty'][:keymanager_pwd]}" ,
:jetty_truststore_pwd => "#{node['jetty'][:truststore_pwd]}"
})
end
## See http://www.eclipse.org/jetty/documentation/current/configuring-security-secure-passwords.html
## Keystore file path (relative to $jetty.base)
-jetty.sslContext.keyStorePath=<%= @jetty_keystore_path %>
+jetty.sslContext.keyStorePath=etc/org.onap.sdc.p12
## Truststore file path (relative to $jetty.base)
-jetty.sslContext.trustStorePath=<%= @jetty_truststore_path %>
+jetty.sslContext.trustStorePath=etc/org.onap.sdc.trust.jks
## Keystore password
# jetty.sslContext.keyStorePassword=OBF:1vny1zlo1x8e1vnw1vn61x8g1zlu1vn4
jetty.sslContext.keyStorePassword=<%= @jetty_keystore_pwd %>
## Keystore type and provider
-jetty.sslContext.keyStoreType=JKS
+# jetty.sslContext.keyStoreType=JKS
# jetty.sslContext.keyStoreProvider=
## KeyManager password
jetty.sslContext.trustStorePassword=<%= @jetty_truststore_pwd %>
## Truststore type and provider
-jetty.sslContext.trustStoreType=JKS
+# jetty.sslContext.trustStoreType=JKS
# jetty.sslContext.trustStoreProvider=
## whether client certificate authentication is required
-Dconfiguration.yaml=$JETTY_BASE/config/onboarding-be/onboarding_configuration.yaml \
-Dfeatures.properties=$JETTY_BASE/config/onboarding-be/features.properties \
-XX:+HeapDumpOnOutOfMemoryError \
- -Djavax.net.ssl.trustStore=$JETTY_BASE/etc/org.onap.sdc.trust.jks \
- -Djavax.net.ssl.trustStorePassword=z+KEj;t+,KN^iimSiS89e#p0 \
-Dconfig.location=$JETTY_BASE/config/onboarding-be/."
cd $JETTY_BASE
chef-solo -c solo.rb -E ${ENVNAME}
cd $JETTY_HOME
-echo "jetty.httpConfig.sendServerVersion=false" >>$JETTY_HOME/start.d/start.ini
+echo "jetty.httpConfig.sendServerVersion=false" >> $JETTY_HOME/start.d/start.ini
java $JAVA_OPTIONS -jar "${JETTY_HOME}/start.jar"
<artifactId>openecomp-sdc-logging-api</artifactId>
<version>${project.version}</version>
</dependency>
+ <dependency>
+ <groupId>org.slf4j</groupId>
+ <artifactId>slf4j-api</artifactId>
+ <version>${slf4j-api.version}</version>
+ </dependency>
<dependency>
<groupId>ch.qos.logback</groupId>
<artifactId>logback-classic</artifactId>
-->
<project xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
- xmlns="http://maven.apache.org/POM/4.0.0"
- xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
- <modelVersion>4.0.0</modelVersion>
+ xmlns="http://maven.apache.org/POM/4.0.0"
+ xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
+ <modelVersion>4.0.0</modelVersion>
- <name>openecomp-sdc-validation-impl</name>
-
<artifactId>openecomp-sdc-validation-impl</artifactId>
+ <name>openecomp-sdc-validation-impl</name>
+ <artifactId>openecomp-sdc-validation-impl</artifactId>
- <groupId>org.openecomp.sdc</groupId>
-
<artifactId>openecomp-sdc-validation-lib</artifactId>
+ <parent>
+ <groupId>org.openecomp.sdc</groupId>
+ <artifactId>openecomp-sdc-validation-lib</artifactId>
<version>1.13.0-SNAPSHOT</version>
- </parent>
+ </parent>
- <dependencies>
- <dependency>
- <groupId>ch.qos.logback</groupId>
- <artifactId>logback-classic</artifactId>
- <version>${logback.version}</version>
- </dependency>
- <dependency>
- <groupId>org.openecomp.sdc</groupId>
- <artifactId>openecomp-sdc-logging-core</artifactId>
- <version>${project.version}</version>
- <scope>runtime</scope>
- </dependency>
- <dependency>
- <groupId>org.openecomp.sdc</groupId>
- <artifactId>openecomp-sdc-logging-api</artifactId>
- <version>${project.version}</version>
- </dependency>
- <dependency>
- <groupId>org.openecomp.sdc.core</groupId>
- <artifactId>openecomp-utilities-lib</artifactId>
- <version>${project.version}</version>
- <exclusions>
- <exclusion>
- <groupId>org.eclipse.jetty</groupId>
- <artifactId>jetty-server</artifactId>
- </exclusion>
- <exclusion>
- <groupId>org.eclipse.jetty</groupId>
- <artifactId>jetty-servlet</artifactId>
- </exclusion>
- </exclusions>
- </dependency>
- <dependency>
- <groupId>org.openecomp.sdc</groupId>
- <artifactId>openecomp-sdc-validation-api</artifactId>
- <version>${project.version}</version>
- </dependency>
- <dependency>
- <groupId>org.openecomp.sdc.core</groupId>
- <artifactId>openecomp-common-lib</artifactId>
- <version>${project.version}</version>
- </dependency>
- <dependency>
- <groupId>org.openecomp.sdc.core</groupId>
- <artifactId>openecomp-heat-lib</artifactId>
- <version>${project.version}</version>
- </dependency>
- <dependency>
- <groupId>commons-io</groupId>
- <artifactId>commons-io</artifactId>
- <version>${commons.io.version}</version>
- <scope>test</scope>
- </dependency>
- <dependency>
- <groupId>org.openecomp.sdc</groupId>
- <artifactId>openecomp-sdc-validation-core</artifactId>
- <version>${project.version}</version>
- </dependency>
- <dependency>
- <groupId>org.onap.vnfsdk.validation</groupId>
- <artifactId>validation-pmdictionary</artifactId>
- <version>${onap.vnfsdk.validation.pmdictionary.version}</version>
- <exclusions>
- <exclusion>
- <groupId>org.apache.logging.log4j</groupId>
- <artifactId>log4j-slf4j-impl</artifactId>
- </exclusion>
- </exclusions>
- </dependency>
- <dependency>
- <groupId>io.vavr</groupId>
- <artifactId>vavr</artifactId>
- <version>${io.vavr.version}</version>
- </dependency>
- <dependency>
- <groupId>org.apache.httpcomponents</groupId>
- <artifactId>httpmime</artifactId>
- <version>${httpclient.version}</version>
- <exclusions>
- <exclusion>
- <groupId>org.apache.httpcomponents</groupId>
- <artifactId>httpcore</artifactId>
- </exclusion>
- </exclusions>
- </dependency>
- <dependency>
- <groupId>org.apache.httpcomponents</groupId>
- <artifactId>httpcore</artifactId>
- <version>${httpcore.version}</version>
- </dependency>
- </dependencies>
+ <dependencies>
+ <dependency>
+ <groupId>ch.qos.logback</groupId>
+ <artifactId>logback-classic</artifactId>
+ <version>${logback.version}</version>
+ </dependency>
+ <dependency>
+ <groupId>org.openecomp.sdc</groupId>
+ <artifactId>openecomp-sdc-logging-core</artifactId>
+ <version>${project.version}</version>
+ <scope>runtime</scope>
+ </dependency>
+ <dependency>
+ <groupId>org.openecomp.sdc</groupId>
+ <artifactId>openecomp-sdc-logging-api</artifactId>
+ <version>${project.version}</version>
+ </dependency>
+ <dependency>
+ <groupId>org.openecomp.sdc.core</groupId>
+ <artifactId>openecomp-utilities-lib</artifactId>
+ <version>${project.version}</version>
+ <exclusions>
+ <exclusion>
+ <groupId>org.eclipse.jetty</groupId>
+ <artifactId>jetty-server</artifactId>
+ </exclusion>
+ <exclusion>
+ <groupId>org.eclipse.jetty</groupId>
+ <artifactId>jetty-servlet</artifactId>
+ </exclusion>
+ </exclusions>
+ </dependency>
+ <dependency>
+ <groupId>org.openecomp.sdc</groupId>
+ <artifactId>openecomp-sdc-validation-api</artifactId>
+ <version>${project.version}</version>
+ </dependency>
+ <dependency>
+ <groupId>org.openecomp.sdc.core</groupId>
+ <artifactId>openecomp-common-lib</artifactId>
+ <version>${project.version}</version>
+ </dependency>
+ <dependency>
+ <groupId>org.openecomp.sdc.core</groupId>
+ <artifactId>openecomp-heat-lib</artifactId>
+ <version>${project.version}</version>
+ </dependency>
+ <dependency>
+ <groupId>commons-io</groupId>
+ <artifactId>commons-io</artifactId>
+ <version>${commons.io.version}</version>
+ <scope>test</scope>
+ </dependency>
+ <dependency>
+ <groupId>org.openecomp.sdc</groupId>
+ <artifactId>openecomp-sdc-validation-core</artifactId>
+ <version>${project.version}</version>
+ </dependency>
+ <dependency>
+ <groupId>org.onap.vnfsdk.validation</groupId>
+ <artifactId>validation-pmdictionary</artifactId>
+ <version>${onap.vnfsdk.validation.pmdictionary.version}</version>
+ <exclusions>
+ <exclusion>
+ <groupId>org.apache.logging.log4j</groupId>
+ <artifactId>log4j-slf4j-impl</artifactId>
+ </exclusion>
+ </exclusions>
+ </dependency>
+ <dependency>
+ <groupId>io.vavr</groupId>
+ <artifactId>vavr</artifactId>
+ <version>${io.vavr.version}</version>
+ </dependency>
+ <dependency>
+ <groupId>org.apache.httpcomponents</groupId>
+ <artifactId>httpmime</artifactId>
+ <version>${httpclient.version}</version>
+ <scope>compile</scope>
+ <exclusions>
+ <exclusion>
+ <groupId>org.apache.httpcomponents</groupId>
+ <artifactId>httpcore</artifactId>
+ </exclusion>
+ </exclusions>
+ </dependency>
+ </dependencies>
</project>
<wire-mock.version>2.26.3</wire-mock.version>
<ecomp.version>3.4.0</ecomp.version>
<cassandra.unit.version>4.3.1.0</cassandra.unit.version>
+ <cadi.version>2.1.8</cadi.version>
<lombok.version>1.18.24</lombok.version>
<commons-beanutils>1.9.4</commons-beanutils>
<commons.io.version>2.8.0</commons.io.version>
<ws.rs.version>2.1.1</ws.rs.version>
<javax.validation.version>2.0.1.Final</javax.validation.version>
- <jetty.version>10.0.14</jetty.version>
- <jetty-distribution.version>9.4.51.v20230217</jetty-distribution.version>
+ <jetty.version>9.4.49.v20220914</jetty.version>
+ <jetty-distribution.version>${jetty.version}</jetty-distribution.version>
<cxf.version>3.4.4</cxf.version>
<org.owasp.esapi.version>2.4.0.0</org.owasp.esapi.version>
<!-- Logging start -->
<!-- logback -->
- <logback.version>1.2.12</logback.version>
- <slf4j-api.version>1.7.36</slf4j-api.version>
+ <logback.version>1.2.10</logback.version>
+ <slf4j-api.version>1.7.25</slf4j-api.version>
<commons-codec>1.15</commons-codec>
<commons-logging>1.2</commons-logging>
<janino.version>3.0.6</janino.version>
<artifactId>keycloak-authz-client</artifactId>
<version>${keycloak.version}</version>
</dependency>
- <dependency>
- <groupId>org.slf4j</groupId>
- <artifactId>slf4j-api</artifactId>
- <version>${slf4j-api.version}</version>
- </dependency>
<dependency>
<groupId>org.keycloak</groupId>
<artifactId>keycloak-spring-security-adapter</artifactId>
<skipYamlJsonValidator>true</skipYamlJsonValidator>
<checkstyle.skip>true</checkstyle.skip>
<jacoco.skip>true</jacoco.skip>
-
<docker.skip.run>true</docker.skip.run>
<maven.antrun.skip>true</maven.antrun.skip>
<swagger.skip>true</swagger.skip>
-FROM onap/integration-java11:10.0.0
+FROM onap/integration-java11:9.0.0
USER root
ARG JETTY_FOLDER=/app/jetty
mode "0755"
variables({
:https_port => "8443",
- :jetty_keystore_path => "etc/org.onap.sdc.p12" ,
- :jetty_keystore_pwd => "?(kP!Yur
Code Review / sdc.git / commitdiff