gerrit.onap Code Review - policy/common.git/blob

   1 /*
   2  * ============LICENSE_START=======================================================
   3  * policy-endpoints
   4  * ================================================================================
   5  * Copyright (C) 2017-2018 AT&T Intellectual Property. All rights reserved.
   6  * ================================================================================
   7  * Licensed under the Apache License, Version 2.0 (the "License");
   8  * you may not use this file except in compliance with the License.
   9  * You may obtain a copy of the License at
  10  *
  11  *      http://www.apache.org/licenses/LICENSE-2.0
  12  *
  13  * Unless required by applicable law or agreed to in writing, software
  14  * distributed under the License is distributed on an "AS IS" BASIS,
  15  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  16  * See the License for the specific language governing permissions and
  17  * limitations under the License.
  18  * ============LICENSE_END=========================================================
  19  */
  20
  21 package org.onap.policy.common.endpoints.http.server;
  22
  23 import java.util.ArrayList;
  24 import java.util.Arrays;
  25 import java.util.HashMap;
  26 import java.util.List;
  27 import java.util.Properties;
  28 import org.onap.aaf.cadi.filter.CadiFilter;
  29 import org.onap.policy.common.endpoints.http.server.internal.JettyJerseyServer;
  30 import org.onap.policy.common.endpoints.properties.PolicyEndPointProperties;
  31 import org.slf4j.Logger;
  32 import org.slf4j.LoggerFactory;
  33
  34 /**
  35  * Factory of HTTP Servlet-Enabled Servlets.
  36  */
  37 public interface HttpServletServerFactory {
  38
  39     /**
  40      * Builds an http or https server with support for servlets.
  41      *
  42      * @param name name
  43      * @param https use secured http over tls connection
  44      * @param host binding host
  45      * @param port port
  46      * @param contextPath server base path
  47      * @param swagger enable swagger documentation
  48      * @param managed is it managed by infrastructure
  49      * @return http server
  50      * @throws IllegalArgumentException when invalid parameters are provided
  51      */
  52     HttpServletServer build(String name, boolean https, String host, int port, String contextPath, boolean swagger,
  53             boolean managed);
  54
  55     /**
  56      * Builds an http server with support for servlets.
  57      *
  58      * @param name name
  59      * @param host binding host
  60      * @param port port
  61      * @param contextPath server base path
  62      * @param swagger enable swagger documentation
  63      * @param managed is it managed by infrastructure
  64      * @return http server
  65      * @throws IllegalArgumentException when invalid parameters are provided
  66      */
  67     HttpServletServer build(String name, String host, int port, String contextPath, boolean swagger,
  68         boolean managed);
  69
  70     /**
  71      * Build a list of http servers per properties.
  72      *
  73      * @param properties properties based configuration
  74      * @return list of http servers
  75      * @throws IllegalArgumentException when invalid parameters are provided
  76      */
  77     List<HttpServletServer> build(Properties properties);
  78
  79     /**
  80      * Gets a server based on the port.
  81      *
  82      * @param port port
  83      * @return http server
  84      */
  85     HttpServletServer get(int port);
  86
  87     /**
  88      * Provides an inventory of servers.
  89      *
  90      * @return inventory of servers
  91      */
  92     List<HttpServletServer> inventory();
  93
  94     /**
  95      * Destroys server bound to a port.
  96      *
  97      * @param port the port the server is bound to
  98      */
  99     void destroy(int port);
 100
 101     /**
 102      * Destroys the factory and therefore all servers.
 103      */
 104     void destroy();
 105 }
 106
 107
 108 /**
 109  * Indexed factory implementation.
 110  */
 111 class IndexedHttpServletServerFactory implements HttpServletServerFactory {
 112
 113     private static final String SPACES_COMMA_SPACES = "\\s*,\\s*";
 114
 115     /**
 116      * logger.
 117      */
 118     protected static Logger logger = LoggerFactory.getLogger(IndexedHttpServletServerFactory.class);
 119
 120     /**
 121      * servers index.
 122      */
 123     protected HashMap<Integer, HttpServletServer> servers = new HashMap<>();
 124
 125     @Override
 126     public synchronized HttpServletServer build(String name, boolean https,
 127                     String host, int port, String contextPath, boolean swagger,
 128             boolean managed) {
 129
 130         if (servers.containsKey(port)) {
 131             return servers.get(port);
 132         }
 133
 134         JettyJerseyServer server = new JettyJerseyServer(name, https, host, port, contextPath, swagger);
 135         if (managed) {
 136             servers.put(port, server);
 137         }
 138
 139         return server;
 140     }
 141
 142     @Override
 143     public synchronized HttpServletServer build(String name, String host, int port, String contextPath,
 144                                                 boolean swagger, boolean managed) {
 145         return build(name, false, host, port, contextPath, swagger, managed);
 146     }
 147
 148
 149     @Override
 150     public synchronized List<HttpServletServer> build(Properties properties) {
 151
 152         ArrayList<HttpServletServer> serviceList = new ArrayList<>();
 153
 154         String serviceNames = properties.getProperty(PolicyEndPointProperties.PROPERTY_HTTP_SERVER_SERVICES);
 155         if (serviceNames == null || serviceNames.isEmpty()) {
 156             logger.warn("No topic for HTTP Service: {}", properties);
 157             return serviceList;
 158         }
 159
 160         List<String> serviceNameList = Arrays.asList(serviceNames.split(SPACES_COMMA_SPACES));
 161
 162         for (String serviceName : serviceNameList) {
 163             String servicePortString = properties.getProperty(PolicyEndPointProperties.PROPERTY_HTTP_SERVER_SERVICES
 164                     + "." + serviceName + PolicyEndPointProperties.PROPERTY_HTTP_PORT_SUFFIX);
 165
 166             int servicePort;
 167             try {
 168                 if (servicePortString == null || servicePortString.isEmpty()) {
 169                     if (logger.isWarnEnabled()) {
 170                         logger.warn("No HTTP port for service in {}", serviceName);
 171                     }
 172                     continue;
 173                 }
 174                 servicePort = Integer.parseInt(servicePortString);
 175             } catch (NumberFormatException nfe) {
 176                 if (logger.isWarnEnabled()) {
 177                     logger.warn("No HTTP port for service in {}", serviceName);
 178                 }
 179                 continue;
 180             }
 181
 182             final String hostName = properties.getProperty(PolicyEndPointProperties.PROPERTY_HTTP_SERVER_SERVICES + "."
 183                     + serviceName + PolicyEndPointProperties.PROPERTY_HTTP_HOST_SUFFIX);
 184
 185             final String contextUriPath = properties.getProperty(
 186                     PolicyEndPointProperties.PROPERTY_HTTP_SERVER_SERVICES + "."
 187                     + serviceName + PolicyEndPointProperties.PROPERTY_HTTP_CONTEXT_URIPATH_SUFFIX);
 188
 189             final String userName = properties.getProperty(PolicyEndPointProperties.PROPERTY_HTTP_SERVER_SERVICES + "."
 190                     + serviceName + PolicyEndPointProperties.PROPERTY_HTTP_AUTH_USERNAME_SUFFIX);
 191
 192             final String password = properties.getProperty(PolicyEndPointProperties.PROPERTY_HTTP_SERVER_SERVICES + "."
 193                     + serviceName + PolicyEndPointProperties.PROPERTY_HTTP_AUTH_PASSWORD_SUFFIX);
 194
 195             final String authUriPath = properties.getProperty(
 196                     PolicyEndPointProperties.PROPERTY_HTTP_SERVER_SERVICES + "."
 197                     + serviceName + PolicyEndPointProperties.PROPERTY_HTTP_AUTH_URIPATH_SUFFIX);
 198
 199             final String restClasses = properties.getProperty(
 200                     PolicyEndPointProperties.PROPERTY_HTTP_SERVER_SERVICES + "."
 201                     + serviceName + PolicyEndPointProperties.PROPERTY_HTTP_REST_CLASSES_SUFFIX);
 202
 203             final String filterClasses = properties.getProperty(
 204                     PolicyEndPointProperties.PROPERTY_HTTP_SERVER_SERVICES + "."
 205                     + serviceName + PolicyEndPointProperties.PROPERTY_HTTP_FILTER_CLASSES_SUFFIX);
 206
 207             final String restPackages = properties.getProperty(
 208                     PolicyEndPointProperties.PROPERTY_HTTP_SERVER_SERVICES + "."
 209                     + serviceName + PolicyEndPointProperties.PROPERTY_HTTP_REST_PACKAGES_SUFFIX);
 210
 211             final String restUriPath = properties.getProperty(
 212                     PolicyEndPointProperties.PROPERTY_HTTP_SERVER_SERVICES + "."
 213                     + serviceName + PolicyEndPointProperties.PROPERTY_HTTP_REST_URIPATH_SUFFIX);
 214
 215             final String managedString = properties.getProperty(
 216                     PolicyEndPointProperties.PROPERTY_HTTP_SERVER_SERVICES + "."
 217                     + serviceName + PolicyEndPointProperties.PROPERTY_MANAGED_SUFFIX);
 218             boolean managed = true;
 219             if (managedString != null && !managedString.isEmpty()) {
 220                 managed = Boolean.parseBoolean(managedString);
 221             }
 222
 223             String swaggerString = properties.getProperty(PolicyEndPointProperties.PROPERTY_HTTP_SERVER_SERVICES + "."
 224                     + serviceName + PolicyEndPointProperties.PROPERTY_HTTP_SWAGGER_SUFFIX);
 225             boolean swagger = false;
 226             if (swaggerString != null && !swaggerString.isEmpty()) {
 227                 swagger = Boolean.parseBoolean(swaggerString);
 228             }
 229
 230             String httpsString = properties.getProperty(PolicyEndPointProperties.PROPERTY_HTTP_SERVER_SERVICES + "."
 231                 + serviceName + PolicyEndPointProperties.PROPERTY_HTTP_HTTPS_SUFFIX);
 232             boolean https = false;
 233             if (httpsString != null && !httpsString.isEmpty()) {
 234                 https = Boolean.parseBoolean(httpsString);
 235             }
 236
 237             String aafString = properties.getProperty(PolicyEndPointProperties.PROPERTY_HTTP_SERVER_SERVICES + "."
 238                 + serviceName + PolicyEndPointProperties.PROPERTY_AAF_SUFFIX);
 239             boolean aaf = false;
 240             if (aafString != null && !aafString.isEmpty()) {
 241                 aaf = Boolean.parseBoolean(aafString);
 242             }
 243
 244             HttpServletServer service = build(serviceName, https, hostName, servicePort,
 245                     contextUriPath, swagger, managed);
 246
 247             /* authentication method either AAF or HTTP Basic Auth */
 248
 249             if (aaf) {
 250                 service.setAafAuthentication(contextUriPath);
 251             } else if (userName != null && !userName.isEmpty() && password != null && !password.isEmpty()) {
 252                 service.setBasicAuthentication(userName, password, authUriPath);
 253             }
 254
 255             if (filterClasses != null && !filterClasses.isEmpty()) {
 256                 List<String> filterClassesList = Arrays.asList(filterClasses.split(SPACES_COMMA_SPACES));
 257                 for (String filterClass : filterClassesList) {
 258                     service.addFilterClass(restUriPath, filterClass);
 259                 }
 260             }
 261
 262             if (restClasses != null && !restClasses.isEmpty()) {
 263                 List<String> restClassesList = Arrays.asList(restClasses.split(SPACES_COMMA_SPACES));
 264                 for (String restClass : restClassesList) {
 265                     service.addServletClass(restUriPath, restClass);
 266                 }
 267             }
 268
 269             if (restPackages != null && !restPackages.isEmpty()) {
 270                 List<String> restPackageList = Arrays.asList(restPackages.split(SPACES_COMMA_SPACES));
 271                 for (String restPackage : restPackageList) {
 272                     service.addServletPackage(restUriPath, restPackage);
 273                 }
 274             }
 275
 276             serviceList.add(service);
 277         }
 278
 279         return serviceList;
 280     }
 281
 282     @Override
 283     public synchronized HttpServletServer get(int port) {
 284
 285         if (servers.containsKey(port)) {
 286             return servers.get(port);
 287         }
 288
 289         throw new IllegalArgumentException("Http Server for " + port + " not found");
 290     }
 291
 292     @Override
 293     public synchronized List<HttpServletServer> inventory() {
 294         return new ArrayList<>(this.servers.values());
 295     }
 296
 297     @Override
 298     public synchronized void destroy(int port) {
 299
 300         if (!servers.containsKey(port)) {
 301             return;
 302         }
 303
 304         HttpServletServer server = servers.remove(port);
 305         server.shutdown();
 306     }
 307
 308     @Override
 309     public synchronized void destroy() {
 310         List<HttpServletServer> httpServletServers = this.inventory();
 311         for (HttpServletServer server : httpServletServers) {
 312             server.shutdown();
 313         }
 314
 315         synchronized (this) {
 316             this.servers.clear();
 317         }
 318     }
 319
 320 }