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

   1 /*******************************************************************************
   2  * ============LICENSE_START==================================================
   3  * * org.onap.dmaap
   4  * * ===========================================================================
   5  * * Copyright © 2017 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  * * ECOMP is a trademark and service mark of AT&T Intellectual Property.
  21  * *
  22  ******************************************************************************/
  23
  24
  25 package org.onap.dmaap.datarouter.provisioning;
  26
  27 import java.io.IOException;
  28 import java.io.InvalidObjectException;
  29 import java.util.List;
  30
  31 import javax.servlet.http.HttpServletRequest;
  32 import javax.servlet.http.HttpServletResponse;
  33
  34 import org.json.JSONObject;
  35 import org.onap.dmaap.datarouter.authz.AuthorizationResponse;
  36 import org.onap.dmaap.datarouter.provisioning.beans.EventLogRecord;
  37 import org.onap.dmaap.datarouter.provisioning.beans.Feed;
  38 import org.onap.dmaap.datarouter.provisioning.eelf.EelfMsgs;
  39 import org.onap.dmaap.datarouter.provisioning.utils.JSONUtilities;
  40
  41 import com.att.eelf.configuration.EELFLogger;
  42 import com.att.eelf.configuration.EELFManager;
  43
  44 import static org.onap.dmaap.datarouter.provisioning.utils.HttpServletUtils.sendResponseError;
  45
  46 /**
  47  * This servlet handles provisioning for the &lt;drFeedsURL&gt; which is the URL on the provisioning server used to
  48  * create new feeds.  It supports POST to create new feeds, and GET to support the Feeds Collection Query function.
  49  *
  50  * @author Robert Eby
  51  * @version $Id$
  52  */
  53 @SuppressWarnings("serial")
  54 public class DRFeedsServlet extends ProxyServlet {
  55
  56     //Adding EELF Logger Rally:US664892
  57     private static EELFLogger eelflogger = EELFManager.getInstance()
  58         .getLogger(DRFeedsServlet.class);
  59
  60     /**
  61      * DELETE on the &lt;drFeedsURL&gt; -- not supported.
  62      */
  63     @Override
  64     public void doDelete(HttpServletRequest req, HttpServletResponse resp) {
  65         setIpFqdnRequestIDandInvocationIDForEelf("doDelete", req);
  66         eelflogger.info(EelfMsgs.ENTRY);
  67         try {
  68             eelflogger.info(EelfMsgs.MESSAGE_WITH_BEHALF_AND_FEEDID, req.getHeader(BEHALF_HEADER), getIdFromPath(req) + "");
  69             String message = "DELETE not allowed for the drFeedsURL.";
  70             EventLogRecord elr = new EventLogRecord(req);
  71             elr.setMessage(message);
  72             elr.setResult(HttpServletResponse.SC_METHOD_NOT_ALLOWED);
  73             eventlogger.info(elr);
  74             sendResponseError(resp, HttpServletResponse.SC_METHOD_NOT_ALLOWED, message, eventlogger);
  75         } finally {
  76             eelflogger.info(EelfMsgs.EXIT);
  77         }
  78     }
  79
  80     /**
  81      * GET on the &lt;drFeedsURL&gt; -- query the list of feeds already existing in the DB. See the <i>Feeds Collection
  82      * Queries</i> section in the <b>Provisioning API</b> document for details on how this method should be invoked.
  83      */
  84     @Override
  85     public void doGet(HttpServletRequest req, HttpServletResponse resp) {
  86         setIpFqdnRequestIDandInvocationIDForEelf("doGet", req);
  87         eelflogger.info(EelfMsgs.ENTRY);
  88         try {
  89             eelflogger.info(EelfMsgs.MESSAGE_WITH_BEHALF_AND_FEEDID, req.getHeader(BEHALF_HEADER), getIdFromPath(req) + "");
  90             EventLogRecord elr = new EventLogRecord(req);
  91             String message = isAuthorizedForProvisioning(req);
  92             if (message != null) {
  93                 elr.setMessage(message);
  94                 elr.setResult(HttpServletResponse.SC_FORBIDDEN);
  95                 eventlogger.info(elr);
  96                 sendResponseError(resp, HttpServletResponse.SC_FORBIDDEN, message, eventlogger);
  97                 return;
  98             }
  99             if (isProxyServer()) {
 100                 super.doGet(req, resp);
 101                 return;
 102             }
 103             String bhdr = req.getHeader(BEHALF_HEADER);
 104             if (bhdr == null) {
 105                 message = "Missing " + BEHALF_HEADER + " header.";
 106                 elr.setMessage(message);
 107                 elr.setResult(HttpServletResponse.SC_BAD_REQUEST);
 108                 eventlogger.info(elr);
 109                 sendResponseError(resp, HttpServletResponse.SC_BAD_REQUEST, message, eventlogger);
 110                 return;
 111             }
 112             String path = req
 113                     .getRequestURI(); // Note: I think this should be getPathInfo(), but that doesn't work (Jetty bug?)
 114             if (path != null && !path.equals("/")) {
 115                 message = "Bad URL.";
 116                 elr.setMessage(message);
 117                 elr.setResult(HttpServletResponse.SC_NOT_FOUND);
 118                 eventlogger.info(elr);
 119                 sendResponseError(resp, HttpServletResponse.SC_NOT_FOUND, message, eventlogger);
 120                 return;
 121             }
 122             // Check with the Authorizer
 123             AuthorizationResponse aresp = authz.decide(req);
 124             if (!aresp.isAuthorized()) {
 125                 message = "Policy Engine disallows access.";
 126                 elr.setMessage(message);
 127                 elr.setResult(HttpServletResponse.SC_FORBIDDEN);
 128                 eventlogger.info(elr);
 129                 sendResponseError(resp, HttpServletResponse.SC_FORBIDDEN, message, eventlogger);
 130                 return;
 131             }
 132
 133             String name = req.getParameter("name");
 134             String vers = req.getParameter("version");
 135             String publ = req.getParameter("publisher");
 136             String subs = req.getParameter("subscriber");
 137             if (name != null && vers != null) {
 138                 // Display a specific feed
 139                 Feed feed = Feed.getFeedByNameVersion(name, vers);
 140                 if (feed == null || feed.isDeleted()) {
 141                     message = "This feed does not exist in the database.";
 142                     elr.setMessage(message);
 143                     elr.setResult(HttpServletResponse.SC_BAD_REQUEST);
 144                     eventlogger.info(elr);
 145                     sendResponseError(resp, HttpServletResponse.SC_BAD_REQUEST, message, eventlogger);
 146                 } else {
 147                     // send response
 148                     elr.setResult(HttpServletResponse.SC_OK);
 149                     eventlogger.info(elr);
 150                     resp.setStatus(HttpServletResponse.SC_OK);
 151                     resp.setContentType(FEEDFULL_CONTENT_TYPE);
 152                     try {
 153                         resp.getOutputStream().print(feed.asJSONObject(true).toString());
 154                     } catch (IOException ioe) {
 155                         eventlogger.error("IOException" + ioe.getMessage());
 156                     }
 157                 }
 158             } else {
 159                 // Display a list of URLs
 160                 List<String> list = null;
 161                 if (name != null) {
 162                     list = Feed.getFilteredFeedUrlList("name", name);
 163                 } else if (publ != null) {
 164                     list = Feed.getFilteredFeedUrlList("publ", publ);
 165                 } else if (subs != null) {
 166                     list = Feed.getFilteredFeedUrlList("subs", subs);
 167                 } else {
 168                     list = Feed.getFilteredFeedUrlList("all", null);
 169                 }
 170                 String t = JSONUtilities.createJSONArray(list);
 171                 // send response
 172                 elr.setResult(HttpServletResponse.SC_OK);
 173                 eventlogger.info(elr);
 174                 resp.setStatus(HttpServletResponse.SC_OK);
 175                 resp.setContentType(FEEDLIST_CONTENT_TYPE);
 176                 try {
 177                     resp.getOutputStream().print(t);
 178                 } catch (IOException ioe) {
 179                     eventlogger.error("IOException" + ioe.getMessage());
 180                 }
 181             }
 182         } finally {
 183             eelflogger.info(EelfMsgs.EXIT);
 184         }
 185     }
 186
 187     /**
 188      * PUT on the &lt;drFeedsURL&gt; -- not supported.
 189      */
 190     @Override
 191     public void doPut(HttpServletRequest req, HttpServletResponse resp) {
 192         setIpFqdnRequestIDandInvocationIDForEelf("doPut", req);
 193         eelflogger.info(EelfMsgs.ENTRY);
 194         try {
 195             eelflogger.info(EelfMsgs.MESSAGE_WITH_BEHALF_AND_FEEDID, req.getHeader(BEHALF_HEADER), getIdFromPath(req) + "");
 196             String message = "PUT not allowed for the drFeedsURL.";
 197             EventLogRecord elr = new EventLogRecord(req);
 198             elr.setMessage(message);
 199             elr.setResult(HttpServletResponse.SC_METHOD_NOT_ALLOWED);
 200             eventlogger.info(elr);
 201             sendResponseError(resp, HttpServletResponse.SC_METHOD_NOT_ALLOWED, message, eventlogger);
 202         } finally {
 203             eelflogger.info(EelfMsgs.EXIT);
 204         }
 205     }
 206
 207     /**
 208      * POST on the &lt;drFeedsURL&gt; -- create a new feed. See the <i>Creating a Feed</i> section in the
 209      * <b>Provisioning API</b> document for details on how this method should be invoked.
 210      */
 211     @Override
 212     public void doPost(HttpServletRequest req, HttpServletResponse resp) {
 213         setIpFqdnRequestIDandInvocationIDForEelf("doPost", req);
 214         eelflogger.info(EelfMsgs.ENTRY);
 215         try {
 216             eelflogger.info(EelfMsgs.MESSAGE_WITH_BEHALF, req.getHeader(BEHALF_HEADER));
 217             EventLogRecord elr = new EventLogRecord(req);
 218             String message = isAuthorizedForProvisioning(req);
 219             if (message != null) {
 220                 elr.setMessage(message);
 221                 elr.setResult(HttpServletResponse.SC_FORBIDDEN);
 222                 eventlogger.info(elr);
 223                 sendResponseError(resp, HttpServletResponse.SC_FORBIDDEN, message, eventlogger);
 224                 return;
 225             }
 226             if (isProxyServer()) {
 227                 super.doPost(req, resp);
 228                 return;
 229             }
 230             String bhdr = req.getHeader(BEHALF_HEADER);
 231             if (bhdr == null) {
 232                 message = "Missing " + BEHALF_HEADER + " header.";
 233                 elr.setMessage(message);
 234                 elr.setResult(HttpServletResponse.SC_BAD_REQUEST);
 235                 eventlogger.info(elr);
 236                 sendResponseError(resp, HttpServletResponse.SC_BAD_REQUEST, message, eventlogger);
 237                 return;
 238             }
 239             String path = req
 240                     .getRequestURI(); // Note: I think this should be getPathInfo(), but that doesn't work (Jetty bug?)
 241             if (path != null && !path.equals("/")) {
 242                 message = "Bad URL.";
 243                 elr.setMessage(message);
 244                 elr.setResult(HttpServletResponse.SC_NOT_FOUND);
 245                 eventlogger.info(elr);
 246                 sendResponseError(resp, HttpServletResponse.SC_NOT_FOUND, message, eventlogger);
 247                 return;
 248             }
 249             // check content type is FEED_CONTENT_TYPE, version 1.0
 250             ContentHeader ch = getContentHeader(req);
 251             String ver = ch.getAttribute("version");
 252             if (!ch.getType().equals(FEED_BASECONTENT_TYPE) || !(ver.equals("1.0") || ver.equals("2.0"))) {
 253                 message = "Incorrect content-type";
 254                 elr.setMessage(message);
 255                 elr.setResult(HttpServletResponse.SC_UNSUPPORTED_MEDIA_TYPE);
 256                 eventlogger.info(elr);
 257                 sendResponseError(resp, HttpServletResponse.SC_UNSUPPORTED_MEDIA_TYPE, message, eventlogger);
 258                 return;
 259             }
 260             // Check with the Authorizer
 261             AuthorizationResponse aresp = authz.decide(req);
 262             if (!aresp.isAuthorized()) {
 263                 message = "Policy Engine disallows access.";
 264                 elr.setMessage(message);
 265                 elr.setResult(HttpServletResponse.SC_FORBIDDEN);
 266                 eventlogger.info(elr);
 267                 sendResponseError(resp, HttpServletResponse.SC_FORBIDDEN, message, eventlogger);
 268                 return;
 269             }
 270             JSONObject jo = getJSONfromInput(req);
 271             if (jo == null) {
 272                 message = "Badly formed JSON";
 273                 elr.setMessage(message);
 274                 elr.setResult(HttpServletResponse.SC_BAD_REQUEST);
 275                 eventlogger.info(elr);
 276                 sendResponseError(resp, HttpServletResponse.SC_BAD_REQUEST, message, eventlogger);
 277                 return;
 278             }
 279             if (intlogger.isDebugEnabled()) {
 280                 intlogger.debug(jo.toString());
 281             }
 282             if (++activeFeeds > maxFeeds) {
 283                 activeFeeds--;
 284                 message = "Cannot create feed; the maximum number of feeds has been configured.";
 285                 elr.setMessage(message);
 286                 elr.setResult(HttpServletResponse.SC_CONFLICT);
 287                 eventlogger.info(elr);
 288                 sendResponseError(resp, HttpServletResponse.SC_CONFLICT, message, eventlogger);
 289                 return;
 290             }
 291             Feed feed = null;
 292             try {
 293                 feed = new Feed(jo);
 294             } catch (InvalidObjectException e) {
 295                 message = e.getMessage();
 296                 elr.setMessage(message);
 297                 elr.setResult(HttpServletResponse.SC_BAD_REQUEST);
 298                 eventlogger.info(elr);
 299                 sendResponseError(resp, HttpServletResponse.SC_BAD_REQUEST, message, eventlogger);
 300                 return;
 301             }
 302             feed.setPublisher(bhdr);    // set from X-ATT-DR-ON-BEHALF-OF header
 303
 304             // Check if this feed already exists
 305             Feed feed2 = Feed.getFeedByNameVersion(feed.getName(), feed.getVersion());
 306             if (feed2 != null) {
 307                 message = "This feed already exists in the database.";
 308                 elr.setMessage(message);
 309                 elr.setResult(HttpServletResponse.SC_BAD_REQUEST);
 310                 eventlogger.info(elr);
 311                 sendResponseError(resp, HttpServletResponse.SC_BAD_REQUEST, message, eventlogger);
 312                 return;
 313             }
 314
 315             // Create FEED table entries
 316             if (doInsert(feed)) {
 317                 // send response
 318                 elr.setResult(HttpServletResponse.SC_CREATED);
 319                 eventlogger.info(elr);
 320                 resp.setStatus(HttpServletResponse.SC_CREATED);
 321                 resp.setContentType(FEEDFULL_CONTENT_TYPE);
 322                 resp.setHeader("Location", feed.getLinks().getSelf());
 323                 try {
 324                     resp.getOutputStream().print(feed.asLimitedJSONObject().toString());
 325                 } catch (IOException ioe) {
 326                     eventlogger.error("IOException" + ioe.getMessage());
 327                 }
 328                 provisioningDataChanged();
 329             } else {
 330                 // Something went wrong with the INSERT
 331                 elr.setResult(HttpServletResponse.SC_INTERNAL_SERVER_ERROR);
 332                 eventlogger.info(elr);
 333                 sendResponseError(resp, HttpServletResponse.SC_INTERNAL_SERVER_ERROR, DB_PROBLEM_MSG, eventlogger);
 334             }
 335         } finally {
 336             eelflogger.info(EelfMsgs.EXIT);
 337         }
 338     }
 339 }