datarouter-prov/src/main/java/org/onap/dmaap/datarouter/provisioning/utils/DRProvCadiFilter.java

   1 /**
   2  * -
   3  * ============LICENSE_START=======================================================
   4  * Copyright (C) 2019 Nordix Foundation.
   5  * ================================================================================
   6  * Licensed under the Apache License, Version 2.0 (the "License");
   7  * you may not use this file except in compliance with the License.
   8  * You may obtain a copy of the License at
   9  *
  10  * <p>* http://www.apache.org/licenses/LICENSE-2.0
  11  *
  12  * <p>Unless required by applicable law or agreed to in writing, software
  13  * distributed under the License is distributed on an "AS IS" BASIS,
  14  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  15  * See the License for the specific language governing permissions and
  16  * limitations under the License.
  17  *
  18  * <p>* SPDX-License-Identifier: Apache-2.0
  19  * ============LICENSE_END=========================================================
  20  */
  21
  22 package org.onap.dmaap.datarouter.provisioning.utils;
  23
  24 import com.att.eelf.configuration.EELFLogger;
  25 import com.att.eelf.configuration.EELFManager;
  26 import java.io.IOException;
  27 import javax.servlet.FilterChain;
  28 import javax.servlet.ServletException;
  29 import javax.servlet.ServletRequest;
  30 import javax.servlet.ServletResponse;
  31 import javax.servlet.http.HttpServletRequest;
  32 import javax.servlet.http.HttpServletResponse;
  33
  34 import org.onap.aaf.cadi.PropAccess;
  35 import org.onap.aaf.cadi.filter.CadiFilter;
  36 import org.onap.dmaap.datarouter.provisioning.BaseServlet;
  37 import org.onap.dmaap.datarouter.provisioning.beans.EventLogRecord;
  38 import org.onap.dmaap.datarouter.provisioning.beans.Feed;
  39 import org.onap.dmaap.datarouter.provisioning.beans.Subscription;
  40
  41 public class DRProvCadiFilter extends CadiFilter {
  42     protected static EELFLogger eventlogger = EELFManager.getInstance().getLogger("EventLog");
  43     protected static EELFLogger intlogger = EELFManager.getInstance().getLogger("InternalLog");
  44     private String aafInstance = "";
  45
  46     public DRProvCadiFilter(boolean init, PropAccess access) throws ServletException {
  47         super(init, access);
  48     }
  49
  50     @Override
  51     public void doFilter(ServletRequest request, ServletResponse response, FilterChain chain)
  52             throws IOException, ServletException {
  53         HttpServletRequest httpRequest = (HttpServletRequest) request;
  54         HttpServletResponse httpResponse = (HttpServletResponse) response;
  55
  56         EventLogRecord elr = new EventLogRecord(httpRequest);
  57         String excludeAAF = httpRequest.getHeader(BaseServlet.EXCLUDE_AAF_HEADER);
  58         //send this param value as true, if want to add legacy feed/subscriber in AAF env
  59
  60         String pathUrl = httpRequest.getServletPath();
  61         if (!(pathUrl.contains("internal")
  62                 || pathUrl.contains("sublog")
  63                 || pathUrl.contains("feedlog")
  64                 || pathUrl.contains("statistics")
  65                 || pathUrl.contains("publish")
  66                 || pathUrl.contains("group"))) {
  67
  68             String method = httpRequest.getMethod().toUpperCase();
  69             if (!("POST".equals(method))) {
  70                 // if request method is PUT method (publish or Feed update) Needs to check for DELETE
  71                 if ("PUT".equals(method) || "DELETE".equals(method)) {
  72                     if ((pathUrl.contains("subs"))) { //edit subscriber
  73                         int subId = BaseServlet.getIdFromPath(httpRequest);
  74                         if (subId <= 0) {
  75                             String message = String.format("Invalid request URI - %s", httpRequest.getPathInfo());
  76                             elr.setMessage(message);
  77                             elr.setResult(HttpServletResponse.SC_NOT_FOUND);
  78                             eventlogger.error(elr.toString());
  79                             httpResponse.sendError(HttpServletResponse.SC_NOT_FOUND, message);
  80                             return;
  81                         }
  82                         if (isAAFSubscriber(subId)) { //edit AAF Subscriber
  83                             String message = String.format("DRProvCadiFilter - "
  84                                             + "Edit AAF Subscriber : %d : AAF Instance - %s", subId, aafInstance);
  85                             elr.setMessage(message);
  86                             eventlogger.info(elr.toString());
  87                             //request.setAttribute("aafInstance", aafInstance);//
  88                             // no need to set it in request since it is taken care in respective servlets
  89                             super.doFilter(request, response, chain);
  90
  91                         } else { //Edit or publish legacy Subscriber
  92                             String message = "DRProvCadiFilter - Edit/Publish Legacy Subscriber :" + subId;
  93                             elr.setMessage(message);
  94                             eventlogger.info(elr.toString());
  95                             chain.doFilter(request, response);
  96                         }
  97
  98                     } else { //edit or publish Feed
  99                         int feedId = BaseServlet.getIdFromPath(httpRequest);
 100                         if (feedId <= 0) {
 101                             String message = "Invalid request URI - " + httpRequest.getPathInfo();
 102                             elr.setMessage(message);
 103                             elr.setResult(HttpServletResponse.SC_NOT_FOUND);
 104                             eventlogger.error(elr.toString());
 105                             httpResponse.sendError(HttpServletResponse.SC_NOT_FOUND, message);
 106                             return;
 107                         }
 108
 109                         if (isAAFFeed(feedId)) { //edit AAF Feed
 110                             String message = "DRProvCadiFilter - Edit AAF Feed:"
 111                                                      + feedId + ":" + "AAF Instance -" + aafInstance;
 112                             elr.setMessage(message);
 113                             eventlogger.info(elr.toString());
 114                             super.doFilter(request, response, chain);
 115
 116                         } else { //Edit or publish legacy Feed
 117                             String message = "DRProvCadiFilter - Edit/Publish Legacy Feed:" + feedId;
 118                             elr.setMessage(message);
 119                             eventlogger.info(elr.toString());
 120                             chain.doFilter(request, response);
 121                         }
 122                     }
 123                 } else { // in all other cases defaults to legacy behavior
 124                     String message = "DRProvCadiFilter - Default Legacy Feed/Subscriber URI -:"
 125                                              + httpRequest.getPathInfo();
 126                     elr.setMessage(message);
 127                     eventlogger.info(elr.toString());
 128                     chain.doFilter(request, response);
 129                 }
 130             } else {
 131                 //check to add legacy/AAF subscriber
 132                 if ((pathUrl.contains("subscribe"))) { //add subscriber
 133                     int feedId = BaseServlet.getIdFromPath(httpRequest);
 134                     if (feedId <= 0) {
 135                         String message = "Invalid request URI - " + httpRequest.getPathInfo();
 136                         elr.setMessage(message);
 137                         elr.setResult(HttpServletResponse.SC_NOT_FOUND);
 138                         eventlogger.error(elr.toString());
 139                         httpResponse.sendError(HttpServletResponse.SC_NOT_FOUND, message);
 140                         return;
 141                     }
 142                     if (isAAFFeed(feedId)) { //check if AAF Feed or legacy to add new subscriber
 143                         if (excludeAAF == null) {
 144                             String message = "DRProvCadiFilter -Invalid request Header Parmeter "
 145                                        + BaseServlet.EXCLUDE_AAF_HEADER
 146                                        + " = " + httpRequest.getHeader(BaseServlet.EXCLUDE_AAF_HEADER);
 147                             elr.setMessage(message);
 148                             elr.setResult(HttpServletResponse.SC_BAD_REQUEST);
 149                             eventlogger.error(elr.toString());
 150                             httpResponse.sendError(HttpServletResponse.SC_BAD_REQUEST, message);
 151                             return;
 152                         }
 153                         if (excludeAAF.equalsIgnoreCase("true")) { //Check to add legacy subscriber to AAF Feed
 154                             String message = "DRProvCadiFilter - add legacy subscriber to AAF Feed, FeedID:" + feedId;
 155                             elr.setMessage(message);
 156                             eventlogger.info(elr.toString());
 157                             chain.doFilter(request, response);
 158                         } else {
 159                             String message = "DRProvCadiFilter - Add AAF subscriber to AAF Feed, FeedID:"
 160                                                      + feedId + ":" + "AAF Instance -" + aafInstance;
 161                             elr.setMessage(message);
 162                             eventlogger.info(elr.toString());
 163                             super.doFilter(request, response, chain);
 164                         }
 165                     } else { //Add legacy susbcriber to legacy Feed
 166                         String message = "DRProvCadiFilter - add legacy subscriber to legacy Feed:" + feedId;
 167                         elr.setMessage(message);
 168                         eventlogger.info(elr.toString());
 169                         chain.doFilter(request, response);
 170                     }
 171                 } else { //add AAF feed
 172                     if (excludeAAF == null) {
 173                         String message = "DRProvCadiFilter -Invalid request Header Parmeter "
 174                                                  + BaseServlet.EXCLUDE_AAF_HEADER
 175                                                  + " = " + httpRequest.getHeader(BaseServlet.EXCLUDE_AAF_HEADER);
 176                         elr.setMessage(message);
 177                         elr.setResult(HttpServletResponse.SC_BAD_REQUEST);
 178                         eventlogger.error(elr.toString());
 179                         httpResponse.sendError(HttpServletResponse.SC_BAD_REQUEST, message);
 180                         return;
 181                     }
 182                     if (excludeAAF.equalsIgnoreCase("true")) { //add legacy feed
 183                         String message = "DRProvCadiFilter - Create new legacy Feed : EXCLUDE_AAF = " + excludeAAF;
 184                         elr.setMessage(message);
 185                         eventlogger.info(elr.toString());
 186                         chain.doFilter(request, response);
 187                     } else { //add AAF Feed
 188                         String message = "DRProvCadiFilter - Create new AAF Feed : EXCLUDE_AAF = " + excludeAAF;
 189                         elr.setMessage(message);
 190                         eventlogger.info(elr.toString());
 191                         super.doFilter(request, response, chain);
 192                     }
 193                 }
 194             }
 195         } else {
 196             //All other requests default to (Non CADI) legacy
 197             chain.doFilter(request, response);
 198         }
 199     }
 200
 201     /**
 202      * Check if it is AAF feed OR existing feed.
 203      *
 204      * @param feedId the Feed ID
 205      * @return true if it is valid
 206      */
 207     @SuppressWarnings("resource")
 208     private boolean isAAFFeed(int feedId) {
 209         try {
 210             Feed feed = Feed.getFeedById(feedId);
 211             if (feed != null) {
 212                 if (!(("legacy".equalsIgnoreCase(feed.getAafInstance())) || feed.getAafInstance() == null
 213                               || feed.getAafInstance().equals(""))) { //also apply null check and empty check too
 214                     aafInstance = feed.getAafInstance();
 215                     String message = "DRProvCadiFilter.isAAFFeed: aafInstance-:" + aafInstance + "; feedId:- " + feedId;
 216                     intlogger.debug(message);
 217                     return true;
 218                 } else {
 219                     return false;
 220                 }
 221             } else {
 222                 String message = "DRProvCadiFilter.isAAFFeed; Feed does not exist FeedID:-" + feedId;
 223                 intlogger.debug(message);
 224             }
 225
 226         } catch (Exception e) {
 227             intlogger.error("PROV0073 DRProvCadiFilter.isAAFFeed: " + e.getMessage(), e);
 228             return false;
 229         }
 230         return false;
 231     }
 232
 233     /**
 234      * Check if it is AAF sub OR existing sub.
 235      *
 236      * @param subId the Sub ID
 237      * @return true if it is valid
 238      */
 239     @SuppressWarnings("resource")
 240     private boolean isAAFSubscriber(int subId) {
 241         try {
 242             Subscription subscriber = Subscription.getSubscriptionById(subId);
 243             if (subscriber != null) {
 244                 if (!(("legacy".equalsIgnoreCase(subscriber.getAafInstance()))
 245                               || subscriber.getAafInstance() == null
 246                               || "".equals(subscriber.getAafInstance()))) { //also apply null check and empty check too
 247                     aafInstance = subscriber.getAafInstance();
 248                     String message = "DRProvCadiFilter.isAAFSubscriber: aafInstance-:" + aafInstance + "; subId:- "
 249                                              + subId;
 250                     intlogger.debug(message);
 251                     return true;
 252                 } else {
 253                     return false;
 254                 }
 255             } else {
 256                 String message = "DRProvCadiFilter.isAAFSubscriber; Subscriber does not exist subId:-" + subId;
 257                 intlogger.debug(message);
 258             }
 259         } catch (Exception e) {
 260             intlogger.error("PROV0073 DRProvCadiFilter.isAAFSubscriber: " + e.getMessage(), e);
 261             return false;
 262         }
 263         return false;
 264     }
 265
 266 }